From: Piotr Ożarowski Date: Tue, 10 Jan 2017 19:19:24 +0000 (+0000) Subject: Import asyncpg_0.8.4.orig.tar.gz X-Git-Tag: archive/raspbian/0.21.0-1+rpi1~1^2^2^2~1 X-Git-Url: https://dgit.raspbian.org/?a=commitdiff_plain;h=cc110f5fda9e5a12c42bda64b5a48cbc848ef242;p=asyncpg.git Import asyncpg_0.8.4.orig.tar.gz [dgit import orig asyncpg_0.8.4.orig.tar.gz] --- cc110f5fda9e5a12c42bda64b5a48cbc848ef242 diff --git a/LICENSE b/LICENSE new file mode 100644 index 0000000..418b71e --- /dev/null +++ b/LICENSE @@ -0,0 +1,189 @@ + Copyright (c) 2016-present MagicStack Inc. http://magic.io + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. + + + Apache License + Version 2.0, January 2004 + http://www.apache.org/licenses/ + + TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION + + 1. Definitions. + + "License" shall mean the terms and conditions for use, reproduction, + and distribution as defined by Sections 1 through 9 of this document. + + "Licensor" shall mean the copyright owner or entity authorized by + the copyright owner that is granting the License. + + "Legal Entity" shall mean the union of the acting entity and all + other entities that control, are controlled by, or are under common + control with that entity. For the purposes of this definition, + "control" means (i) the power, direct or indirect, to cause the + direction or management of such entity, whether by contract or + otherwise, or (ii) ownership of fifty percent (50%) or more of the + outstanding shares, or (iii) beneficial ownership of such entity. + + "You" (or "Your") shall mean an individual or Legal Entity + exercising permissions granted by this License. + + "Source" form shall mean the preferred form for making modifications, + including but not limited to software source code, documentation + source, and configuration files. + + "Object" form shall mean any form resulting from mechanical + transformation or translation of a Source form, including but + not limited to compiled object code, generated documentation, + and conversions to other media types. + + "Work" shall mean the work of authorship, whether in Source or + Object form, made available under the License, as indicated by a + copyright notice that is included in or attached to the work + (an example is provided in the Appendix below). + + "Derivative Works" shall mean any work, whether in Source or Object + form, that is based on (or derived from) the Work and for which the + editorial revisions, annotations, elaborations, or other modifications + represent, as a whole, an original work of authorship. For the purposes + of this License, Derivative Works shall not include works that remain + separable from, or merely link (or bind by name) to the interfaces of, + the Work and Derivative Works thereof. + + "Contribution" shall mean any work of authorship, including + the original version of the Work and any modifications or additions + to that Work or Derivative Works thereof, that is intentionally + submitted to Licensor for inclusion in the Work by the copyright owner + or by an individual or Legal Entity authorized to submit on behalf of + the copyright owner. For the purposes of this definition, "submitted" + means any form of electronic, verbal, or written communication sent + to the Licensor or its representatives, including but not limited to + communication on electronic mailing lists, source code control systems, + and issue tracking systems that are managed by, or on behalf of, the + Licensor for the purpose of discussing and improving the Work, but + excluding communication that is conspicuously marked or otherwise + designated in writing by the copyright owner as "Not a Contribution." + + "Contributor" shall mean Licensor and any individual or Legal Entity + on behalf of whom a Contribution has been received by Licensor and + subsequently incorporated within the Work. + + 2. Grant of Copyright License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + copyright license to reproduce, prepare Derivative Works of, + publicly display, publicly perform, sublicense, and distribute the + Work and such Derivative Works in Source or Object form. + + 3. Grant of Patent License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + (except as stated in this section) patent license to make, have made, + use, offer to sell, sell, import, and otherwise transfer the Work, + where such license applies only to those patent claims licensable + by such Contributor that are necessarily infringed by their + Contribution(s) alone or by combination of their Contribution(s) + with the Work to which such Contribution(s) was submitted. If You + institute patent litigation against any entity (including a + cross-claim or counterclaim in a lawsuit) alleging that the Work + or a Contribution incorporated within the Work constitutes direct + or contributory patent infringement, then any patent licenses + granted to You under this License for that Work shall terminate + as of the date such litigation is filed. + + 4. Redistribution. You may reproduce and distribute copies of the + Work or Derivative Works thereof in any medium, with or without + modifications, and in Source or Object form, provided that You + meet the following conditions: + + (a) You must give any other recipients of the Work or + Derivative Works a copy of this License; and + + (b) You must cause any modified files to carry prominent notices + stating that You changed the files; and + + (c) You must retain, in the Source form of any Derivative Works + that You distribute, all copyright, patent, trademark, and + attribution notices from the Source form of the Work, + excluding those notices that do not pertain to any part of + the Derivative Works; and + + (d) If the Work includes a "NOTICE" text file as part of its + distribution, then any Derivative Works that You distribute must + include a readable copy of the attribution notices contained + within such NOTICE file, excluding those notices that do not + pertain to any part of the Derivative Works, in at least one + of the following places: within a NOTICE text file distributed + as part of the Derivative Works; within the Source form or + documentation, if provided along with the Derivative Works; or, + within a display generated by the Derivative Works, if and + wherever such third-party notices normally appear. The contents + of the NOTICE file are for informational purposes only and + do not modify the License. You may add Your own attribution + notices within Derivative Works that You distribute, alongside + or as an addendum to the NOTICE text from the Work, provided + that such additional attribution notices cannot be construed + as modifying the License. + + You may add Your own copyright statement to Your modifications and + may provide additional or different license terms and conditions + for use, reproduction, or distribution of Your modifications, or + for any such Derivative Works as a whole, provided Your use, + reproduction, and distribution of the Work otherwise complies with + the conditions stated in this License. + + 5. Submission of Contributions. Unless You explicitly state otherwise, + any Contribution intentionally submitted for inclusion in the Work + by You to the Licensor shall be under the terms and conditions of + this License, without any additional terms or conditions. + Notwithstanding the above, nothing herein shall supersede or modify + the terms of any separate license agreement you may have executed + with Licensor regarding such Contributions. + + 6. Trademarks. This License does not grant permission to use the trade + names, trademarks, service marks, or product names of the Licensor, + except as required for reasonable and customary use in describing the + origin of the Work and reproducing the content of the NOTICE file. + + 7. Disclaimer of Warranty. Unless required by applicable law or + agreed to in writing, Licensor provides the Work (and each + Contributor provides its Contributions) on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or + implied, including, without limitation, any warranties or conditions + of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A + PARTICULAR PURPOSE. You are solely responsible for determining the + appropriateness of using or redistributing the Work and assume any + risks associated with Your exercise of permissions under this License. + + 8. Limitation of Liability. In no event and under no legal theory, + whether in tort (including negligence), contract, or otherwise, + unless required by applicable law (such as deliberate and grossly + negligent acts) or agreed to in writing, shall any Contributor be + liable to You for damages, including any direct, indirect, special, + incidental, or consequential damages of any character arising as a + result of this License or out of the use or inability to use the + Work (including but not limited to damages for loss of goodwill, + work stoppage, computer failure or malfunction, or any and all + other commercial damages or losses), even if such Contributor + has been advised of the possibility of such damages. + + 9. Accepting Warranty or Additional Liability. While redistributing + the Work or Derivative Works thereof, You may choose to offer, + and charge a fee for, acceptance of support, warranty, indemnity, + or other liability obligations and/or rights consistent with this + License. However, in accepting such obligations, You may act only + on Your own behalf and on Your sole responsibility, not on behalf + of any other Contributor, and only if You agree to indemnify, + defend, and hold each Contributor harmless for any liability + incurred by, or claims asserted against, such Contributor by reason + of your accepting any such warranty or additional liability. diff --git a/MANIFEST.in b/MANIFEST.in new file mode 100644 index 0000000..e4cfbc3 --- /dev/null +++ b/MANIFEST.in @@ -0,0 +1,5 @@ +recursive-include docs *.py *.rst +recursive-include examples *.py +recursive-include tests *.py *.pem +recursive-include asyncpg *.pyx *.pxd *.pxi *.py *.c *.h +include LICENSE README.rst Makefile performance.png diff --git a/Makefile b/Makefile new file mode 100644 index 0000000..2f310e4 --- /dev/null +++ b/Makefile @@ -0,0 +1,49 @@ +.PHONY: compile debug test quicktest clean all + + +PYTHON ?= python + + +all: compile + + +clean: + rm -fr dist/ doc/_build/ + rm -fr asyncpg/protocol/*.c asyncpg/protocol/*.html + rm -fr asyncpg/protocol/*.so build *.egg-info + rm -fr asyncpg/protocol/codecs/*.html + find . -name '__pycache__' | xargs rm -rf + + +compile: + $(PYTHON) setup.py build_ext --inplace --cython-always + + +debug: + $(PYTHON) setup.py build_ext --inplace --debug \ + --cython-always \ + --cython-annotate \ + --cython-directives="linetrace=True" \ + --define ASYNCPG_DEBUG,CYTHON_TRACE,CYTHON_TRACE_NOGIL + + +test: + PYTHONASYNCIODEBUG=1 $(PYTHON) -m unittest discover -s tests + $(PYTHON) -m unittest discover -s tests + USE_UVLOOP=1 $(PYTHON) -m unittest discover -s tests + + +quicktest: + $(PYTHON) -m unittest discover -s tests + + +sdist: clean compile test + $(PYTHON) setup.py sdist + + +release: clean compile test + $(PYTHON) setup.py sdist upload + + +htmldocs: compile + $(MAKE) -C docs html diff --git a/PKG-INFO b/PKG-INFO new file mode 100644 index 0000000..eef00cf --- /dev/null +++ b/PKG-INFO @@ -0,0 +1,110 @@ +Metadata-Version: 1.1 +Name: asyncpg +Version: 0.8.4 +Summary: An asyncio PosgtreSQL driver +Home-page: https://github.com/MagicStack/asyncpg +Author: MagicStack Inc +Author-email: hello@magic.io +License: Apache License, Version 2.0 +Description: asyncpg -- A fast PostgreSQL Database Client Library for Python/asyncio + ======================================================================= + + .. image:: https://travis-ci.org/MagicStack/asyncpg.svg?branch=master + :target: https://travis-ci.org/MagicStack/asyncpg + + .. image:: https://ci.appveyor.com/api/projects/status/9rwppnxphgc8bqoj/branch/master?svg=true + :target: https://ci.appveyor.com/project/magicstack/asyncpg + + .. image:: https://img.shields.io/pypi/v/asyncpg.svg + :target: https://pypi.python.org/pypi/asyncpg + + **asyncpg** is a database interface library designed specifically for + PostgreSQL and Python/asyncio. asyncpg is an efficient, clean implementation + of PostgreSQL server binary protocol for use with Python's ``asyncio`` + framework. You can read more about asyncpg in an introductory + `blog post `_. + + asyncpg requires Python 3.5 or later and is supported for PostgreSQL + versions 9.1 to 9.6. + + + Documentation + ------------- + + The project documentation can be found + `here `_. + + + Performance + ----------- + + In our testing asyncpg is, on average, **3x** faster than psycopg2 + (and its asyncio variant -- aiopg). + + .. image:: performance.png + :target: http://magic.io/blog/asyncpg-1m-rows-from-postgres-to-python/ + + The above results are a geometric mean of benchmarks obtained with PostgreSQL + `client driver benchmarking toolbench `_. + + + Features + -------- + + asyncpg implements PostgreSQL server protocol natively and exposes its + features directly, as opposed to hiding them behind a generic facade + like DB-API. + + This enables asyncpg to have easy-to-use support for: + + * **prepared statements** + * **scrollable cursors** + * **partial iteration** on query results + * automatic encoding and decoding of composite types, arrays, + and any combination of those + * straightforward support for custom data types + + + Installation + ------------ + + asyncpg is available on PyPI and has no dependencies. + Use pip to install:: + + $ pip install asyncpg + + + Basic Usage + ----------- + + .. code-block:: python + + import asyncio + import asyncpg + + async def run(): + conn = await asyncpg.connect(user='user', password='password', + database='database', host='127.0.0.1') + values = await conn.fetch('''SELECT * FROM mytable''') + await conn.close() + + loop = asyncio.get_event_loop() + loop.run_until_complete(run()) + + + License + ------- + + asyncpg is developed and distributed under the Apache 2.0 license. + +Platform: POSIX +Classifier: License :: OSI Approved :: Apache Software License +Classifier: Intended Audience :: Developers +Classifier: Programming Language :: Python :: 3 :: Only +Classifier: Programming Language :: Python :: 3.5 +Classifier: Programming Language :: Python :: 3.6 +Classifier: Operating System :: POSIX +Classifier: Operating System :: MacOS :: MacOS X +Classifier: Operating System :: Microsoft :: Windows +Classifier: Development Status :: 4 - Beta +Provides: asyncpg diff --git a/README.rst b/README.rst new file mode 100644 index 0000000..8730e0f --- /dev/null +++ b/README.rst @@ -0,0 +1,90 @@ +asyncpg -- A fast PostgreSQL Database Client Library for Python/asyncio +======================================================================= + +.. image:: https://travis-ci.org/MagicStack/asyncpg.svg?branch=master + :target: https://travis-ci.org/MagicStack/asyncpg + +.. image:: https://ci.appveyor.com/api/projects/status/9rwppnxphgc8bqoj/branch/master?svg=true + :target: https://ci.appveyor.com/project/magicstack/asyncpg + +.. image:: https://img.shields.io/pypi/v/asyncpg.svg + :target: https://pypi.python.org/pypi/asyncpg + +**asyncpg** is a database interface library designed specifically for +PostgreSQL and Python/asyncio. asyncpg is an efficient, clean implementation +of PostgreSQL server binary protocol for use with Python's ``asyncio`` +framework. You can read more about asyncpg in an introductory +`blog post `_. + +asyncpg requires Python 3.5 or later and is supported for PostgreSQL +versions 9.1 to 9.6. + + +Documentation +------------- + +The project documentation can be found +`here `_. + + +Performance +----------- + +In our testing asyncpg is, on average, **3x** faster than psycopg2 +(and its asyncio variant -- aiopg). + +.. image:: performance.png + :target: http://magic.io/blog/asyncpg-1m-rows-from-postgres-to-python/ + +The above results are a geometric mean of benchmarks obtained with PostgreSQL +`client driver benchmarking toolbench `_. + + +Features +-------- + +asyncpg implements PostgreSQL server protocol natively and exposes its +features directly, as opposed to hiding them behind a generic facade +like DB-API. + +This enables asyncpg to have easy-to-use support for: + +* **prepared statements** +* **scrollable cursors** +* **partial iteration** on query results +* automatic encoding and decoding of composite types, arrays, + and any combination of those +* straightforward support for custom data types + + +Installation +------------ + +asyncpg is available on PyPI and has no dependencies. +Use pip to install:: + + $ pip install asyncpg + + +Basic Usage +----------- + +.. code-block:: python + + import asyncio + import asyncpg + + async def run(): + conn = await asyncpg.connect(user='user', password='password', + database='database', host='127.0.0.1') + values = await conn.fetch('''SELECT * FROM mytable''') + await conn.close() + + loop = asyncio.get_event_loop() + loop.run_until_complete(run()) + + +License +------- + +asyncpg is developed and distributed under the Apache 2.0 license. diff --git a/asyncpg.egg-info/PKG-INFO b/asyncpg.egg-info/PKG-INFO new file mode 100644 index 0000000..eef00cf --- /dev/null +++ b/asyncpg.egg-info/PKG-INFO @@ -0,0 +1,110 @@ +Metadata-Version: 1.1 +Name: asyncpg +Version: 0.8.4 +Summary: An asyncio PosgtreSQL driver +Home-page: https://github.com/MagicStack/asyncpg +Author: MagicStack Inc +Author-email: hello@magic.io +License: Apache License, Version 2.0 +Description: asyncpg -- A fast PostgreSQL Database Client Library for Python/asyncio + ======================================================================= + + .. image:: https://travis-ci.org/MagicStack/asyncpg.svg?branch=master + :target: https://travis-ci.org/MagicStack/asyncpg + + .. image:: https://ci.appveyor.com/api/projects/status/9rwppnxphgc8bqoj/branch/master?svg=true + :target: https://ci.appveyor.com/project/magicstack/asyncpg + + .. image:: https://img.shields.io/pypi/v/asyncpg.svg + :target: https://pypi.python.org/pypi/asyncpg + + **asyncpg** is a database interface library designed specifically for + PostgreSQL and Python/asyncio. asyncpg is an efficient, clean implementation + of PostgreSQL server binary protocol for use with Python's ``asyncio`` + framework. You can read more about asyncpg in an introductory + `blog post `_. + + asyncpg requires Python 3.5 or later and is supported for PostgreSQL + versions 9.1 to 9.6. + + + Documentation + ------------- + + The project documentation can be found + `here `_. + + + Performance + ----------- + + In our testing asyncpg is, on average, **3x** faster than psycopg2 + (and its asyncio variant -- aiopg). + + .. image:: performance.png + :target: http://magic.io/blog/asyncpg-1m-rows-from-postgres-to-python/ + + The above results are a geometric mean of benchmarks obtained with PostgreSQL + `client driver benchmarking toolbench `_. + + + Features + -------- + + asyncpg implements PostgreSQL server protocol natively and exposes its + features directly, as opposed to hiding them behind a generic facade + like DB-API. + + This enables asyncpg to have easy-to-use support for: + + * **prepared statements** + * **scrollable cursors** + * **partial iteration** on query results + * automatic encoding and decoding of composite types, arrays, + and any combination of those + * straightforward support for custom data types + + + Installation + ------------ + + asyncpg is available on PyPI and has no dependencies. + Use pip to install:: + + $ pip install asyncpg + + + Basic Usage + ----------- + + .. code-block:: python + + import asyncio + import asyncpg + + async def run(): + conn = await asyncpg.connect(user='user', password='password', + database='database', host='127.0.0.1') + values = await conn.fetch('''SELECT * FROM mytable''') + await conn.close() + + loop = asyncio.get_event_loop() + loop.run_until_complete(run()) + + + License + ------- + + asyncpg is developed and distributed under the Apache 2.0 license. + +Platform: POSIX +Classifier: License :: OSI Approved :: Apache Software License +Classifier: Intended Audience :: Developers +Classifier: Programming Language :: Python :: 3 :: Only +Classifier: Programming Language :: Python :: 3.5 +Classifier: Programming Language :: Python :: 3.6 +Classifier: Operating System :: POSIX +Classifier: Operating System :: MacOS :: MacOS X +Classifier: Operating System :: Microsoft :: Windows +Classifier: Development Status :: 4 - Beta +Provides: asyncpg diff --git a/asyncpg.egg-info/SOURCES.txt b/asyncpg.egg-info/SOURCES.txt new file mode 100644 index 0000000..1a18c5c --- /dev/null +++ b/asyncpg.egg-info/SOURCES.txt @@ -0,0 +1,87 @@ +LICENSE +MANIFEST.in +Makefile +README.rst +performance.png +setup.py +asyncpg/__init__.py +asyncpg/_testbase.py +asyncpg/cluster.py +asyncpg/compat.py +asyncpg/connection.py +asyncpg/cursor.py +asyncpg/introspection.py +asyncpg/pool.py +asyncpg/prepared_stmt.py +asyncpg/serverversion.py +asyncpg/transaction.py +asyncpg/types.py +asyncpg.egg-info/PKG-INFO +asyncpg.egg-info/SOURCES.txt +asyncpg.egg-info/dependency_links.txt +asyncpg.egg-info/top_level.txt +asyncpg/exceptions/__init__.py +asyncpg/exceptions/_base.py +asyncpg/protocol/__init__.py +asyncpg/protocol/buffer.pxd +asyncpg/protocol/buffer.pyx +asyncpg/protocol/consts.pxi +asyncpg/protocol/coreproto.pxd +asyncpg/protocol/coreproto.pyx +asyncpg/protocol/debug.h +asyncpg/protocol/debug.pxd +asyncpg/protocol/encodings.pyx +asyncpg/protocol/hton.pxd +asyncpg/protocol/pgtypes.pxi +asyncpg/protocol/prepared_stmt.pxd +asyncpg/protocol/prepared_stmt.pyx +asyncpg/protocol/protocol.c +asyncpg/protocol/protocol.pxd +asyncpg/protocol/protocol.pyx +asyncpg/protocol/python.pxd +asyncpg/protocol/settings.pxd +asyncpg/protocol/settings.pyx +asyncpg/protocol/codecs/__init__.py +asyncpg/protocol/codecs/array.pyx +asyncpg/protocol/codecs/base.pxd +asyncpg/protocol/codecs/base.pyx +asyncpg/protocol/codecs/bits.pyx +asyncpg/protocol/codecs/bytea.pyx +asyncpg/protocol/codecs/datetime.pyx +asyncpg/protocol/codecs/float.pyx +asyncpg/protocol/codecs/geometry.pyx +asyncpg/protocol/codecs/hstore.pyx +asyncpg/protocol/codecs/int.pyx +asyncpg/protocol/codecs/json.pyx +asyncpg/protocol/codecs/misc.pyx +asyncpg/protocol/codecs/money.pyx +asyncpg/protocol/codecs/network.pyx +asyncpg/protocol/codecs/numeric.pyx +asyncpg/protocol/codecs/range.pyx +asyncpg/protocol/codecs/record.pyx +asyncpg/protocol/codecs/text.pyx +asyncpg/protocol/codecs/textutils.pyx +asyncpg/protocol/codecs/tsearch.pyx +asyncpg/protocol/codecs/txid.pyx +asyncpg/protocol/codecs/uuid.pyx +asyncpg/protocol/record/__init__.pxd +asyncpg/protocol/record/recordobj.c +asyncpg/protocol/record/recordobj.h +docs/conf.py +docs/examples.rst +docs/index.rst +docs/installation.rst +docs/api/index.rst +tests/test_cancellation.py +tests/test_codecs.py +tests/test_connect.py +tests/test_cursor.py +tests/test_exceptions.py +tests/test_execute.py +tests/test_listeners.py +tests/test_pool.py +tests/test_prepare.py +tests/test_record.py +tests/test_test.py +tests/test_timeout.py +tests/test_transaction.py \ No newline at end of file diff --git a/asyncpg.egg-info/dependency_links.txt b/asyncpg.egg-info/dependency_links.txt new file mode 100644 index 0000000..8b13789 --- /dev/null +++ b/asyncpg.egg-info/dependency_links.txt @@ -0,0 +1 @@ + diff --git a/asyncpg.egg-info/top_level.txt b/asyncpg.egg-info/top_level.txt new file mode 100644 index 0000000..5789edd --- /dev/null +++ b/asyncpg.egg-info/top_level.txt @@ -0,0 +1 @@ +asyncpg diff --git a/asyncpg/__init__.py b/asyncpg/__init__.py new file mode 100644 index 0000000..5488318 --- /dev/null +++ b/asyncpg/__init__.py @@ -0,0 +1,14 @@ +# Copyright (C) 2016-present the ayncpg authors and contributors +# +# +# This module is part of asyncpg and is released under +# the Apache 2.0 License: http://www.apache.org/licenses/LICENSE-2.0 + + +from .connection import connect # NOQA +from .exceptions import * # NOQA +from .pool import create_pool # NOQA +from .types import * # NOQA + + +__all__ = ('connect', 'create_pool') + exceptions.__all__ # NOQA diff --git a/asyncpg/_testbase.py b/asyncpg/_testbase.py new file mode 100644 index 0000000..daf9cdf --- /dev/null +++ b/asyncpg/_testbase.py @@ -0,0 +1,167 @@ +# Copyright (C) 2016-present the ayncpg authors and contributors +# +# +# This module is part of asyncpg and is released under +# the Apache 2.0 License: http://www.apache.org/licenses/LICENSE-2.0 + + +import asyncio +import atexit +import contextlib +import functools +import inspect +import logging +import os +import time +import unittest + + +from asyncpg import cluster as pg_cluster +from asyncpg import pool as pg_pool + + +@contextlib.contextmanager +def silence_asyncio_long_exec_warning(): + def flt(log_record): + msg = log_record.getMessage() + return not msg.startswith('Executing ') + + logger = logging.getLogger('asyncio') + logger.addFilter(flt) + try: + yield + finally: + logger.removeFilter(flt) + + +class TestCaseMeta(type(unittest.TestCase)): + + @staticmethod + def _iter_methods(bases, ns): + for base in bases: + for methname in dir(base): + if not methname.startswith('test_'): + continue + + meth = getattr(base, methname) + if not inspect.iscoroutinefunction(meth): + continue + + yield methname, meth + + for methname, meth in ns.items(): + if not methname.startswith('test_'): + continue + + if not inspect.iscoroutinefunction(meth): + continue + + yield methname, meth + + def __new__(mcls, name, bases, ns): + for methname, meth in mcls._iter_methods(bases, ns): + @functools.wraps(meth) + def wrapper(self, *args, __meth__=meth, **kwargs): + self.loop.run_until_complete(__meth__(self, *args, **kwargs)) + ns[methname] = wrapper + + return super().__new__(mcls, name, bases, ns) + + +class TestCase(unittest.TestCase, metaclass=TestCaseMeta): + + @classmethod + def setUpClass(cls): + if os.environ.get('USE_UVLOOP'): + import uvloop + asyncio.set_event_loop_policy(uvloop.EventLoopPolicy()) + + loop = asyncio.new_event_loop() + asyncio.set_event_loop(None) + cls.loop = loop + + @classmethod + def tearDownClass(cls): + cls.loop.close() + asyncio.set_event_loop(None) + + @contextlib.contextmanager + def assertRunUnder(self, delta): + st = time.monotonic() + try: + yield + finally: + if time.monotonic() - st > delta: + raise AssertionError( + 'running block took longer than {}'.format(delta)) + + +_default_cluster = None + + +def _start_cluster(ClusterCls, cluster_kwargs, server_settings): + cluster = ClusterCls(**cluster_kwargs) + cluster.init() + cluster.trust_local_connections() + cluster.start(port='dynamic', server_settings=server_settings) + atexit.register(_shutdown_cluster, cluster) + return cluster + + +def _start_default_cluster(server_settings={}): + global _default_cluster + + if _default_cluster is None: + pg_host = os.environ.get('PGHOST') + if pg_host: + # Using existing cluster, assuming it is initialized and running + _default_cluster = pg_cluster.RunningCluster() + else: + _default_cluster = _start_cluster( + pg_cluster.TempCluster, {}, server_settings) + + return _default_cluster + + +def _shutdown_cluster(cluster): + cluster.stop() + cluster.destroy() + + +class ClusterTestCase(TestCase): + @classmethod + def setUpClass(cls): + super().setUpClass() + cls.cluster = _start_default_cluster({ + 'log_connections': 'on' + }) + + def create_pool(self, **kwargs): + conn_spec = self.cluster.get_connection_spec() + conn_spec.update(kwargs) + return pg_pool.create_pool(loop=self.loop, **conn_spec) + + @classmethod + def start_cluster(cls, ClusterCls, *, + cluster_kwargs={}, server_settings={}): + return _start_cluster(ClusterCls, cluster_kwargs, server_settings) + + +class ConnectedTestCase(ClusterTestCase): + + def getExtraConnectOptions(self): + return {} + + def setUp(self): + super().setUp() + opts = self.getExtraConnectOptions() + self.con = self.loop.run_until_complete( + self.cluster.connect(database='postgres', loop=self.loop, **opts)) + self.server_version = self.con.get_server_version() + + def tearDown(self): + try: + self.loop.run_until_complete(self.con.close()) + self.con = None + finally: + super().tearDown() diff --git a/asyncpg/cluster.py b/asyncpg/cluster.py new file mode 100644 index 0000000..b9601b5 --- /dev/null +++ b/asyncpg/cluster.py @@ -0,0 +1,605 @@ +# Copyright (C) 2016-present the ayncpg authors and contributors +# +# +# This module is part of asyncpg and is released under +# the Apache 2.0 License: http://www.apache.org/licenses/LICENSE-2.0 + + +import asyncio +import errno +import os +import os.path +import platform +import random +import re +import shutil +import socket +import subprocess +import tempfile +import textwrap +import time + +import asyncpg +from asyncpg import serverversion + + +_system = platform.uname().system + +if _system == 'Windows': + def platform_exe(name): + if name.endswith('.exe'): + return name + return name + '.exe' +else: + def platform_exe(name): + return name + + +if _system == 'Linux': + def ensure_dead_with_parent(): + import ctypes + import signal + + try: + PR_SET_PDEATHSIG = 1 + libc = ctypes.CDLL(ctypes.util.find_library('c')) + libc.prctl(PR_SET_PDEATHSIG, signal.SIGKILL) + except Exception as e: + print(e) +else: + ensure_dead_with_parent = None + + +def find_available_port(port_range=(49152, 65535), max_tries=1000): + low, high = port_range + + port = low + try_no = 0 + + while try_no < max_tries: + try_no += 1 + port = random.randint(low, high) + sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM) + try: + sock.bind(('127.0.0.1', port)) + except socket.error as e: + if e.errno == errno.EADDRINUSE: + continue + finally: + sock.close() + + break + else: + port = None + + return port + + +class ClusterError(Exception): + pass + + +class Cluster: + def __init__(self, data_dir, *, pg_config_path=None): + self._data_dir = data_dir + self._pg_config_path = pg_config_path + self._pg_config = None + self._pg_config_data = None + self._pg_ctl = None + self._daemon_pid = None + self._daemon_process = None + self._connection_addr = None + self._connection_spec_override = None + + def is_managed(self): + return True + + def get_data_dir(self): + return self._data_dir + + def get_status(self): + if self._pg_ctl is None: + self._init_env() + + process = subprocess.run( + [self._pg_ctl, 'status', '-D', self._data_dir], + stdout=subprocess.PIPE, stderr=subprocess.PIPE) + stdout, stderr = process.stdout, process.stderr + + if process.returncode == 4 or not os.listdir(self._data_dir): + return 'not-initialized' + elif process.returncode == 3: + return 'stopped' + elif process.returncode == 0: + r = re.match(r'.*PID\s?:\s+(\d+).*', stdout.decode()) + if not r: + raise ClusterError( + 'could not parse pg_ctl status output: {}'.format( + stdout.decode())) + self._daemon_pid = int(r.group(1)) + return self._test_connection(timeout=0) + else: + raise ClusterError( + 'pg_ctl status exited with status {:d}: {}'.format( + process.returncode, stderr)) + + async def connect(self, loop=None, **kwargs): + conn_info = self.get_connection_spec() + conn_info.update(kwargs) + return await asyncpg.connect(loop=loop, **conn_info) + + def init(self, **settings): + """Initialize cluster.""" + if self.get_status() != 'not-initialized': + raise ClusterError( + 'cluster in {!r} has already been initialized'.format( + self._data_dir)) + + if settings: + settings_args = ['--{}={}'.format(k, v) + for k, v in settings.items()] + extra_args = ['-o'] + [' '.join(settings_args)] + else: + extra_args = [] + + process = subprocess.run( + [self._pg_ctl, 'init', '-D', self._data_dir] + extra_args, + stdout=subprocess.PIPE, stderr=subprocess.STDOUT) + + output = process.stdout + + if process.returncode != 0: + raise ClusterError( + 'pg_ctl init exited with status {:d}:\n{}'.format( + process.returncode, output.decode())) + + return output.decode() + + def start(self, wait=60, *, server_settings={}, **opts): + """Start the cluster.""" + status = self.get_status() + if status == 'running': + return + elif status == 'not-initialized': + raise ClusterError( + 'cluster in {!r} has not been initialized'.format( + self._data_dir)) + + port = opts.pop('port', None) + if port == 'dynamic': + port = find_available_port() + + extra_args = ['--{}={}'.format(k, v) for k, v in opts.items()] + extra_args.append('--port={}'.format(port)) + + sockdir = server_settings.get('unix_socket_directories') + if sockdir is None: + sockdir = server_settings.get('unix_socket_directory') + if sockdir is None: + sockdir = '/tmp' + + if self._pg_version < (9, 3): + sockdir_opt = 'unix_socket_directory' + else: + sockdir_opt = 'unix_socket_directories' + + server_settings[sockdir_opt] = sockdir + + for k, v in server_settings.items(): + extra_args.extend(['-c', '{}={}'.format(k, v)]) + + if _system == 'Windows': + # On Windows we have to use pg_ctl as direct execution + # of postgres daemon under an Administrative account + # is not permitted and there is no easy way to drop + # privileges. + process = subprocess.run( + [self._pg_ctl, 'start', '-D', self._data_dir, + '-o', ' '.join(extra_args)], + stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL) + stderr = process.stderr + + if process.returncode != 0: + raise ClusterError( + 'pg_ctl start exited with status {:d}: {}'.format( + process.returncode, stderr.decode())) + else: + self._daemon_process = \ + subprocess.Popen( + [self._postgres, '-D', self._data_dir, *extra_args], + stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL, + preexec_fn=ensure_dead_with_parent) + + self._daemon_pid = self._daemon_process.pid + + self._test_connection(timeout=wait) + + def reload(self): + """Reload server configuration.""" + status = self.get_status() + if status != 'running': + raise ClusterError('cannot reload: cluster is not running') + + process = subprocess.run( + [self._pg_ctl, 'reload', '-D', self._data_dir], + stdout=subprocess.PIPE, stderr=subprocess.PIPE) + + stderr = process.stderr + + if process.returncode != 0: + raise ClusterError( + 'pg_ctl stop exited with status {:d}: {}'.format( + process.returncode, stderr.decode())) + + def stop(self, wait=60): + process = subprocess.run( + [self._pg_ctl, 'stop', '-D', self._data_dir, '-t', str(wait), + '-m', 'fast'], + stdout=subprocess.PIPE, stderr=subprocess.PIPE) + + stderr = process.stderr + + if process.returncode != 0: + raise ClusterError( + 'pg_ctl stop exited with status {:d}: {}'.format( + process.returncode, stderr.decode())) + + if (self._daemon_process is not None and + self._daemon_process.returncode is None): + self._daemon_process.kill() + + def destroy(self): + status = self.get_status() + if status == 'stopped' or status == 'not-initialized': + shutil.rmtree(self._data_dir) + else: + raise ClusterError('cannot destroy {} cluster'.format(status)) + + def _get_connection_spec(self): + if self._connection_addr is None: + self._connection_addr = self._connection_addr_from_pidfile() + + if self._connection_addr is not None: + if self._connection_spec_override: + args = self._connection_addr.copy() + args.update(self._connection_spec_override) + return args + else: + return self._connection_addr + + def get_connection_spec(self): + status = self.get_status() + if status != 'running': + raise ClusterError('cluster is not running') + + return self._get_connection_spec() + + def override_connection_spec(self, **kwargs): + self._connection_spec_override = kwargs + + def reset_hba(self): + """Remove all records from pg_hba.conf.""" + status = self.get_status() + if status == 'not-initialized': + raise ClusterError( + 'cannot modify HBA records: cluster is not initialized') + + pg_hba = os.path.join(self._data_dir, 'pg_hba.conf') + + try: + with open(pg_hba, 'w'): + pass + except IOError as e: + raise ClusterError( + 'cannot modify HBA records: {}'.format(e)) from e + + def add_hba_entry(self, *, type='host', database, user, address=None, + auth_method, auth_options=None): + """Add a record to pg_hba.conf.""" + status = self.get_status() + if status == 'not-initialized': + raise ClusterError( + 'cannot modify HBA records: cluster is not initialized') + + if type not in {'local', 'host', 'hostssl', 'hostnossl'}: + raise ValueError('invalid HBA record type: {!r}'.format(type)) + + pg_hba = os.path.join(self._data_dir, 'pg_hba.conf') + + record = '{} {} {}'.format(type, database, user) + + if type != 'local': + if address is None: + raise ValueError( + '{!r} entry requires a valid address'.format(type)) + else: + record += ' {}'.format(address) + + record += ' {}'.format(auth_method) + + if auth_options is not None: + record += ' ' + ' '.join( + '{}={}'.format(k, v) for k, v in auth_options) + + try: + with open(pg_hba, 'a') as f: + print(record, file=f) + except IOError as e: + raise ClusterError( + 'cannot modify HBA records: {}'.format(e)) from e + + def trust_local_connections(self): + self.reset_hba() + + if _system != 'Windows': + self.add_hba_entry(type='local', database='all', + user='all', auth_method='trust') + self.add_hba_entry(type='host', address='127.0.0.1/32', + database='all', user='all', + auth_method='trust') + self.add_hba_entry(type='host', address='::1/128', + database='all', user='all', + auth_method='trust') + status = self.get_status() + if status == 'running': + self.reload() + + def trust_local_replication_by(self, user): + if _system != 'Windows': + self.add_hba_entry(type='local', database='replication', + user=user, auth_method='trust') + self.add_hba_entry(type='host', address='127.0.0.1/32', + database='replication', user=user, + auth_method='trust') + self.add_hba_entry(type='host', address='::1/128', + database='replication', user=user, + auth_method='trust') + status = self.get_status() + if status == 'running': + self.reload() + + def _init_env(self): + self._pg_config = self._find_pg_config(self._pg_config_path) + self._pg_config_data = self._run_pg_config(self._pg_config) + self._pg_version = self._get_pg_version() + self._pg_ctl = self._find_pg_binary('pg_ctl') + self._postgres = self._find_pg_binary('postgres') + + def _connection_addr_from_pidfile(self): + pidfile = os.path.join(self._data_dir, 'postmaster.pid') + + try: + with open(pidfile, 'rt') as f: + piddata = f.read() + except FileNotFoundError: + return None + + lines = piddata.splitlines() + + if len(lines) < 6: + # A complete postgres pidfile is at least 6 lines + return None + + pmpid = int(lines[0]) + if self._daemon_pid and pmpid != self._daemon_pid: + # This might be an old pidfile left from previous postgres + # daemon run. + return None + + portnum = lines[3] + sockdir = lines[4] + hostaddr = lines[5] + + if sockdir: + if sockdir[0] != '/': + # Relative sockdir + sockdir = os.path.normpath( + os.path.join(self._data_dir, sockdir)) + host_str = sockdir + else: + host_str = hostaddr + + if host_str == '*': + host_str = 'localhost' + elif host_str == '0.0.0.0': + host_str = '127.0.0.1' + elif host_str == '::': + host_str = '::1' + + return { + 'host': host_str, + 'port': portnum + } + + def _test_connection(self, timeout=60): + self._connection_addr = None + + loop = asyncio.new_event_loop() + + try: + for i in range(timeout): + if self._connection_addr is None: + conn_spec = self._get_connection_spec() + if conn_spec is None: + time.sleep(1) + continue + + try: + con = loop.run_until_complete( + asyncpg.connect(database='postgres', + timeout=5, loop=loop, + **self._connection_addr)) + except (OSError, asyncio.TimeoutError, + asyncpg.CannotConnectNowError, + asyncpg.PostgresConnectionError): + time.sleep(1) + continue + except asyncpg.PostgresError: + # Any other error other than ServerNotReadyError or + # ConnectionError is interpreted to indicate the server is + # up. + break + else: + loop.run_until_complete(con.close()) + break + finally: + loop.close() + + return 'running' + + def _run_pg_config(self, pg_config_path): + process = subprocess.run( + pg_config_path, stdout=subprocess.PIPE, stderr=subprocess.PIPE) + stdout, stderr = process.stdout, process.stderr + + if process.returncode != 0: + raise ClusterError('pg_config exited with status {:d}: {}'.format( + process.returncode, stderr)) + else: + config = {} + + for line in stdout.splitlines(): + k, eq, v = line.decode('utf-8').partition('=') + if eq: + config[k.strip().lower()] = v.strip() + + return config + + def _find_pg_config(self, pg_config_path): + if pg_config_path is None: + pg_install = os.environ.get('PGINSTALLATION') + if pg_install: + pg_config_path = platform_exe( + os.path.join(pg_install, 'pg_config')) + else: + pathenv = os.environ.get('PATH').split(os.pathsep) + for path in pathenv: + pg_config_path = platform_exe( + os.path.join(path, 'pg_config')) + if os.path.exists(pg_config_path): + break + else: + pg_config_path = None + + if not pg_config_path: + raise ClusterError('could not find pg_config executable') + + if not os.path.isfile(pg_config_path): + raise ClusterError('{!r} is not an executable') + + return pg_config_path + + def _find_pg_binary(self, binary): + bindir = self._pg_config_data.get('bindir') + if not bindir: + raise ClusterError( + 'could not find {} executable: '.format(binary) + + 'pg_config output did not provide the BINDIR value') + + bpath = platform_exe(os.path.join(bindir, binary)) + + if not os.path.isfile(bpath): + raise ClusterError( + 'could not find {} executable: '.format(binary) + + '{!r} does not exist or is not a file'.format(bpath)) + + return bpath + + def _get_pg_version(self): + version_string = self._pg_config_data.get('version') + if not version_string: + raise ClusterError('could not determine PostgreSQL version') + + return serverversion.split_server_version_string(version_string) + + +class TempCluster(Cluster): + def __init__(self, *, + data_dir_suffix=None, data_dir_prefix=None, + data_dir_parent=None, pg_config_path=None): + self._data_dir = tempfile.mkdtemp(suffix=data_dir_suffix, + prefix=data_dir_prefix, + dir=data_dir_parent) + super().__init__(self._data_dir, pg_config_path=pg_config_path) + + +class HotStandbyCluster(TempCluster): + def __init__(self, *, + master, replication_user, + data_dir_suffix=None, data_dir_prefix=None, + data_dir_parent=None, pg_config_path=None): + self._master = master + self._repl_user = replication_user + super().__init__( + data_dir_suffix=data_dir_suffix, + data_dir_prefix=data_dir_prefix, + data_dir_parent=data_dir_parent, + pg_config_path=pg_config_path) + + def _init_env(self): + super()._init_env() + self._pg_basebackup = self._find_pg_binary('pg_basebackup') + + def init(self, **settings): + """Initialize cluster.""" + if self.get_status() != 'not-initialized': + raise ClusterError( + 'cluster in {!r} has already been initialized'.format( + self._data_dir)) + + process = subprocess.run( + [self._pg_basebackup, '-h', self._master['host'], + '-p', self._master['port'], '-D', self._data_dir, + '-U', self._repl_user], + stdout=subprocess.PIPE, stderr=subprocess.STDOUT) + + output = process.stdout + + if process.returncode != 0: + raise ClusterError( + 'pg_basebackup init exited with status {:d}:\n{}'.format( + process.returncode, output.decode())) + + with open(os.path.join(self._data_dir, 'recovery.conf'), 'w') as f: + f.write(textwrap.dedent("""\ + standby_mode = 'on' + primary_conninfo = 'host={host} port={port} user={user}' + """.format( + host=self._master['host'], + port=self._master['port'], + user=self._repl_user))) + + return output.decode() + + +class RunningCluster(Cluster): + def __init__(self, **kwargs): + self.conn_spec = kwargs + + def is_managed(self): + return False + + def get_connection_spec(self): + return dict(self.conn_spec) + + def get_status(self): + return 'running' + + def init(self, **settings): + pass + + def start(self, wait=60, **settings): + pass + + def stop(self, wait=60): + pass + + def destroy(self): + pass + + def reset_hba(self): + raise ClusterError('cannot modify HBA records of unmanaged cluster') + + def add_hba_entry(self, *, type='host', database, user, address=None, + auth_method, auth_options=None): + raise ClusterError('cannot modify HBA records of unmanaged cluster') diff --git a/asyncpg/compat.py b/asyncpg/compat.py new file mode 100644 index 0000000..1d330a4 --- /dev/null +++ b/asyncpg/compat.py @@ -0,0 +1,20 @@ +# Copyright (C) 2016-present the ayncpg authors and contributors +# +# +# This module is part of asyncpg and is released under +# the Apache 2.0 License: http://www.apache.org/licenses/LICENSE-2.0 + + +import functools +import sys + + +if sys.version_info < (3, 5, 2): + def aiter_compat(func): + @functools.wraps(func) + async def wrapper(self): + return func(self) + return wrapper +else: + def aiter_compat(func): + return func diff --git a/asyncpg/connection.py b/asyncpg/connection.py new file mode 100644 index 0000000..9445a9b --- /dev/null +++ b/asyncpg/connection.py @@ -0,0 +1,731 @@ +# Copyright (C) 2016-present the ayncpg authors and contributors +# +# +# This module is part of asyncpg and is released under +# the Apache 2.0 License: http://www.apache.org/licenses/LICENSE-2.0 + + +import asyncio +import collections +import getpass +import os +import socket +import struct +import urllib.parse + +from . import cursor +from . import introspection +from . import prepared_stmt +from . import protocol +from . import serverversion +from . import transaction + + +class Connection: + """A representation of a database session. + + Connections are created by calling :func:`~asyncpg.connection.connect`. + """ + + __slots__ = ('_protocol', '_transport', '_loop', '_types_stmt', + '_type_by_name_stmt', '_top_xact', '_uid', '_aborted', + '_stmt_cache_max_size', '_stmt_cache', '_stmts_to_close', + '_addr', '_opts', '_command_timeout', '_listeners', + '_server_version', '_intro_query') + + def __init__(self, protocol, transport, loop, addr, opts, *, + statement_cache_size, command_timeout): + self._protocol = protocol + self._transport = transport + self._loop = loop + self._types_stmt = None + self._type_by_name_stmt = None + self._top_xact = None + self._uid = 0 + self._aborted = False + + self._addr = addr + self._opts = opts + + self._stmt_cache_max_size = statement_cache_size + self._stmt_cache = collections.OrderedDict() + self._stmts_to_close = set() + + self._command_timeout = command_timeout + + self._listeners = {} + + ver_string = self._protocol.get_settings().server_version + self._server_version = \ + serverversion.split_server_version_string(ver_string) + + if self._server_version < (9, 2): + self._intro_query = introspection.INTRO_LOOKUP_TYPES_91 + else: + self._intro_query = introspection.INTRO_LOOKUP_TYPES + + async def add_listener(self, channel, callback): + """Add a listener for Postgres notifications. + + :param str channel: Channel to listen on. + :param callable callback: + A callable receiving the following arguments: + **connection**: a Connection the callback is registered with; + **pid**: PID of the Postgres server that sent the notification; + **channel**: name of the channel the notification was sent to; + **payload**: the payload. + """ + if channel not in self._listeners: + await self.fetch('LISTEN {}'.format(channel)) + self._listeners[channel] = set() + self._listeners[channel].add(callback) + + async def remove_listener(self, channel, callback): + """Remove a listening callback on the specified channel.""" + if channel not in self._listeners: + return + if callback not in self._listeners[channel]: + return + self._listeners[channel].remove(callback) + if not self._listeners[channel]: + del self._listeners[channel] + await self.fetch('UNLISTEN {}'.format(channel)) + + def get_server_pid(self): + """Return the PID of the Postgres server the connection is bound to.""" + return self._protocol.get_server_pid() + + def get_server_version(self): + """Return the version of the connected PostgreSQL server. + + The returned value is a named tuple similar to that in + ``sys.version_info``: + + .. code-block:: pycon + + >>> con.get_server_version() + ServerVersion(major=9, minor=6, micro=1, + releaselevel='final', serial=0) + + """ + return self._server_version + + def get_settings(self): + """Return connection settings. + + :return: :class:`~asyncpg.ConnectionSettings`. + """ + return self._protocol.get_settings() + + def transaction(self, *, isolation='read_committed', readonly=False, + deferrable=False): + """Create a :class:`~transaction.Transaction` object. + + Refer to `PostgreSQL documentation`_ on the meaning of transaction + parameters. + + :param isolation: Transaction isolation mode, can be one of: + `'serializable'`, `'repeatable_read'`, + `'read_committed'`. + + :param readonly: Specifies whether or not this transaction is + read-only. + + :param deferrable: Specifies whether or not this transaction is + deferrable. + + .. _`PostgreSQL documentation`: https://www.postgresql.org/docs/current/static/sql-set-transaction.html + """ + return transaction.Transaction(self, isolation, readonly, deferrable) + + async def execute(self, query: str, *args, timeout: float=None) -> str: + """Execute an SQL command (or commands). + + This method can execute many SQL commands at once, when no arguments + are provided. + + Example: + + .. code-block:: pycon + + >>> await con.execute(''' + ... CREATE TABLE mytab (a int); + ... INSERT INTO mytab (a) VALUES (100), (200), (300); + ... ''') + INSERT 0 3 + + >>> await con.execute(''' + ... INSERT INTO mytab (a) VALUES ($1), ($2) + ... ''', 10, 20) + INSERT 0 2 + + :param args: Query arguments. + :param float timeout: Optional timeout value in seconds. + :return str: Status of the last SQL command. + + .. versionchanged:: 0.5.4 + Made it possible to pass query arguments. + """ + if not args: + return await self._protocol.query(query, timeout) + + stmt = await self._get_statement(query, timeout) + _, status, _ = await self._protocol.bind_execute(stmt, args, '', 0, + True, timeout) + return status.decode() + + async def executemany(self, command: str, args, timeout: float=None): + """Execute an SQL *command* for each sequence of arguments in *args*. + + Example: + + .. code-block:: pycon + + >>> await con.executemany(''' + ... INSERT INTO mytab (a) VALUES ($1, $2, $3); + ... ''', [(1, 2, 3), (4, 5, 6)]) + + :param command: Command to execute. + :args: An iterable containing sequences of arguments. + :param float timeout: Optional timeout value in seconds. + :return None: This method discards the results of the operations. + + .. versionadded:: 0.7.0 + """ + stmt = await self._get_statement(command, timeout) + return await self._protocol.bind_execute_many(stmt, args, '', timeout) + + async def _get_statement(self, query, timeout): + cache = self._stmt_cache_max_size > 0 + + if cache: + try: + state = self._stmt_cache[query] + except KeyError: + pass + else: + self._stmt_cache.move_to_end(query, last=True) + if not state.closed: + return state + + protocol = self._protocol + state = await protocol.prepare(None, query, timeout) + + ready = state._init_types() + if ready is not True: + if self._types_stmt is None: + self._types_stmt = await self.prepare(self._intro_query) + + types = await self._types_stmt.fetch(list(ready)) + protocol.get_settings().register_data_types(types) + + if cache: + if len(self._stmt_cache) > self._stmt_cache_max_size - 1: + old_query, old_state = self._stmt_cache.popitem(last=False) + self._maybe_gc_stmt(old_state) + self._stmt_cache[query] = state + + # If we've just created a new statement object, check if there + # are any statements for GC. + if self._stmts_to_close: + await self._cleanup_stmts() + + return state + + def cursor(self, query, *args, prefetch=None, timeout=None): + """Return a *cursor factory* for the specified query. + + :param args: Query arguments. + :param int prefetch: The number of rows the *cursor iterator* + will prefetch (defaults to ``50``.) + :param float timeout: Optional timeout in seconds. + + :return: A :class:`~cursor.CursorFactory` object. + """ + return cursor.CursorFactory(self, query, None, args, + prefetch, timeout) + + async def prepare(self, query, *, timeout=None): + """Create a *prepared statement* for the specified query. + + :param str query: Text of the query to create a prepared statement for. + :param float timeout: Optional timeout value in seconds. + + :return: A :class:`~prepared_stmt.PreparedStatement` instance. + """ + stmt = await self._get_statement(query, timeout) + return prepared_stmt.PreparedStatement(self, query, stmt) + + async def fetch(self, query, *args, timeout=None) -> list: + """Run a query and return the results as a list of :class:`Record`. + + :param str query: Query text. + :param args: Query arguments. + :param float timeout: Optional timeout value in seconds. + + :return list: A list of :class:`Record` instances. + """ + stmt = await self._get_statement(query, timeout) + data = await self._protocol.bind_execute(stmt, args, '', 0, + False, timeout) + return data + + async def fetchval(self, query, *args, column=0, timeout=None): + """Run a query and return a value in the first row. + + :param str query: Query text. + :param args: Query arguments. + :param int column: Numeric index within the record of the value to + return (defaults to 0). + :param float timeout: Optional timeout value in seconds. + If not specified, defaults to the value of + ``command_timeout`` argument to the ``Connection`` + instance constructor. + + :return: The value of the specified column of the first record. + """ + stmt = await self._get_statement(query, timeout) + data = await self._protocol.bind_execute(stmt, args, '', 1, + False, timeout) + if not data: + return None + return data[0][column] + + async def fetchrow(self, query, *args, timeout=None): + """Run a query and return the first row. + + :param str query: Query text + :param args: Query arguments + :param float timeout: Optional timeout value in seconds. + + :return: The first row as a :class:`Record` instance. + """ + stmt = await self._get_statement(query, timeout) + data = await self._protocol.bind_execute(stmt, args, '', 1, + False, timeout) + if not data: + return None + return data[0] + + async def set_type_codec(self, typename, *, + schema='public', encoder, decoder, binary=False): + """Set an encoder/decoder pair for the specified data type. + + :param typename: Name of the data type the codec is for. + :param schema: Schema name of the data type the codec is for + (defaults to 'public') + :param encoder: Callable accepting a single argument and returning + a string or a bytes object (if `binary` is True). + :param decoder: Callable accepting a single string or bytes argument + and returning a decoded object. + :param binary: Specifies whether the codec is able to handle binary + data. If ``False`` (the default), the data is + expected to be encoded/decoded in text. + """ + if self._type_by_name_stmt is None: + self._type_by_name_stmt = await self.prepare( + introspection.TYPE_BY_NAME) + + typeinfo = await self._type_by_name_stmt.fetchrow( + typename, schema) + if not typeinfo: + raise ValueError('unknown type: {}.{}'.format(schema, typename)) + + oid = typeinfo['oid'] + if typeinfo['kind'] != b'b' or typeinfo['elemtype']: + raise ValueError( + 'cannot use custom codec on non-scalar type {}.{}'.format( + schema, typename)) + + self._protocol.get_settings().add_python_codec( + oid, typename, schema, 'scalar', + encoder, decoder, binary) + + async def set_builtin_type_codec(self, typename, *, + schema='public', codec_name): + """Set a builtin codec for the specified data type. + + :param typename: Name of the data type the codec is for. + :param schema: Schema name of the data type the codec is for + (defaults to 'public') + :param codec_name: The name of the builtin codec. + """ + if self._type_by_name_stmt is None: + self._type_by_name_stmt = await self.prepare( + introspection.TYPE_BY_NAME) + + typeinfo = await self._type_by_name_stmt.fetchrow( + typename, schema) + if not typeinfo: + raise ValueError('unknown type: {}.{}'.format(schema, typename)) + + oid = typeinfo['oid'] + if typeinfo['kind'] != b'b' or typeinfo['elemtype']: + raise ValueError( + 'cannot alias non-scalar type {}.{}'.format( + schema, typename)) + + self._protocol.get_settings().set_builtin_type_codec( + oid, typename, schema, 'scalar', codec_name) + + def is_closed(self): + """Return ``True`` if the connection is closed, ``False`` otherwise. + + :return bool: ``True`` if the connection is closed, ``False`` + otherwise. + """ + return not self._protocol.is_connected() or self._aborted + + async def close(self): + """Close the connection gracefully.""" + if self.is_closed(): + return + self._close_stmts() + self._listeners = {} + self._aborted = True + await self._protocol.close() + + def terminate(self): + """Terminate the connection without waiting for pending data.""" + self._close_stmts() + self._listeners = {} + self._aborted = True + self._protocol.abort() + + async def reset(self): + self._listeners = {} + + await self.execute(''' + DO $$ + BEGIN + PERFORM * FROM pg_listening_channels() LIMIT 1; + IF FOUND THEN + UNLISTEN *; + END IF; + END; + $$; + SET SESSION AUTHORIZATION DEFAULT; + RESET ALL; + CLOSE ALL; + SELECT pg_advisory_unlock_all(); + ''') + + def _get_unique_id(self): + self._uid += 1 + return 'id{}'.format(self._uid) + + def _close_stmts(self): + for stmt in self._stmt_cache.values(): + stmt.mark_closed() + + for stmt in self._stmts_to_close: + stmt.mark_closed() + + self._stmt_cache.clear() + self._stmts_to_close.clear() + + def _maybe_gc_stmt(self, stmt): + if stmt.refs == 0 and stmt.query not in self._stmt_cache: + stmt.mark_closed() + self._stmts_to_close.add(stmt) + + async def _cleanup_stmts(self): + to_close = self._stmts_to_close + self._stmts_to_close = set() + for stmt in to_close: + await self._protocol.close_statement(stmt, False) + + def _request_portal_name(self): + return self._get_unique_id() + + def _cancel_current_command(self, waiter): + async def cancel(): + try: + # Open new connection to the server + if isinstance(self._addr, str): + r, w = await asyncio.open_unix_connection( + self._addr, loop=self._loop) + else: + r, w = await asyncio.open_connection( + *self._addr, loop=self._loop) + + sock = w.transport.get_extra_info('socket') + sock.setsockopt(socket.IPPROTO_TCP, + socket.TCP_NODELAY, 1) + + # Pack CancelRequest message + msg = struct.pack('!llll', 16, 80877102, + self._protocol.backend_pid, + self._protocol.backend_secret) + except Exception as ex: + waiter.set_exception(ex) + return + + try: + w.write(msg) + await r.read() # Wait until EOF + except ConnectionResetError: + # On some systems Postgres will reset the connection + # after processing the cancellation command. + pass + except Exception as ex: + waiter.set_exception(ex) + finally: + if not waiter.done(): # Ensure set_exception wasn't called. + waiter.set_result(None) + w.close() + + self._loop.create_task(cancel()) + + def _notify(self, pid, channel, payload): + if channel not in self._listeners: + return + + for cb in self._listeners[channel]: + try: + cb(self, pid, channel, payload) + except Exception as ex: + self._loop.call_exception_handler({ + 'message': 'Unhandled exception in asyncpg notification ' + 'listener callback {!r}'.format(cb), + 'exception': ex + }) + + +async def connect(dsn=None, *, + host=None, port=None, + user=None, password=None, + database=None, + loop=None, + timeout=60, + statement_cache_size=100, + command_timeout=None, + **opts): + """A coroutine to establish a connection to a PostgreSQL server. + + Returns a new :class:`~asyncpg.connection.Connection` object. + + :param dsn: Connection arguments specified using as a single string in the + following format: + ``postgres://user:pass@host:port/database?option=value`` + + :param host: database host address or a path to the directory containing + database server UNIX socket (defaults to the default UNIX + socket, or the value of the ``PGHOST`` environment variable, + if set). + + :param port: connection port number (defaults to ``5432``, or the value of + the ``PGPORT`` environment variable, if set) + + :param user: the name of the database role used for authentication + (defaults to the name of the effective user of the process + making the connection, or the value of ``PGUSER`` environment + variable, if set) + + :param database: the name of the database (defaults to the value of + ``PGDATABASE`` environment variable, if set.) + + :param password: password used for authentication + + :param loop: An asyncio event loop instance. If ``None``, the default + event loop will be used. + + :param float timeout: connection timeout in seconds. + + :param float command_timeout: the default timeout for operations on + this connection (the default is no timeout). + + :param int statement_cache_size: the size of prepared statement LRU cache. + + :return: A :class:`~asyncpg.connection.Connection` instance. + + Example: + + .. code-block:: pycon + + >>> import asyncpg + >>> import asyncio + >>> async def run(): + ... con = await asyncpg.connect(user='postgres') + ... types = await con.fetch('SELECT * FROM pg_type') + ... print(types) + >>> asyncio.get_event_loop().run_until_complete(run()) + [ connection parameter conversion read here: + # https://www.postgresql.org/docs/current/static/libpq-envars.html + # Note that env values may be an empty string in cases when + # the variable is "unset" by setting it to an empty value + # + if host is None: + host = os.getenv('PGHOST') + if not host: + host = ['/tmp', '/private/tmp', + '/var/pgsql_socket', '/run/postgresql', + 'localhost'] + if not isinstance(host, list): + host = [host] + + if port is None: + port = os.getenv('PGPORT') + if port: + port = int(port) + else: + port = 5432 + else: + port = int(port) + + if user is None: + user = os.getenv('PGUSER') + if not user: + user = getpass.getuser() + + if password is None: + password = os.getenv('PGPASSWORD') + + if database is None: + database = os.getenv('PGDATABASE') + + if user is not None: + opts['user'] = user + if password is not None: + opts['password'] = password + if database is not None: + opts['database'] = database + + for param in opts: + if not isinstance(param, str): + raise ValueError( + 'invalid connection parameter {!r} (str expected)' + .format(param)) + if not isinstance(opts[param], str): + raise ValueError( + 'invalid connection parameter {!r}: {!r} (str expected)' + .format(param, opts[param])) + + return host, port, opts + + +def _create_future(loop): + try: + create_future = loop.create_future + except AttributeError: + return asyncio.Future(loop=loop) + else: + return create_future() diff --git a/asyncpg/cursor.py b/asyncpg/cursor.py new file mode 100644 index 0000000..a0731d6 --- /dev/null +++ b/asyncpg/cursor.py @@ -0,0 +1,254 @@ +# Copyright (C) 2016-present the ayncpg authors and contributors +# +# +# This module is part of asyncpg and is released under +# the Apache 2.0 License: http://www.apache.org/licenses/LICENSE-2.0 + + +import collections + +from . import compat +from . import exceptions + + +class CursorFactory: + """A cursor interface for the results of a query. + + A cursor interface can be used to initiate efficient traversal of the + results of a large query. + """ + + __slots__ = ('_state', '_connection', '_args', '_prefetch', + '_query', '_timeout') + + def __init__(self, connection, query, state, args, prefetch, timeout): + self._connection = connection + self._args = args + self._prefetch = prefetch + self._query = query + self._timeout = timeout + self._state = state + if state is not None: + state.attach() + + @compat.aiter_compat + def __aiter__(self): + prefetch = 50 if self._prefetch is None else self._prefetch + return CursorIterator(self._connection, + self._query, self._state, + self._args, prefetch, + self._timeout) + + def __await__(self): + if self._prefetch is not None: + raise exceptions.InterfaceError( + 'prefetch argument can only be specified for iterable cursor') + cursor = Cursor(self._connection, self._query, + self._state, self._args) + return cursor._init(self._timeout).__await__() + + def __del__(self): + if self._state is not None: + self._state.detach() + self._connection._maybe_gc_stmt(self._state) + + +class BaseCursor: + + __slots__ = ('_state', '_connection', '_args', '_portal_name', + '_exhausted', '_query') + + def __init__(self, connection, query, state, args): + self._args = args + self._connection = connection + self._state = state + if state is not None: + state.attach() + self._portal_name = None + self._exhausted = False + self._query = query + + def _check_ready(self): + if self._state is None: + raise exceptions.InterfaceError( + 'cursor: no associated prepared statement') + + if self._state.closed: + raise exceptions.InterfaceError( + 'cursor: the prepared statement is closed') + + if not self._connection._top_xact: + raise exceptions.NoActiveSQLTransactionError( + 'cursor cannot be created outside of a transaction') + + async def _bind_exec(self, n, timeout): + self._check_ready() + + if self._portal_name: + raise exceptions.InterfaceError( + 'cursor already has an open portal') + + con = self._connection + protocol = con._protocol + + self._portal_name = con._request_portal_name() + buffer, _, self._exhausted = await protocol.bind_execute( + self._state, self._args, self._portal_name, n, True, timeout) + return buffer + + async def _bind(self, timeout): + self._check_ready() + + if self._portal_name: + raise exceptions.InterfaceError( + 'cursor already has an open portal') + + con = self._connection + protocol = con._protocol + + self._portal_name = con._request_portal_name() + buffer = await protocol.bind(self._state, self._args, + self._portal_name, + timeout) + return buffer + + async def _exec(self, n, timeout): + self._check_ready() + + if not self._portal_name: + raise exceptions.InterfaceError( + 'cursor does not have an open portal') + + protocol = self._connection._protocol + buffer, _, self._exhausted = await protocol.execute( + self._state, self._portal_name, n, True, timeout) + return buffer + + def __repr__(self): + attrs = [] + if self._exhausted: + attrs.append('exhausted') + attrs.append('') # to separate from id + + if self.__class__.__module__.startswith('asyncpg.'): + mod = 'asyncpg' + else: + mod = self.__class__.__module__ + + return '<{}.{} "{!s:.30}" {}{:#x}>'.format( + mod, self.__class__.__name__, + self._state.query, + ' '.join(attrs), id(self)) + + def __del__(self): + if self._state is not None: + self._state.detach() + self._connection._maybe_gc_stmt(self._state) + + +class CursorIterator(BaseCursor): + + __slots__ = ('_buffer', '_prefetch', '_timeout') + + def __init__(self, connection, query, state, args, prefetch, timeout): + super().__init__(connection, query, state, args) + + if prefetch <= 0: + raise exceptions.InterfaceError( + 'prefetch argument must be greater than zero') + + self._buffer = collections.deque() + self._prefetch = prefetch + self._timeout = timeout + + @compat.aiter_compat + def __aiter__(self): + return self + + async def __anext__(self): + if self._state is None: + self._state = await self._connection._get_statement( + self._query, self._timeout) + self._state.attach() + + if not self._portal_name: + buffer = await self._bind_exec(self._prefetch, self._timeout) + self._buffer.extend(buffer) + + if not self._buffer and not self._exhausted: + buffer = await self._exec(self._prefetch, self._timeout) + self._buffer.extend(buffer) + + if self._buffer: + return self._buffer.popleft() + + raise StopAsyncIteration + + +class Cursor(BaseCursor): + """An open *portal* into the results of a query.""" + + __slots__ = () + + async def _init(self, timeout): + if self._state is None: + self._state = await self._connection._get_statement( + self._query, timeout) + self._state.attach() + self._check_ready() + await self._bind(timeout) + return self + + async def fetch(self, n, *, timeout=None): + r"""Return the next *n* rows as a list of :class:`Record` objects. + + :param float timeout: Optional timeout value in seconds. + + :return: A list of :class:`Record` instances. + """ + self._check_ready() + if n <= 0: + raise exceptions.InterfaceError('n must be greater than zero') + if self._exhausted: + return [] + recs = await self._exec(n, timeout) + if len(recs) < n: + self._exhausted = True + return recs + + async def fetchrow(self, *, timeout=None): + r"""Return the next row. + + :param float timeout: Optional timeout value in seconds. + + :return: A :class:`Record` instance. + """ + self._check_ready() + if self._exhausted: + return None + recs = await self._exec(1, timeout) + if len(recs) < 1: + self._exhausted = True + return None + return recs[0] + + async def forward(self, n, *, timeout=None) -> int: + r"""Skip over the next *n* rows. + + :param float timeout: Optional timeout value in seconds. + + :return: A number of rows actually skipped over (<= *n*). + """ + self._check_ready() + if n <= 0: + raise exceptions.InterfaceError('n must be greater than zero') + + protocol = self._connection._protocol + status = await protocol.query('MOVE FORWARD {:d} {}'.format( + n, self._portal_name), timeout) + + advanced = int(status.split()[1]) + if advanced < n: + self._exhausted = True + + return advanced diff --git a/asyncpg/exceptions/__init__.py b/asyncpg/exceptions/__init__.py new file mode 100644 index 0000000..07d5413 --- /dev/null +++ b/asyncpg/exceptions/__init__.py @@ -0,0 +1,1097 @@ +# Copyright (C) 2016-present the ayncpg authors and contributors +# +# +# This module is part of asyncpg and is released under +# the Apache 2.0 License: http://www.apache.org/licenses/LICENSE-2.0 + + +# GENERATED FROM postgresql/src/backend/utils/errcodes.txt +# DO NOT MODIFY, use tools/generate_exceptions.py to update + +from ._base import * # NOQA +from . import _base + + +class PostgresWarning(Warning, _base.PostgresMessage): + sqlstate = '01000' + + +class DynamicResultSetsReturned(PostgresWarning): + sqlstate = '0100C' + + +class ImplicitZeroBitPadding(PostgresWarning): + sqlstate = '01008' + + +class NullValueEliminatedInSetFunction(PostgresWarning): + sqlstate = '01003' + + +class PrivilegeNotGranted(PostgresWarning): + sqlstate = '01007' + + +class PrivilegeNotRevoked(PostgresWarning): + sqlstate = '01006' + + +class StringDataRightTruncation(PostgresWarning): + sqlstate = '01004' + + +class DeprecatedFeature(PostgresWarning): + sqlstate = '01P01' + + +class NoData(PostgresWarning): + sqlstate = '02000' + + +class NoAdditionalDynamicResultSetsReturned(NoData): + sqlstate = '02001' + + +class SQLStatementNotYetCompleteError(_base.PostgresError): + sqlstate = '03000' + + +class PostgresConnectionError(_base.PostgresError): + sqlstate = '08000' + + +class ConnectionDoesNotExistError(PostgresConnectionError): + sqlstate = '08003' + + +class ConnectionFailureError(PostgresConnectionError): + sqlstate = '08006' + + +class ClientCannotConnectError(PostgresConnectionError): + sqlstate = '08001' + + +class ConnectionRejectionError(PostgresConnectionError): + sqlstate = '08004' + + +class TransactionResolutionUnknownError(PostgresConnectionError): + sqlstate = '08007' + + +class ProtocolViolationError(PostgresConnectionError): + sqlstate = '08P01' + + +class TriggeredActionError(_base.PostgresError): + sqlstate = '09000' + + +class FeatureNotSupportedError(_base.PostgresError): + sqlstate = '0A000' + + +class InvalidTransactionInitiationError(_base.PostgresError): + sqlstate = '0B000' + + +class LocatorError(_base.PostgresError): + sqlstate = '0F000' + + +class InvalidLocatorSpecificationError(LocatorError): + sqlstate = '0F001' + + +class InvalidGrantorError(_base.PostgresError): + sqlstate = '0L000' + + +class InvalidGrantOperationError(InvalidGrantorError): + sqlstate = '0LP01' + + +class InvalidRoleSpecificationError(_base.PostgresError): + sqlstate = '0P000' + + +class DiagnosticsError(_base.PostgresError): + sqlstate = '0Z000' + + +class StackedDiagnosticsAccessedWithoutActiveHandlerError(DiagnosticsError): + sqlstate = '0Z002' + + +class CaseNotFoundError(_base.PostgresError): + sqlstate = '20000' + + +class CardinalityViolationError(_base.PostgresError): + sqlstate = '21000' + + +class DataError(_base.PostgresError): + sqlstate = '22000' + + +class ArraySubscriptError(DataError): + sqlstate = '2202E' + + +class CharacterNotInRepertoireError(DataError): + sqlstate = '22021' + + +class DatetimeFieldOverflowError(DataError): + sqlstate = '22008' + + +class DivisionByZeroError(DataError): + sqlstate = '22012' + + +class ErrorInAssignmentError(DataError): + sqlstate = '22005' + + +class EscapeCharacterConflictError(DataError): + sqlstate = '2200B' + + +class IndicatorOverflowError(DataError): + sqlstate = '22022' + + +class IntervalFieldOverflowError(DataError): + sqlstate = '22015' + + +class InvalidArgumentForLogarithmError(DataError): + sqlstate = '2201E' + + +class InvalidArgumentForNtileFunctionError(DataError): + sqlstate = '22014' + + +class InvalidArgumentForNthValueFunctionError(DataError): + sqlstate = '22016' + + +class InvalidArgumentForPowerFunctionError(DataError): + sqlstate = '2201F' + + +class InvalidArgumentForWidthBucketFunctionError(DataError): + sqlstate = '2201G' + + +class InvalidCharacterValueForCastError(DataError): + sqlstate = '22018' + + +class InvalidDatetimeFormatError(DataError): + sqlstate = '22007' + + +class InvalidEscapeCharacterError(DataError): + sqlstate = '22019' + + +class InvalidEscapeOctetError(DataError): + sqlstate = '2200D' + + +class InvalidEscapeSequenceError(DataError): + sqlstate = '22025' + + +class NonstandardUseOfEscapeCharacterError(DataError): + sqlstate = '22P06' + + +class InvalidIndicatorParameterValueError(DataError): + sqlstate = '22010' + + +class InvalidParameterValueError(DataError): + sqlstate = '22023' + + +class InvalidRegularExpressionError(DataError): + sqlstate = '2201B' + + +class InvalidRowCountInLimitClauseError(DataError): + sqlstate = '2201W' + + +class InvalidRowCountInResultOffsetClauseError(DataError): + sqlstate = '2201X' + + +class InvalidTablesampleArgumentError(DataError): + sqlstate = '2202H' + + +class InvalidTablesampleRepeatError(DataError): + sqlstate = '2202G' + + +class InvalidTimeZoneDisplacementValueError(DataError): + sqlstate = '22009' + + +class InvalidUseOfEscapeCharacterError(DataError): + sqlstate = '2200C' + + +class MostSpecificTypeMismatchError(DataError): + sqlstate = '2200G' + + +class NullValueNotAllowedError(DataError): + sqlstate = '22004' + + +class NullValueNoIndicatorParameterError(DataError): + sqlstate = '22002' + + +class NumericValueOutOfRangeError(DataError): + sqlstate = '22003' + + +class StringDataLengthMismatchError(DataError): + sqlstate = '22026' + + +class StringDataRightTruncationError(DataError): + sqlstate = '22001' + + +class SubstringError(DataError): + sqlstate = '22011' + + +class TrimError(DataError): + sqlstate = '22027' + + +class UnterminatedCStringError(DataError): + sqlstate = '22024' + + +class ZeroLengthCharacterStringError(DataError): + sqlstate = '2200F' + + +class PostgresFloatingPointError(DataError): + sqlstate = '22P01' + + +class InvalidTextRepresentationError(DataError): + sqlstate = '22P02' + + +class InvalidBinaryRepresentationError(DataError): + sqlstate = '22P03' + + +class BadCopyFileFormatError(DataError): + sqlstate = '22P04' + + +class UntranslatableCharacterError(DataError): + sqlstate = '22P05' + + +class NotAnXmlDocumentError(DataError): + sqlstate = '2200L' + + +class InvalidXmlDocumentError(DataError): + sqlstate = '2200M' + + +class InvalidXmlContentError(DataError): + sqlstate = '2200N' + + +class InvalidXmlCommentError(DataError): + sqlstate = '2200S' + + +class InvalidXmlProcessingInstructionError(DataError): + sqlstate = '2200T' + + +class IntegrityConstraintViolationError(_base.PostgresError): + sqlstate = '23000' + + +class RestrictViolationError(IntegrityConstraintViolationError): + sqlstate = '23001' + + +class NotNullViolationError(IntegrityConstraintViolationError): + sqlstate = '23502' + + +class ForeignKeyViolationError(IntegrityConstraintViolationError): + sqlstate = '23503' + + +class UniqueViolationError(IntegrityConstraintViolationError): + sqlstate = '23505' + + +class CheckViolationError(IntegrityConstraintViolationError): + sqlstate = '23514' + + +class ExclusionViolationError(IntegrityConstraintViolationError): + sqlstate = '23P01' + + +class InvalidCursorStateError(_base.PostgresError): + sqlstate = '24000' + + +class InvalidTransactionStateError(_base.PostgresError): + sqlstate = '25000' + + +class ActiveSQLTransactionError(InvalidTransactionStateError): + sqlstate = '25001' + + +class BranchTransactionAlreadyActiveError(InvalidTransactionStateError): + sqlstate = '25002' + + +class HeldCursorRequiresSameIsolationLevelError(InvalidTransactionStateError): + sqlstate = '25008' + + +class InappropriateAccessModeForBranchTransactionError( + InvalidTransactionStateError): + sqlstate = '25003' + + +class InappropriateIsolationLevelForBranchTransactionError( + InvalidTransactionStateError): + sqlstate = '25004' + + +class NoActiveSQLTransactionForBranchTransactionError( + InvalidTransactionStateError): + sqlstate = '25005' + + +class ReadOnlySQLTransactionError(InvalidTransactionStateError): + sqlstate = '25006' + + +class SchemaAndDataStatementMixingNotSupportedError( + InvalidTransactionStateError): + sqlstate = '25007' + + +class NoActiveSQLTransactionError(InvalidTransactionStateError): + sqlstate = '25P01' + + +class InFailedSQLTransactionError(InvalidTransactionStateError): + sqlstate = '25P02' + + +class IdleInTransactionSessionTimeoutError(InvalidTransactionStateError): + sqlstate = '25P03' + + +class InvalidSQLStatementNameError(_base.PostgresError): + sqlstate = '26000' + + +class TriggeredDataChangeViolationError(_base.PostgresError): + sqlstate = '27000' + + +class InvalidAuthorizationSpecificationError(_base.PostgresError): + sqlstate = '28000' + + +class InvalidPasswordError(InvalidAuthorizationSpecificationError): + sqlstate = '28P01' + + +class DependentPrivilegeDescriptorsStillExistError(_base.PostgresError): + sqlstate = '2B000' + + +class DependentObjectsStillExistError( + DependentPrivilegeDescriptorsStillExistError): + sqlstate = '2BP01' + + +class InvalidTransactionTerminationError(_base.PostgresError): + sqlstate = '2D000' + + +class SQLRoutineError(_base.PostgresError): + sqlstate = '2F000' + + +class FunctionExecutedNoReturnStatementError(SQLRoutineError): + sqlstate = '2F005' + + +class ModifyingSQLDataNotPermittedError(SQLRoutineError): + sqlstate = '2F002' + + +class ProhibitedSQLStatementAttemptedError(SQLRoutineError): + sqlstate = '2F003' + + +class ReadingSQLDataNotPermittedError(SQLRoutineError): + sqlstate = '2F004' + + +class InvalidCursorNameError(_base.PostgresError): + sqlstate = '34000' + + +class ExternalRoutineError(_base.PostgresError): + sqlstate = '38000' + + +class ContainingSQLNotPermittedError(ExternalRoutineError): + sqlstate = '38001' + + +class ModifyingExternalRoutineSQLDataNotPermittedError(ExternalRoutineError): + sqlstate = '38002' + + +class ProhibitedExternalRoutineSQLStatementAttemptedError( + ExternalRoutineError): + sqlstate = '38003' + + +class ReadingExternalRoutineSQLDataNotPermittedError(ExternalRoutineError): + sqlstate = '38004' + + +class ExternalRoutineInvocationError(_base.PostgresError): + sqlstate = '39000' + + +class InvalidSqlstateReturnedError(ExternalRoutineInvocationError): + sqlstate = '39001' + + +class NullValueInExternalRoutineNotAllowedError( + ExternalRoutineInvocationError): + sqlstate = '39004' + + +class TriggerProtocolViolatedError(ExternalRoutineInvocationError): + sqlstate = '39P01' + + +class SrfProtocolViolatedError(ExternalRoutineInvocationError): + sqlstate = '39P02' + + +class EventTriggerProtocolViolatedError(ExternalRoutineInvocationError): + sqlstate = '39P03' + + +class SavepointError(_base.PostgresError): + sqlstate = '3B000' + + +class InvalidSavepointSpecificationError(SavepointError): + sqlstate = '3B001' + + +class InvalidCatalogNameError(_base.PostgresError): + sqlstate = '3D000' + + +class InvalidSchemaNameError(_base.PostgresError): + sqlstate = '3F000' + + +class TransactionRollbackError(_base.PostgresError): + sqlstate = '40000' + + +class TransactionIntegrityConstraintViolationError(TransactionRollbackError): + sqlstate = '40002' + + +class SerializationError(TransactionRollbackError): + sqlstate = '40001' + + +class StatementCompletionUnknownError(TransactionRollbackError): + sqlstate = '40003' + + +class DeadlockDetectedError(TransactionRollbackError): + sqlstate = '40P01' + + +class SyntaxOrAccessError(_base.PostgresError): + sqlstate = '42000' + + +class PostgresSyntaxError(SyntaxOrAccessError): + sqlstate = '42601' + + +class InsufficientPrivilegeError(SyntaxOrAccessError): + sqlstate = '42501' + + +class CannotCoerceError(SyntaxOrAccessError): + sqlstate = '42846' + + +class GroupingError(SyntaxOrAccessError): + sqlstate = '42803' + + +class WindowingError(SyntaxOrAccessError): + sqlstate = '42P20' + + +class InvalidRecursionError(SyntaxOrAccessError): + sqlstate = '42P19' + + +class InvalidForeignKeyError(SyntaxOrAccessError): + sqlstate = '42830' + + +class InvalidNameError(SyntaxOrAccessError): + sqlstate = '42602' + + +class NameTooLongError(SyntaxOrAccessError): + sqlstate = '42622' + + +class ReservedNameError(SyntaxOrAccessError): + sqlstate = '42939' + + +class DatatypeMismatchError(SyntaxOrAccessError): + sqlstate = '42804' + + +class IndeterminateDatatypeError(SyntaxOrAccessError): + sqlstate = '42P18' + + +class CollationMismatchError(SyntaxOrAccessError): + sqlstate = '42P21' + + +class IndeterminateCollationError(SyntaxOrAccessError): + sqlstate = '42P22' + + +class WrongObjectTypeError(SyntaxOrAccessError): + sqlstate = '42809' + + +class UndefinedColumnError(SyntaxOrAccessError): + sqlstate = '42703' + + +class UndefinedFunctionError(SyntaxOrAccessError): + sqlstate = '42883' + + +class UndefinedTableError(SyntaxOrAccessError): + sqlstate = '42P01' + + +class UndefinedParameterError(SyntaxOrAccessError): + sqlstate = '42P02' + + +class UndefinedObjectError(SyntaxOrAccessError): + sqlstate = '42704' + + +class DuplicateColumnError(SyntaxOrAccessError): + sqlstate = '42701' + + +class DuplicateCursorError(SyntaxOrAccessError): + sqlstate = '42P03' + + +class DuplicateDatabaseError(SyntaxOrAccessError): + sqlstate = '42P04' + + +class DuplicateFunctionError(SyntaxOrAccessError): + sqlstate = '42723' + + +class DuplicatePreparedStatementError(SyntaxOrAccessError): + sqlstate = '42P05' + + +class DuplicateSchemaError(SyntaxOrAccessError): + sqlstate = '42P06' + + +class DuplicateTableError(SyntaxOrAccessError): + sqlstate = '42P07' + + +class DuplicateAliasError(SyntaxOrAccessError): + sqlstate = '42712' + + +class DuplicateObjectError(SyntaxOrAccessError): + sqlstate = '42710' + + +class AmbiguousColumnError(SyntaxOrAccessError): + sqlstate = '42702' + + +class AmbiguousFunctionError(SyntaxOrAccessError): + sqlstate = '42725' + + +class AmbiguousParameterError(SyntaxOrAccessError): + sqlstate = '42P08' + + +class AmbiguousAliasError(SyntaxOrAccessError): + sqlstate = '42P09' + + +class InvalidColumnReferenceError(SyntaxOrAccessError): + sqlstate = '42P10' + + +class InvalidColumnDefinitionError(SyntaxOrAccessError): + sqlstate = '42611' + + +class InvalidCursorDefinitionError(SyntaxOrAccessError): + sqlstate = '42P11' + + +class InvalidDatabaseDefinitionError(SyntaxOrAccessError): + sqlstate = '42P12' + + +class InvalidFunctionDefinitionError(SyntaxOrAccessError): + sqlstate = '42P13' + + +class InvalidPreparedStatementDefinitionError(SyntaxOrAccessError): + sqlstate = '42P14' + + +class InvalidSchemaDefinitionError(SyntaxOrAccessError): + sqlstate = '42P15' + + +class InvalidTableDefinitionError(SyntaxOrAccessError): + sqlstate = '42P16' + + +class InvalidObjectDefinitionError(SyntaxOrAccessError): + sqlstate = '42P17' + + +class WithCheckOptionViolationError(_base.PostgresError): + sqlstate = '44000' + + +class InsufficientResourcesError(_base.PostgresError): + sqlstate = '53000' + + +class DiskFullError(InsufficientResourcesError): + sqlstate = '53100' + + +class OutOfMemoryError(InsufficientResourcesError): + sqlstate = '53200' + + +class TooManyConnectionsError(InsufficientResourcesError): + sqlstate = '53300' + + +class ConfigurationLimitExceededError(InsufficientResourcesError): + sqlstate = '53400' + + +class ProgramLimitExceededError(_base.PostgresError): + sqlstate = '54000' + + +class StatementTooComplexError(ProgramLimitExceededError): + sqlstate = '54001' + + +class TooManyColumnsError(ProgramLimitExceededError): + sqlstate = '54011' + + +class TooManyArgumentsError(ProgramLimitExceededError): + sqlstate = '54023' + + +class ObjectNotInPrerequisiteStateError(_base.PostgresError): + sqlstate = '55000' + + +class ObjectInUseError(ObjectNotInPrerequisiteStateError): + sqlstate = '55006' + + +class CantChangeRuntimeParamError(ObjectNotInPrerequisiteStateError): + sqlstate = '55P02' + + +class LockNotAvailableError(ObjectNotInPrerequisiteStateError): + sqlstate = '55P03' + + +class OperatorInterventionError(_base.PostgresError): + sqlstate = '57000' + + +class QueryCanceledError(OperatorInterventionError): + sqlstate = '57014' + + +class AdminShutdownError(OperatorInterventionError): + sqlstate = '57P01' + + +class CrashShutdownError(OperatorInterventionError): + sqlstate = '57P02' + + +class CannotConnectNowError(OperatorInterventionError): + sqlstate = '57P03' + + +class DatabaseDroppedError(OperatorInterventionError): + sqlstate = '57P04' + + +class PostgresSystemError(_base.PostgresError): + sqlstate = '58000' + + +class PostgresIOError(PostgresSystemError): + sqlstate = '58030' + + +class UndefinedFileError(PostgresSystemError): + sqlstate = '58P01' + + +class DuplicateFileError(PostgresSystemError): + sqlstate = '58P02' + + +class SnapshotTooOldError(_base.PostgresError): + sqlstate = '72000' + + +class ConfigFileError(_base.PostgresError): + sqlstate = 'F0000' + + +class LockFileExistsError(ConfigFileError): + sqlstate = 'F0001' + + +class FDWError(_base.PostgresError): + sqlstate = 'HV000' + + +class FDWColumnNameNotFoundError(FDWError): + sqlstate = 'HV005' + + +class FDWDynamicParameterValueNeededError(FDWError): + sqlstate = 'HV002' + + +class FDWFunctionSequenceError(FDWError): + sqlstate = 'HV010' + + +class FDWInconsistentDescriptorInformationError(FDWError): + sqlstate = 'HV021' + + +class FDWInvalidAttributeValueError(FDWError): + sqlstate = 'HV024' + + +class FDWInvalidColumnNameError(FDWError): + sqlstate = 'HV007' + + +class FDWInvalidColumnNumberError(FDWError): + sqlstate = 'HV008' + + +class FDWInvalidDataTypeError(FDWError): + sqlstate = 'HV004' + + +class FDWInvalidDataTypeDescriptorsError(FDWError): + sqlstate = 'HV006' + + +class FDWInvalidDescriptorFieldIdentifierError(FDWError): + sqlstate = 'HV091' + + +class FDWInvalidHandleError(FDWError): + sqlstate = 'HV00B' + + +class FDWInvalidOptionIndexError(FDWError): + sqlstate = 'HV00C' + + +class FDWInvalidOptionNameError(FDWError): + sqlstate = 'HV00D' + + +class FDWInvalidStringLengthOrBufferLengthError(FDWError): + sqlstate = 'HV090' + + +class FDWInvalidStringFormatError(FDWError): + sqlstate = 'HV00A' + + +class FDWInvalidUseOfNullPointerError(FDWError): + sqlstate = 'HV009' + + +class FDWTooManyHandlesError(FDWError): + sqlstate = 'HV014' + + +class FDWOutOfMemoryError(FDWError): + sqlstate = 'HV001' + + +class FDWNoSchemasError(FDWError): + sqlstate = 'HV00P' + + +class FDWOptionNameNotFoundError(FDWError): + sqlstate = 'HV00J' + + +class FDWReplyHandleError(FDWError): + sqlstate = 'HV00K' + + +class FDWSchemaNotFoundError(FDWError): + sqlstate = 'HV00Q' + + +class FDWTableNotFoundError(FDWError): + sqlstate = 'HV00R' + + +class FDWUnableToCreateExecutionError(FDWError): + sqlstate = 'HV00L' + + +class FDWUnableToCreateReplyError(FDWError): + sqlstate = 'HV00M' + + +class FDWUnableToEstablishConnectionError(FDWError): + sqlstate = 'HV00N' + + +class PLPGSQLError(_base.PostgresError): + sqlstate = 'P0000' + + +class RaiseError(PLPGSQLError): + sqlstate = 'P0001' + + +class NoDataFoundError(PLPGSQLError): + sqlstate = 'P0002' + + +class TooManyRowsError(PLPGSQLError): + sqlstate = 'P0003' + + +class AssertError(PLPGSQLError): + sqlstate = 'P0004' + + +class InternalServerError(_base.PostgresError): + sqlstate = 'XX000' + + +class DataCorruptedError(InternalServerError): + sqlstate = 'XX001' + + +class IndexCorruptedError(InternalServerError): + sqlstate = 'XX002' + + +__all__ = _base.__all__ + ( + 'ActiveSQLTransactionError', 'AdminShutdownError', + 'AmbiguousAliasError', 'AmbiguousColumnError', + 'AmbiguousFunctionError', 'AmbiguousParameterError', + 'ArraySubscriptError', 'AssertError', 'BadCopyFileFormatError', + 'BranchTransactionAlreadyActiveError', 'CannotCoerceError', + 'CannotConnectNowError', 'CantChangeRuntimeParamError', + 'CardinalityViolationError', 'CaseNotFoundError', + 'CharacterNotInRepertoireError', 'CheckViolationError', + 'ClientCannotConnectError', 'CollationMismatchError', + 'ConfigFileError', 'ConfigurationLimitExceededError', + 'ConnectionDoesNotExistError', 'ConnectionFailureError', + 'ConnectionRejectionError', 'ContainingSQLNotPermittedError', + 'CrashShutdownError', 'DataCorruptedError', 'DataError', + 'DatabaseDroppedError', 'DatatypeMismatchError', + 'DatetimeFieldOverflowError', 'DeadlockDetectedError', + 'DependentObjectsStillExistError', + 'DependentPrivilegeDescriptorsStillExistError', 'DeprecatedFeature', + 'DiagnosticsError', 'DiskFullError', 'DivisionByZeroError', + 'DuplicateAliasError', 'DuplicateColumnError', 'DuplicateCursorError', + 'DuplicateDatabaseError', 'DuplicateFileError', + 'DuplicateFunctionError', 'DuplicateObjectError', + 'DuplicatePreparedStatementError', 'DuplicateSchemaError', + 'DuplicateTableError', 'DynamicResultSetsReturned', + 'ErrorInAssignmentError', 'EscapeCharacterConflictError', + 'EventTriggerProtocolViolatedError', 'ExclusionViolationError', + 'ExternalRoutineError', 'ExternalRoutineInvocationError', + 'FDWColumnNameNotFoundError', 'FDWDynamicParameterValueNeededError', + 'FDWError', 'FDWFunctionSequenceError', + 'FDWInconsistentDescriptorInformationError', + 'FDWInvalidAttributeValueError', 'FDWInvalidColumnNameError', + 'FDWInvalidColumnNumberError', 'FDWInvalidDataTypeDescriptorsError', + 'FDWInvalidDataTypeError', 'FDWInvalidDescriptorFieldIdentifierError', + 'FDWInvalidHandleError', 'FDWInvalidOptionIndexError', + 'FDWInvalidOptionNameError', 'FDWInvalidStringFormatError', + 'FDWInvalidStringLengthOrBufferLengthError', + 'FDWInvalidUseOfNullPointerError', 'FDWNoSchemasError', + 'FDWOptionNameNotFoundError', 'FDWOutOfMemoryError', + 'FDWReplyHandleError', 'FDWSchemaNotFoundError', + 'FDWTableNotFoundError', 'FDWTooManyHandlesError', + 'FDWUnableToCreateExecutionError', 'FDWUnableToCreateReplyError', + 'FDWUnableToEstablishConnectionError', 'FeatureNotSupportedError', + 'ForeignKeyViolationError', 'FunctionExecutedNoReturnStatementError', + 'GroupingError', 'HeldCursorRequiresSameIsolationLevelError', + 'IdleInTransactionSessionTimeoutError', 'ImplicitZeroBitPadding', + 'InFailedSQLTransactionError', + 'InappropriateAccessModeForBranchTransactionError', + 'InappropriateIsolationLevelForBranchTransactionError', + 'IndeterminateCollationError', 'IndeterminateDatatypeError', + 'IndexCorruptedError', 'IndicatorOverflowError', + 'InsufficientPrivilegeError', 'InsufficientResourcesError', + 'IntegrityConstraintViolationError', 'InternalServerError', + 'IntervalFieldOverflowError', 'InvalidArgumentForLogarithmError', + 'InvalidArgumentForNthValueFunctionError', + 'InvalidArgumentForNtileFunctionError', + 'InvalidArgumentForPowerFunctionError', + 'InvalidArgumentForWidthBucketFunctionError', + 'InvalidAuthorizationSpecificationError', + 'InvalidBinaryRepresentationError', 'InvalidCatalogNameError', + 'InvalidCharacterValueForCastError', 'InvalidColumnDefinitionError', + 'InvalidColumnReferenceError', 'InvalidCursorDefinitionError', + 'InvalidCursorNameError', 'InvalidCursorStateError', + 'InvalidDatabaseDefinitionError', 'InvalidDatetimeFormatError', + 'InvalidEscapeCharacterError', 'InvalidEscapeOctetError', + 'InvalidEscapeSequenceError', 'InvalidForeignKeyError', + 'InvalidFunctionDefinitionError', 'InvalidGrantOperationError', + 'InvalidGrantorError', 'InvalidIndicatorParameterValueError', + 'InvalidLocatorSpecificationError', 'InvalidNameError', + 'InvalidObjectDefinitionError', 'InvalidParameterValueError', + 'InvalidPasswordError', 'InvalidPreparedStatementDefinitionError', + 'InvalidRecursionError', 'InvalidRegularExpressionError', + 'InvalidRoleSpecificationError', 'InvalidRowCountInLimitClauseError', + 'InvalidRowCountInResultOffsetClauseError', + 'InvalidSQLStatementNameError', 'InvalidSavepointSpecificationError', + 'InvalidSchemaDefinitionError', 'InvalidSchemaNameError', + 'InvalidSqlstateReturnedError', 'InvalidTableDefinitionError', + 'InvalidTablesampleArgumentError', 'InvalidTablesampleRepeatError', + 'InvalidTextRepresentationError', + 'InvalidTimeZoneDisplacementValueError', + 'InvalidTransactionInitiationError', 'InvalidTransactionStateError', + 'InvalidTransactionTerminationError', + 'InvalidUseOfEscapeCharacterError', 'InvalidXmlCommentError', + 'InvalidXmlContentError', 'InvalidXmlDocumentError', + 'InvalidXmlProcessingInstructionError', 'LocatorError', + 'LockFileExistsError', 'LockNotAvailableError', + 'ModifyingExternalRoutineSQLDataNotPermittedError', + 'ModifyingSQLDataNotPermittedError', 'MostSpecificTypeMismatchError', + 'NameTooLongError', 'NoActiveSQLTransactionError', + 'NoActiveSQLTransactionForBranchTransactionError', + 'NoAdditionalDynamicResultSetsReturned', 'NoData', 'NoDataFoundError', + 'NonstandardUseOfEscapeCharacterError', 'NotAnXmlDocumentError', + 'NotNullViolationError', 'NullValueEliminatedInSetFunction', + 'NullValueInExternalRoutineNotAllowedError', + 'NullValueNoIndicatorParameterError', 'NullValueNotAllowedError', + 'NumericValueOutOfRangeError', 'ObjectInUseError', + 'ObjectNotInPrerequisiteStateError', 'OperatorInterventionError', + 'OutOfMemoryError', 'PLPGSQLError', 'PostgresConnectionError', + 'PostgresFloatingPointError', 'PostgresIOError', + 'PostgresSyntaxError', 'PostgresSystemError', 'PostgresWarning', + 'PrivilegeNotGranted', 'PrivilegeNotRevoked', + 'ProgramLimitExceededError', + 'ProhibitedExternalRoutineSQLStatementAttemptedError', + 'ProhibitedSQLStatementAttemptedError', 'ProtocolViolationError', + 'QueryCanceledError', 'RaiseError', 'ReadOnlySQLTransactionError', + 'ReadingExternalRoutineSQLDataNotPermittedError', + 'ReadingSQLDataNotPermittedError', 'ReservedNameError', + 'RestrictViolationError', 'SQLRoutineError', + 'SQLStatementNotYetCompleteError', 'SavepointError', + 'SchemaAndDataStatementMixingNotSupportedError', 'SerializationError', + 'SnapshotTooOldError', 'SrfProtocolViolatedError', + 'StackedDiagnosticsAccessedWithoutActiveHandlerError', + 'StatementCompletionUnknownError', 'StatementTooComplexError', + 'StringDataLengthMismatchError', 'StringDataRightTruncation', + 'StringDataRightTruncationError', 'SubstringError', + 'SyntaxOrAccessError', 'TooManyArgumentsError', 'TooManyColumnsError', + 'TooManyConnectionsError', 'TooManyRowsError', + 'TransactionIntegrityConstraintViolationError', + 'TransactionResolutionUnknownError', 'TransactionRollbackError', + 'TriggerProtocolViolatedError', 'TriggeredActionError', + 'TriggeredDataChangeViolationError', 'TrimError', + 'UndefinedColumnError', 'UndefinedFileError', + 'UndefinedFunctionError', 'UndefinedObjectError', + 'UndefinedParameterError', 'UndefinedTableError', + 'UniqueViolationError', 'UnterminatedCStringError', + 'UntranslatableCharacterError', 'WindowingError', + 'WithCheckOptionViolationError', 'WrongObjectTypeError', + 'ZeroLengthCharacterStringError' +) diff --git a/asyncpg/exceptions/_base.py b/asyncpg/exceptions/_base.py new file mode 100644 index 0000000..c2d1e7e --- /dev/null +++ b/asyncpg/exceptions/_base.py @@ -0,0 +1,109 @@ +# Copyright (C) 2016-present the ayncpg authors and contributors +# +# +# This module is part of asyncpg and is released under +# the Apache 2.0 License: http://www.apache.org/licenses/LICENSE-2.0 + + +import sys + + +__all__ = ('PostgresError', 'FatalPostgresError', 'UnknownPostgresError', + 'InterfaceError') + + +class PostgresMessageMeta(type): + _message_map = {} + _field_map = { + 'S': 'severity', + 'C': 'sqlstate', + 'M': 'message', + 'D': 'detail', + 'H': 'hint', + 'P': 'position', + 'p': 'internal_position', + 'q': 'internal_query', + 'W': 'context', + 's': 'schema_name', + 't': 'table_name', + 'c': 'column_name', + 'd': 'data_type_name', + 'n': 'constraint_name', + 'F': 'server_source_filename', + 'L': 'server_source_line', + 'R': 'server_source_function' + } + + def __new__(mcls, name, bases, dct): + cls = super().__new__(mcls, name, bases, dct) + if cls.__module__ == mcls.__module__ and name == 'PostgresMessage': + for f in mcls._field_map.values(): + setattr(cls, f, None) + + if (cls.__module__ == 'asyncpg' or + cls.__module__.startswith('asyncpg.')): + mod = sys.modules[cls.__module__] + if hasattr(mod, name): + raise RuntimeError('exception class redefinition: {}'.format( + name)) + + code = dct.get('sqlstate') + if code is not None: + existing = mcls._message_map.get(code) + if existing is not None: + raise TypeError('{} has duplicate SQLSTATE code, which is' + 'already defined by {}'.format( + name, existing.__name__)) + mcls._message_map[code] = cls + + return cls + + @classmethod + def get_message_class_for_sqlstate(mcls, code): + return mcls._message_map.get(code, UnknownPostgresError) + + +class PostgresMessage(metaclass=PostgresMessageMeta): + def __str__(self): + msg = self.message + if self.detail: + msg += '\nDETAIL: {}'.format(self.detail) + if self.hint: + msg += '\nHINT: {}'.format(self.hint) + + return msg + + @classmethod + def new(cls, fields, query=None): + errcode = fields.get('C') + mcls = cls.__class__ + exccls = mcls.get_message_class_for_sqlstate(errcode) + mapped = { + 'query': query + } + + for k, v in fields.items(): + field = mcls._field_map.get(k) + if field: + mapped[field] = v + + e = exccls(mapped.get('message')) + e.__dict__.update(mapped) + + return e + + +class PostgresError(Exception, PostgresMessage): + """Base class for all Postgres errors.""" + + +class FatalPostgresError(PostgresError): + """A fatal error that should result in server disconnection.""" + + +class UnknownPostgresError(FatalPostgresError): + """An error with an unknown SQLSTATE code.""" + + +class InterfaceError(Exception): + """An error caused by improper use of asyncpg API.""" diff --git a/asyncpg/introspection.py b/asyncpg/introspection.py new file mode 100644 index 0000000..a9050d9 --- /dev/null +++ b/asyncpg/introspection.py @@ -0,0 +1,269 @@ +# Copyright (C) 2016-present the ayncpg authors and contributors +# +# +# This module is part of asyncpg and is released under +# the Apache 2.0 License: http://www.apache.org/licenses/LICENSE-2.0 + + +INTRO_LOOKUP_TYPES = '''\ +WITH RECURSIVE typeinfo_tree( + oid, ns, name, kind, basetype, has_bin_io, elemtype, elemdelim, + range_subtype, elem_has_bin_io, attrtypoids, attrnames, depth) +AS ( + WITH composite_attrs + AS ( + SELECT + c.reltype AS comptype_oid, + array_agg(ia.atttypid ORDER BY ia.attnum) AS typoids, + array_agg(ia.attname::text ORDER BY ia.attnum) AS names + FROM + pg_attribute ia + INNER JOIN pg_class c + ON (ia.attrelid = c.oid) + WHERE + ia.attnum > 0 AND NOT ia.attisdropped + GROUP BY + c.reltype + ), + + typeinfo + AS ( + SELECT + t.oid AS oid, + ns.nspname AS ns, + t.typname AS name, + t.typtype AS kind, + (CASE WHEN t.typtype = 'd' THEN + (WITH RECURSIVE typebases(oid, depth) AS ( + SELECT + t2.typbasetype AS oid, + 0 AS depth + FROM + pg_type t2 + WHERE + t2.oid = t.oid + + UNION ALL + + SELECT + t2.typbasetype AS oid, + tb.depth + 1 AS depth + FROM + pg_type t2, + typebases tb + WHERE + tb.oid = t2.oid + AND t2.typbasetype != 0 + ) SELECT oid FROM typebases ORDER BY depth DESC LIMIT 1) + + ELSE NULL + END) AS basetype, + t.typreceive::oid != 0 AND t.typsend::oid != 0 + AS has_bin_io, + t.typelem AS elemtype, + elem_t.typdelim AS elemdelim, + range_t.rngsubtype AS range_subtype, + (CASE WHEN t.typtype = 'r' THEN + (SELECT + range_elem_t.typreceive::oid != 0 AND + range_elem_t.typsend::oid != 0 + FROM + pg_catalog.pg_type AS range_elem_t + WHERE + range_elem_t.oid = range_t.rngsubtype) + ELSE + elem_t.typreceive::oid != 0 AND + elem_t.typsend::oid != 0 + END) AS elem_has_bin_io, + (CASE WHEN t.typtype = 'c' THEN + (SELECT ca.typoids + FROM composite_attrs AS ca + WHERE ca.comptype_oid = t.oid) + + ELSE NULL + END) AS attrtypoids, + (CASE WHEN t.typtype = 'c' THEN + (SELECT ca.names + FROM composite_attrs AS ca + WHERE ca.comptype_oid = t.oid) + + ELSE NULL + END) AS attrnames + FROM + pg_catalog.pg_type AS t + INNER JOIN pg_catalog.pg_namespace ns ON ( + ns.oid = t.typnamespace) + LEFT JOIN pg_type elem_t ON ( + t.typlen = -1 AND + t.typelem != 0 AND + t.typelem = elem_t.oid + ) + LEFT JOIN pg_range range_t ON ( + t.oid = range_t.rngtypid + ) + ) + + SELECT + ti.oid, ti.ns, ti.name, ti.kind, ti.basetype, ti.has_bin_io, + ti.elemtype, ti.elemdelim, ti.range_subtype, ti.elem_has_bin_io, + ti.attrtypoids, ti.attrnames, 0 + FROM + typeinfo AS ti + WHERE + ti.oid = any($1::oid[]) + + UNION ALL + + SELECT + ti.oid, ti.ns, ti.name, ti.kind, ti.basetype, ti.has_bin_io, + ti.elemtype, ti.elemdelim, ti.range_subtype, ti.elem_has_bin_io, + ti.attrtypoids, ti.attrnames, tt.depth + 1 + FROM + typeinfo ti, + typeinfo_tree tt + WHERE + (tt.elemtype IS NOT NULL AND ti.oid = tt.elemtype) + OR (tt.attrtypoids IS NOT NULL AND ti.oid = any(tt.attrtypoids)) + OR (tt.range_subtype IS NOT NULL AND ti.oid = tt.range_subtype) +) + +SELECT DISTINCT + * +FROM + typeinfo_tree +ORDER BY + depth DESC +''' + + +# Prior to 9.2 PostgreSQL did not have range types. +INTRO_LOOKUP_TYPES_91 = '''\ +WITH RECURSIVE typeinfo_tree( + oid, ns, name, kind, basetype, has_bin_io, elemtype, elemdelim, + range_subtype, elem_has_bin_io, attrtypoids, attrnames, depth) +AS ( + WITH composite_attrs + AS ( + SELECT + c.reltype AS comptype_oid, + array_agg(ia.atttypid ORDER BY ia.attnum) AS typoids, + array_agg(ia.attname::text ORDER BY ia.attnum) AS names + FROM + pg_attribute ia + INNER JOIN pg_class c + ON (ia.attrelid = c.oid) + WHERE + ia.attnum > 0 AND NOT ia.attisdropped + GROUP BY + c.reltype + ), + + typeinfo + AS ( + SELECT + t.oid AS oid, + ns.nspname AS ns, + t.typname AS name, + t.typtype AS kind, + (CASE WHEN t.typtype = 'd' THEN + (WITH RECURSIVE typebases(oid, depth) AS ( + SELECT + t2.typbasetype AS oid, + 0 AS depth + FROM + pg_type t2 + WHERE + t2.oid = t.oid + + UNION ALL + + SELECT + t2.typbasetype AS oid, + tb.depth + 1 AS depth + FROM + pg_type t2, + typebases tb + WHERE + tb.oid = t2.oid + AND t2.typbasetype != 0 + ) SELECT oid FROM typebases ORDER BY depth DESC LIMIT 1) + + ELSE NULL + END) AS basetype, + t.typreceive::oid != 0 AND t.typsend::oid != 0 + AS has_bin_io, + t.typelem AS elemtype, + elem_t.typdelim AS elemdelim, + NULL::oid AS range_subtype, + elem_t.typreceive::oid != 0 AND + elem_t.typsend::oid != 0 + AS elem_has_bin_io, + (CASE WHEN t.typtype = 'c' THEN + (SELECT ca.typoids + FROM composite_attrs AS ca + WHERE ca.comptype_oid = t.oid) + + ELSE NULL + END) AS attrtypoids, + (CASE WHEN t.typtype = 'c' THEN + (SELECT ca.names + FROM composite_attrs AS ca + WHERE ca.comptype_oid = t.oid) + + ELSE NULL + END) AS attrnames + FROM + pg_catalog.pg_type AS t + INNER JOIN pg_catalog.pg_namespace ns ON ( + ns.oid = t.typnamespace) + LEFT JOIN pg_type elem_t ON ( + t.typlen = -1 AND + t.typelem != 0 AND + t.typelem = elem_t.oid + ) + ) + + SELECT + ti.oid, ti.ns, ti.name, ti.kind, ti.basetype, ti.has_bin_io, + ti.elemtype, ti.elemdelim, ti.range_subtype, ti.elem_has_bin_io, + ti.attrtypoids, ti.attrnames, 0 + FROM + typeinfo AS ti + WHERE + ti.oid = any($1::oid[]) + + UNION ALL + + SELECT + ti.oid, ti.ns, ti.name, ti.kind, ti.basetype, ti.has_bin_io, + ti.elemtype, ti.elemdelim, ti.range_subtype, ti.elem_has_bin_io, + ti.attrtypoids, ti.attrnames, tt.depth + 1 + FROM + typeinfo ti, + typeinfo_tree tt + WHERE + (tt.elemtype IS NOT NULL AND ti.oid = tt.elemtype) + OR (tt.attrtypoids IS NOT NULL AND ti.oid = any(tt.attrtypoids)) + OR (tt.range_subtype IS NOT NULL AND ti.oid = tt.range_subtype) +) + +SELECT DISTINCT + * +FROM + typeinfo_tree +ORDER BY + depth DESC +''' + + +TYPE_BY_NAME = '''\ +SELECT + t.oid, + t.typelem AS elemtype, + t.typtype AS kind +FROM + pg_catalog.pg_type AS t + INNER JOIN pg_catalog.pg_namespace ns ON (ns.oid = t.typnamespace) +WHERE + t.typname = $1 AND ns.nspname = $2 +''' diff --git a/asyncpg/pool.py b/asyncpg/pool.py new file mode 100644 index 0000000..259dced --- /dev/null +++ b/asyncpg/pool.py @@ -0,0 +1,311 @@ +# Copyright (C) 2016-present the ayncpg authors and contributors +# +# +# This module is part of asyncpg and is released under +# the Apache 2.0 License: http://www.apache.org/licenses/LICENSE-2.0 + + +import asyncio + +from . import connection +from . import exceptions + + +class Pool: + """A connection pool. + + Connection pool can be used to manage a set of connections to the database. + Connections are first acquired from the pool, then used, and then released + back to the pool. Once a connection is released, it's reset to close all + open cursors and other resources *except* prepared statements. + + Pools are created by calling :func:`~asyncpg.pool.create_pool`. + """ + + __slots__ = ('_queue', '_loop', '_minsize', '_maxsize', + '_connect_args', '_connect_kwargs', + '_working_addr', '_working_opts', + '_con_count', '_max_queries', '_connections', + '_initialized', '_closed', '_setup') + + def __init__(self, *connect_args, + min_size, + max_size, + max_queries, + setup, + loop, + **connect_kwargs): + + if loop is None: + loop = asyncio.get_event_loop() + self._loop = loop + + if max_size <= 0: + raise ValueError('max_size is expected to be greater than zero') + + if min_size <= 0: + raise ValueError('min_size is expected to be greater than zero') + + if min_size > max_size: + raise ValueError('min_size is greater than max_size') + + if max_queries <= 0: + raise ValueError('max_queries is expected to be greater than zero') + + self._minsize = min_size + self._maxsize = max_size + self._max_queries = max_queries + + self._setup = setup + + self._connect_args = connect_args + self._connect_kwargs = connect_kwargs + + self._working_addr = None + self._working_opts = None + + self._reset() + + self._closed = False + + async def _new_connection(self): + if self._working_addr is None: + con = await connection.connect(*self._connect_args, + loop=self._loop, + **self._connect_kwargs) + + self._working_addr = con._addr + self._working_opts = con._opts + + else: + if isinstance(self._working_addr, str): + host = self._working_addr + port = 0 + else: + host, port = self._working_addr + + con = await connection.connect(host=host, port=port, + loop=self._loop, + **self._working_opts) + + self._connections.add(con) + return con + + async def _init(self): + if self._initialized: + return + if self._closed: + raise exceptions.InterfaceError('pool is closed') + + for _ in range(self._minsize): + self._con_count += 1 + try: + con = await self._new_connection() + except: + self._con_count -= 1 + raise + self._queue.put_nowait(con) + + self._initialized = True + return self + + def acquire(self, *, timeout=None): + """Acquire a database connection from the pool. + + :param float timeout: A timeout for acquiring a Connection. + :return: An instance of :class:`~asyncpg.connection.Connection`. + + Can be used in an ``await`` expression or with an ``async with`` block. + + .. code-block:: python + + async with pool.acquire() as con: + await con.execute(...) + + Or: + + .. code-block:: python + + con = await pool.acquire() + try: + await con.execute(...) + finally: + await pool.release(con) + """ + return PoolAcquireContext(self, timeout) + + async def _acquire(self, timeout): + if timeout is None: + return await self._acquire_impl() + else: + return await asyncio.wait_for(self._acquire_impl(), + timeout=timeout, + loop=self._loop) + + async def _acquire_impl(self): + self._check_init() + + try: + con = self._queue.get_nowait() + except asyncio.QueueEmpty: + con = None + + if con is None: + if self._con_count < self._maxsize: + self._con_count += 1 + try: + con = await self._new_connection() + except: + self._con_count -= 1 + raise + else: + con = await self._queue.get() + + if self._setup is not None: + try: + await self._setup(con) + except: + await self.release(con) + raise + + return con + + async def release(self, connection): + """Release a database connection back to the pool.""" + self._check_init() + if connection.is_closed(): + self._con_count -= 1 + self._connections.remove(connection) + elif connection._protocol.queries_count >= self._max_queries: + self._con_count -= 1 + self._connections.remove(connection) + await connection.close() + else: + await connection.reset() + self._queue.put_nowait(connection) + + async def close(self): + """Gracefully close all connections in the pool.""" + if self._closed: + return + self._check_init() + self._closed = True + coros = [] + for con in self._connections: + coros.append(con.close()) + await asyncio.gather(*coros, loop=self._loop) + self._reset() + + def terminate(self): + """Terminate all connections in the pool.""" + if self._closed: + return + self._check_init() + self._closed = True + for con in self._connections: + con.terminate() + self._reset() + + def _check_init(self): + if not self._initialized: + raise exceptions.InterfaceError('pool is not initialized') + if self._closed: + raise exceptions.InterfaceError('pool is closed') + + def _reset(self): + self._connections = set() + self._con_count = 0 + self._initialized = False + self._queue = asyncio.Queue(maxsize=self._maxsize, loop=self._loop) + + def __await__(self): + return self._init().__await__() + + async def __aenter__(self): + await self._init() + return self + + async def __aexit__(self, *exc): + await self.close() + + +class PoolAcquireContext: + + __slots__ = ('timeout', 'connection', 'done', 'pool') + + def __init__(self, pool, timeout): + self.pool = pool + self.timeout = timeout + self.connection = None + self.done = False + + async def __aenter__(self): + if self.connection is not None or self.done: + raise exceptions.InterfaceError('a connection is already acquired') + self.connection = await self.pool._acquire(self.timeout) + return self.connection + + async def __aexit__(self, *exc): + self.done = True + con = self.connection + self.connection = None + await self.pool.release(con) + + def __await__(self): + self.done = True + return self.pool._acquire(self.timeout).__await__() + + +def create_pool(dsn=None, *, + min_size=10, + max_size=10, + max_queries=50000, + setup=None, + loop=None, + **connect_kwargs): + r"""Create a connection pool. + + Can be used either with an ``async with`` block: + + .. code-block:: python + + async with asyncpg.create_pool(user='postgres', + command_timeout=60) as pool: + async with pool.acquire() as con: + await con.fetch('SELECT 1') + + Or directly with ``await``: + + .. code-block:: python + + pool = await asyncpg.create_pool(user='postgres', command_timeout=60) + con = await pool.acquire() + try: + await con.fetch('SELECT 1') + finally: + await pool.release(con) + + :param str dsn: Connection arguments specified using as a single string in + the following format: + ``postgres://user:pass@host:port/database?option=value``. + + :param \*\*connect_kwargs: Keyword arguments for the + :func:`~asyncpg.connection.connect` function. + :param int min_size: Number of connection the pool will be initialized + with. + :param int max_size: Max number of connections in the pool. + :param int max_queries: Number of queries after a connection is closed + and replaced with a new connection. + :param coroutine setup: A coroutine to initialize a connection right before + it is returned from :meth:`~pool.Pool.acquire`. + An example use case would be to automatically + set up notifications listeners for all connections + of a pool. + :param loop: An asyncio event loop instance. If ``None``, the default + event loop will be used. + :return: An instance of :class:`~asyncpg.pool.Pool`. + """ + return Pool(dsn, + min_size=min_size, max_size=max_size, + max_queries=max_queries, loop=loop, setup=setup, + **connect_kwargs) diff --git a/asyncpg/prepared_stmt.py b/asyncpg/prepared_stmt.py new file mode 100644 index 0000000..fa35c9d --- /dev/null +++ b/asyncpg/prepared_stmt.py @@ -0,0 +1,210 @@ +# Copyright (C) 2016-present the ayncpg authors and contributors +# +# +# This module is part of asyncpg and is released under +# the Apache 2.0 License: http://www.apache.org/licenses/LICENSE-2.0 + + +import json + +from . import cursor +from . import exceptions + + +class PreparedStatement: + """A representation of a prepared statement.""" + + __slots__ = ('_connection', '_state', '_query', '_last_status') + + def __init__(self, connection, query, state): + self._connection = connection + self._state = state + self._query = query + state.attach() + self._last_status = None + + def get_query(self) -> str: + """Return the text of the query for this prepared statement. + + Example:: + + stmt = await connection.prepare('SELECT $1::int') + assert stmt.get_query() == "SELECT $1::int" + """ + return self._query + + def get_statusmsg(self) -> str: + """Return the status of the executed command. + + Example:: + + stmt = await connection.prepare('CREATE TABLE mytab (a int)') + await stmt.fetch() + assert stmt.get_statusmsg() == "CREATE TABLE" + """ + if self._last_status is None: + return self._last_status + return self._last_status.decode() + + def get_parameters(self): + """Return a description of statement parameters types. + + :return: A tuple of :class:`asyncpg.types.Type`. + + Example:: + + stmt = await connection.prepare('SELECT ($1::int, $2::text)') + print(stmt.get_parameters()) + + # Will print: + # (Type(oid=23, name='int4', kind='scalar', schema='pg_catalog'), + # Type(oid=25, name='text', kind='scalar', schema='pg_catalog')) + """ + self.__check_open() + return self._state._get_parameters() + + def get_attributes(self): + """Return a description of relation attributes (columns). + + :return: A tuple of :class:`asyncpg.types.Attribute`. + + Example:: + + st = await self.con.prepare(''' + SELECT typname, typnamespace FROM pg_type + ''') + print(st.get_attributes()) + + # Will print: + # (Attribute( + # name='typname', + # type=Type(oid=19, name='name', kind='scalar', + # schema='pg_catalog')), + # Attribute( + # name='typnamespace', + # type=Type(oid=26, name='oid', kind='scalar', + # schema='pg_catalog'))) + """ + self.__check_open() + return self._state._get_attributes() + + def cursor(self, *args, prefetch=None, + timeout=None) -> cursor.CursorFactory: + """Return a *cursor factory* for the prepared statement. + + :param args: Query arguments. + :param int prefetch: The number of rows the *cursor iterator* + will prefetch (defaults to ``50``.) + :param float timeout: Optional timeout in seconds. + + :return: A :class:`~cursor.CursorFactory` object. + """ + self.__check_open() + return cursor.CursorFactory(self._connection, self._query, + self._state, args, prefetch, + timeout) + + async def explain(self, *args, analyze=False): + """Return the execution plan of the statement. + + :param args: Query arguments. + :param analyze: If ``True``, the statement will be executed and + the run time statitics added to the return value. + + :return: An object representing the execution plan. This value + is actually a deserialized JSON output of the SQL + ``EXPLAIN`` command. + """ + query = 'EXPLAIN (FORMAT JSON, VERBOSE' + if analyze: + query += ', ANALYZE) ' + else: + query += ') ' + query += self._state.query + + if analyze: + # From PostgreSQL docs: + # Important: Keep in mind that the statement is actually + # executed when the ANALYZE option is used. Although EXPLAIN + # will discard any output that a SELECT would return, other + # side effects of the statement will happen as usual. If you + # wish to use EXPLAIN ANALYZE on an INSERT, UPDATE, DELETE, + # CREATE TABLE AS, or EXECUTE statement without letting the + # command affect your data, use this approach: + # BEGIN; + # EXPLAIN ANALYZE ...; + # ROLLBACK; + tr = self._connection.transaction() + await tr.start() + try: + data = await self._connection.fetchval(query, *args) + finally: + await tr.rollback() + else: + data = await self._connection.fetchval(query, *args) + + return json.loads(data) + + async def fetch(self, *args, timeout=None): + r"""Execute the statement and return a list of :class:`Record` objects. + + :param str query: Query text + :param args: Query arguments + :param float timeout: Optional timeout value in seconds. + + :return: A list of :class:`Record` instances. + """ + self.__check_open() + protocol = self._connection._protocol + data, status, _ = await protocol.bind_execute( + self._state, args, '', 0, True, timeout) + self._last_status = status + return data + + async def fetchval(self, *args, column=0, timeout=None): + """Execute the statement and return a value in the first row. + + :param args: Query arguments. + :param int column: Numeric index within the record of the value to + return (defaults to 0). + :param float timeout: Optional timeout value in seconds. + If not specified, defaults to the value of + ``command_timeout`` argument to the ``Connection`` + instance constructor. + + :return: The value of the specified column of the first record. + """ + self.__check_open() + protocol = self._connection._protocol + data, status, _ = await protocol.bind_execute( + self._state, args, '', 1, True, timeout) + self._last_status = status + if not data: + return None + return data[0][column] + + async def fetchrow(self, *args, timeout=None): + """Execute the statement and return the first row. + + :param str query: Query text + :param args: Query arguments + :param float timeout: Optional timeout value in seconds. + + :return: The first row as a :class:`Record` instance. + """ + self.__check_open() + protocol = self._connection._protocol + data, status, _ = await protocol.bind_execute( + self._state, args, '', 1, True, timeout) + self._last_status = status + if not data: + return None + return data[0] + + def __check_open(self): + if self._state.closed: + raise exceptions.InterfaceError('prepared statement is closed') + + def __del__(self): + self._state.detach() + self._connection._maybe_gc_stmt(self._state) diff --git a/asyncpg/protocol/__init__.py b/asyncpg/protocol/__init__.py new file mode 100644 index 0000000..44ac549 --- /dev/null +++ b/asyncpg/protocol/__init__.py @@ -0,0 +1,8 @@ +# Copyright (C) 2016-present the ayncpg authors and contributors +# +# +# This module is part of asyncpg and is released under +# the Apache 2.0 License: http://www.apache.org/licenses/LICENSE-2.0 + + +from .protocol import Protocol diff --git a/asyncpg/protocol/buffer.pxd b/asyncpg/protocol/buffer.pxd new file mode 100644 index 0000000..6687e8e --- /dev/null +++ b/asyncpg/protocol/buffer.pxd @@ -0,0 +1,131 @@ +# Copyright (C) 2016-present the ayncpg authors and contributors +# +# +# This module is part of asyncpg and is released under +# the Apache 2.0 License: http://www.apache.org/licenses/LICENSE-2.0 + + +cdef class Memory: + cdef: + char* buf + object owner + ssize_t length + + cdef as_bytes(self) + + @staticmethod + cdef inline Memory new(char* buf, object owner, ssize_t length) + + +cdef class WriteBuffer: + cdef: + # Preallocated small buffer + bint _smallbuf_inuse + char _smallbuf[_BUFFER_INITIAL_SIZE] + + char *_buf + + # Allocated size + ssize_t _size + + # Length of data in the buffer + ssize_t _length + + # Number of memoryviews attached to the buffer + int _view_count + + # True is start_message was used + bint _message_mode + + cdef inline _check_readonly(self) + cdef inline len(self) + cdef inline _ensure_alloced(self, ssize_t extra_length) + cdef _reallocate(self, ssize_t new_size) + cdef inline start_message(self, char type) + cdef inline end_message(self) + cdef write_buffer(self, WriteBuffer buf) + cdef write_byte(self, char b) + cdef write_bytes(self, bytes data) + cdef write_bytestring(self, bytes string) + cdef write_str(self, str string, str encoding) + cdef write_cstr(self, char *data, ssize_t len) + cdef write_int16(self, int16_t i) + cdef write_int32(self, int32_t i) + cdef write_int64(self, int64_t i) + cdef write_float(self, float f) + cdef write_double(self, double d) + + @staticmethod + cdef WriteBuffer new_message(char type) + + @staticmethod + cdef WriteBuffer new() + + +cdef class ReadBuffer: + cdef: + # A deque of buffers (bytes objects) + object _bufs + object _bufs_append + object _bufs_popleft + + # A pointer to the first buffer in `_bufs` + bytes _buf0 + + # A pointer to the previous first buffer + # (used to prolong the life of _buf0 when using + # methods like _try_read_bytes) + bytes _buf0_prev + + # Number of buffers in `_bufs` + int32_t _bufs_len + + # A read position in the first buffer in `_bufs` + ssize_t _pos0 + + # Length of the first buffer in `_bufs` + ssize_t _len0 + + # A total number of buffered bytes in ReadBuffer + ssize_t _length + + char _current_message_type + int _current_message_len + ssize_t _current_message_len_unread + bint _current_message_ready + + cdef feed_data(self, data) + cdef inline _ensure_first_buf(self) + cdef _switch_to_next_buf(self) + cdef inline read_byte(self) + cdef inline char* _try_read_bytes(self, ssize_t nbytes) + cdef inline read(self, ssize_t nbytes) + cdef inline read_bytes(self, ssize_t n) + cdef inline read_int32(self) + cdef inline read_int16(self) + cdef inline read_cstr(self) + cdef int32_t has_message(self) except -1 + cdef inline char* try_consume_message(self, ssize_t* len) + cdef Memory consume_message(self) + cdef discard_message(self) + cdef inline _discard_message(self) + cdef inline char get_message_type(self) + cdef inline int32_t get_message_length(self) + + @staticmethod + cdef ReadBuffer new_message_parser(object data) + + +cdef class FastReadBuffer: + cdef: + const char* buf + ssize_t len + + cdef inline const char* read(self, ssize_t n) except NULL + cdef inline const char* read_all(self) + cdef inline FastReadBuffer slice_from(self, FastReadBuffer source, + ssize_t len) + cdef _raise_ins_err(self, ssize_t n, ssize_t len) + + @staticmethod + cdef FastReadBuffer new() diff --git a/asyncpg/protocol/buffer.pyx b/asyncpg/protocol/buffer.pyx new file mode 100644 index 0000000..e999b7a --- /dev/null +++ b/asyncpg/protocol/buffer.pyx @@ -0,0 +1,616 @@ +# Copyright (C) 2016-present the ayncpg authors and contributors +# +# +# This module is part of asyncpg and is released under +# the Apache 2.0 License: http://www.apache.org/licenses/LICENSE-2.0 + + +from cpython cimport Py_buffer +from libc.string cimport memcpy + + +class BufferError(Exception): + pass + +@cython.no_gc_clear +@cython.final +@cython.freelist(_MEMORY_FREELIST_SIZE) +cdef class Memory: + + cdef as_bytes(self): + return cpython.PyBytes_FromStringAndSize(self.buf, self.length) + + @staticmethod + cdef inline Memory new(char* buf, object owner, ssize_t length): + cdef Memory mem + mem = Memory.__new__(Memory) + mem.buf = buf + mem.owner = owner + mem.length = length + return mem + + +@cython.no_gc_clear +@cython.final +@cython.freelist(_BUFFER_FREELIST_SIZE) +cdef class WriteBuffer: + + def __cinit__(self): + self._smallbuf_inuse = True + self._buf = self._smallbuf + self._size = _BUFFER_INITIAL_SIZE + self._length = 0 + self._message_mode = 0 + + def __dealloc__(self): + if self._buf is not NULL and not self._smallbuf_inuse: + PyMem_Free(self._buf) + self._buf = NULL + self._size = 0 + + if self._view_count: + raise RuntimeError( + 'Deallocating buffer with attached memoryviews') + + def __getbuffer__(self, Py_buffer *buffer, int flags): + self._view_count += 1 + + PyBuffer_FillInfo( + buffer, self, self._buf, self._length, + 1, # read-only + flags) + + def __releasebuffer__(self, Py_buffer *buffer): + self._view_count -= 1 + + cdef inline _check_readonly(self): + if self._view_count: + raise BufferError('the buffer is in read-only mode') + + cdef inline len(self): + return self._length + + cdef inline _ensure_alloced(self, ssize_t extra_length): + cdef ssize_t new_size = extra_length + self._length + + if new_size > self._size: + self._reallocate(new_size) + + cdef _reallocate(self, ssize_t new_size): + cdef char *new_buf + + if new_size < _BUFFER_MAX_GROW: + new_size = _BUFFER_MAX_GROW + else: + # Add a little extra + new_size += _BUFFER_INITIAL_SIZE + + if self._smallbuf_inuse: + new_buf = PyMem_Malloc(sizeof(char) * new_size) + if new_buf is NULL: + self._buf = NULL + self._size = 0 + self._length = 0 + raise MemoryError + memcpy(new_buf, self._buf, self._size) + self._size = new_size + self._buf = new_buf + self._smallbuf_inuse = False + else: + new_buf = PyMem_Realloc(self._buf, new_size) + if new_buf is NULL: + PyMem_Free(self._buf) + self._buf = NULL + self._size = 0 + self._length = 0 + raise MemoryError + self._buf = new_buf + self._size = new_size + + cdef inline start_message(self, char type): + if self._length != 0: + raise BufferError('cannot start_message for a non-empty buffer') + self._ensure_alloced(5) + self._message_mode = 1 + self._buf[0] = type + self._length = 5 + + cdef inline end_message(self): + # "length-1" to exclude the message type byte + cdef ssize_t mlen = self._length - 1 + + self._check_readonly() + if not self._message_mode: + raise BufferError( + 'end_message can only be called with start_message') + if self._length < 5: + raise BufferError('end_message: buffer is too small') + if mlen > _MAXINT32: + raise BufferError('end_message: message is too large') + + hton.pack_int32(&self._buf[1], mlen) + return self + + cdef write_buffer(self, WriteBuffer buf): + self._check_readonly() + + if not buf._length: + return + + self._ensure_alloced(buf._length) + memcpy(self._buf + self._length, + buf._buf, + buf._length) + self._length += buf._length + + cdef write_byte(self, char b): + self._check_readonly() + + self._ensure_alloced(1) + self._buf[self._length] = b + self._length += 1 + + cdef write_bytes(self, bytes data): + cdef char* buf + cdef ssize_t len + + cpython.PyBytes_AsStringAndSize(data, &buf, &len) + self.write_cstr(buf, len) + + cdef write_bytestring(self, bytes string): + cdef char* buf + cdef ssize_t len + + cpython.PyBytes_AsStringAndSize(string, &buf, &len) + # PyBytes_AsStringAndSize returns a null-terminated buffer, + # but the null byte is not counted in len. hence the + 1 + self.write_cstr(buf, len + 1) + + cdef write_str(self, str string, str encoding): + self.write_bytestring(string.encode(encoding)) + + cdef write_cstr(self, char *data, ssize_t len): + self._check_readonly() + self._ensure_alloced(len) + + memcpy(self._buf + self._length, data, len) + self._length += len + + cdef write_int16(self, int16_t i): + self._check_readonly() + self._ensure_alloced(2) + + hton.pack_int16(&self._buf[self._length], i) + self._length += 2 + + cdef write_int32(self, int32_t i): + self._check_readonly() + self._ensure_alloced(4) + + hton.pack_int32(&self._buf[self._length], i) + self._length += 4 + + cdef write_int64(self, int64_t i): + self._check_readonly() + self._ensure_alloced(8) + + hton.pack_int64(&self._buf[self._length], i) + self._length += 8 + + cdef write_float(self, float f): + self._check_readonly() + self._ensure_alloced(4) + + hton.pack_float(&self._buf[self._length], f) + self._length += 4 + + cdef write_double(self, double d): + self._check_readonly() + self._ensure_alloced(8) + + hton.pack_double(&self._buf[self._length], d) + self._length += 8 + + @staticmethod + cdef WriteBuffer new_message(char type): + cdef WriteBuffer buf + buf = WriteBuffer.__new__(WriteBuffer) + buf.start_message(type) + return buf + + @staticmethod + cdef WriteBuffer new(): + cdef WriteBuffer buf + buf = WriteBuffer.__new__(WriteBuffer) + return buf + + +@cython.no_gc_clear +@cython.final +@cython.freelist(_BUFFER_FREELIST_SIZE) +cdef class ReadBuffer: + + def __cinit__(self): + self._bufs = collections.deque() + self._bufs_append = self._bufs.append + self._bufs_popleft = self._bufs.popleft + self._bufs_len = 0 + self._buf0 = None + self._buf0_prev = None + self._pos0 = 0 + self._len0 = 0 + self._length = 0 + + self._current_message_type = 0 + self._current_message_len = 0 + self._current_message_len_unread = 0 + self._current_message_ready = 0 + + cdef feed_data(self, data): + cdef: + ssize_t dlen + bytes data_bytes + + if not cpython.PyBytes_CheckExact(data): + raise BufferError('feed_data: bytes object expected') + data_bytes = data + + dlen = cpython.Py_SIZE(data_bytes) + if dlen == 0: + # EOF? + return + + self._bufs_append(data_bytes) + self._length += dlen + + if self._bufs_len == 0: + # First buffer + self._len0 = dlen + self._buf0 = data_bytes + + self._bufs_len += 1 + + cdef inline _ensure_first_buf(self): + if self._len0 == 0: + raise BufferError('empty first buffer') + + if self._pos0 == self._len0: + self._switch_to_next_buf() + + cdef _switch_to_next_buf(self): + # The first buffer is fully read, discard it + self._bufs_popleft() + self._bufs_len -= 1 + + # Shouldn't fail, since we've checked that `_length >= 1` + # in _ensure_first_buf() + self._buf0_prev = self._buf0 + self._buf0 = self._bufs[0] + + self._pos0 = 0 + self._len0 = len(self._buf0) + + if ASYNCPG_DEBUG: + if self._len0 < 1: + raise RuntimeError( + 'debug: second buffer of ReadBuffer is empty') + + cdef inline char* _try_read_bytes(self, ssize_t nbytes): + # Important: caller must call _ensure_first_buf() prior + # to calling try_read_bytes, and must not overread + + cdef: + char * result + + if ASYNCPG_DEBUG: + if nbytes > self._length: + return NULL + + if self._current_message_ready: + if self._current_message_len_unread < nbytes: + return NULL + + if self._pos0 + nbytes <= self._len0: + result = cpython.PyBytes_AS_STRING(self._buf0) + result += self._pos0 + self._pos0 += nbytes + self._length -= nbytes + if self._current_message_ready: + self._current_message_len_unread -= nbytes + return result + else: + return NULL + + cdef inline read(self, ssize_t nbytes): + cdef: + object result + ssize_t nread + char *buf + + self._ensure_first_buf() + buf = self._try_read_bytes(nbytes) + if buf != NULL: + return Memory.new(buf, self._buf0, nbytes) + + if nbytes > self._length: + raise BufferError( + 'not enough data to read {} bytes'.format(nbytes)) + + if self._current_message_ready: + self._current_message_len_unread -= nbytes + if self._current_message_len_unread < 0: + raise BufferError('buffer overread') + + result = bytearray() + while True: + if self._pos0 + nbytes > self._len0: + result.extend(self._buf0[self._pos0:]) + nread = self._len0 - self._pos0 + self._pos0 = self._len0 + self._length -= nread + nbytes -= nread + self._ensure_first_buf() + + else: + result.extend(self._buf0[self._pos0:self._pos0 + nbytes]) + self._pos0 += nbytes + self._length -= nbytes + return Memory.new( + PyByteArray_AsString(result), + result, + len(result)) + + cdef inline read_byte(self): + cdef char* first_byte + + if ASYNCPG_DEBUG: + if not self._buf0: + raise RuntimeError( + 'debug: first buffer of ReadBuffer is empty') + + self._ensure_first_buf() + first_byte = self._try_read_bytes(1) + if first_byte is NULL: + raise BufferError('not enough data to read one byte') + + return first_byte[0] + + cdef inline read_bytes(self, ssize_t n): + cdef: + Memory mem + char *cbuf + + self._ensure_first_buf() + cbuf = self._try_read_bytes(n) + if cbuf != NULL: + return cbuf + else: + mem = (self.read(n)) + return mem.buf + + cdef inline read_int32(self): + cdef: + Memory mem + char *cbuf + + self._ensure_first_buf() + cbuf = self._try_read_bytes(4) + if cbuf != NULL: + return hton.unpack_int32(cbuf) + else: + mem = (self.read(4)) + return hton.unpack_int32(mem.buf) + + cdef inline read_int16(self): + cdef: + Memory mem + char *cbuf + + self._ensure_first_buf() + cbuf = self._try_read_bytes(2) + if cbuf != NULL: + return hton.unpack_int16(cbuf) + else: + mem = (self.read(2)) + return hton.unpack_int16(mem.buf) + + cdef inline read_cstr(self): + if not self._current_message_ready: + raise BufferError( + 'read_cstr only works when the message guaranteed ' + 'to be in the buffer') + + cdef: + ssize_t pos + ssize_t nread + bytes result + char* buf + char* buf_start + + self._ensure_first_buf() + + buf_start = cpython.PyBytes_AS_STRING(self._buf0) + buf = buf_start + self._pos0 + while buf - buf_start < self._len0: + if buf[0] == 0: + pos = buf - buf_start + nread = pos - self._pos0 + buf = self._try_read_bytes(nread + 1) + if buf != NULL: + return cpython.PyBytes_FromStringAndSize(buf, nread) + else: + break + else: + buf += 1 + + result = b'' + while True: + pos = self._buf0.find(b'\x00', self._pos0) + if pos >= 0: + result += self._buf0[self._pos0 : pos] + nread = pos - self._pos0 + 1 + self._pos0 = pos + 1 + self._length -= nread + + self._current_message_len_unread -= nread + if self._current_message_len_unread < 0: + raise BufferError('read_cstr: buffer overread') + + return result + + else: + result += self._buf0[self._pos0:] + nread = self._len0 - self._pos0 + self._pos0 = self._len0 + self._length -= nread + + self._current_message_len_unread -= nread + if self._current_message_len_unread < 0: + raise BufferError('read_cstr: buffer overread') + + self._ensure_first_buf() + + cdef int32_t has_message(self) except -1: + cdef: + char* cbuf + + if self._current_message_ready: + return 1 + + if self._current_message_type == 0: + if self._length < 1: + return 0 + self._ensure_first_buf() + cbuf = self._try_read_bytes(1) + if cbuf == NULL: + raise BufferError( + 'failed to read one byte on a non-empty buffer') + self._current_message_type = cbuf[0] + + if self._current_message_len == 0: + if self._length < 4: + return 0 + + self._ensure_first_buf() + cbuf = self._try_read_bytes(4) + if cbuf != NULL: + self._current_message_len = hton.unpack_int32(cbuf) + else: + self._current_message_len = self.read_int32() + + self._current_message_len_unread = self._current_message_len - 4 + + if self._length < self._current_message_len_unread: + return 0 + + self._current_message_ready = 1 + return 1 + + cdef inline char* try_consume_message(self, ssize_t* len): + cdef ssize_t buf_len + + if not self._current_message_ready: + return NULL + + self._ensure_first_buf() + buf_len = self._current_message_len_unread + buf = self._try_read_bytes(buf_len) + if buf != NULL: + len[0] = buf_len + self._discard_message() + return buf + + cdef Memory consume_message(self): + if not self._current_message_ready: + raise BufferError('no message to consume') + if self._current_message_len_unread > 0: + mem = self.read(self._current_message_len_unread) + else: + mem = None + self._discard_message() + return mem + + cdef discard_message(self): + if self._current_message_type == 0: + # Already discarded + return + + if not self._current_message_ready: + raise BufferError('no message to discard') + + if self._current_message_len_unread: + if ASYNCPG_DEBUG: + mtype = chr(self._current_message_type) + + discarded = self.consume_message() + + if ASYNCPG_DEBUG: + print('!!! discarding message {!r} unread data: {!r}'.format( + mtype, + (discarded).as_bytes())) + + self._discard_message() + + cdef inline _discard_message(self): + self._current_message_type = 0 + self._current_message_len = 0 + self._current_message_ready = 0 + self._current_message_len_unread = 0 + + cdef inline char get_message_type(self): + return self._current_message_type + + cdef inline int32_t get_message_length(self): + return self._current_message_len + + @staticmethod + cdef ReadBuffer new_message_parser(object data): + cdef ReadBuffer buf + + buf = ReadBuffer.__new__(ReadBuffer) + buf.feed_data(data) + + buf._current_message_ready = 1 + buf._current_message_len_unread = buf._len0 + + return buf + + +@cython.no_gc_clear +@cython.final +@cython.freelist(_BUFFER_FREELIST_SIZE) +cdef class FastReadBuffer: + + cdef inline const char* read(self, ssize_t n) except NULL: + cdef const char *result + + if n > self.len: + self._raise_ins_err(n, self.len) + + result = self.buf + self.buf += n + self.len -= n + + return result + + cdef inline const char* read_all(self): + cdef const char *result + result = self.buf + self.buf += self.len + self.len = 0 + return result + + cdef inline FastReadBuffer slice_from(self, FastReadBuffer source, + ssize_t len): + self.buf = source.read(len) + self.len = len + return self + + cdef _raise_ins_err(self, ssize_t n, ssize_t len): + raise BufferError( + 'insufficient data in buffer: requested {}, remaining {}'. + format(n, self.len)) + + @staticmethod + cdef FastReadBuffer new(): + return FastReadBuffer.__new__(FastReadBuffer) diff --git a/asyncpg/protocol/codecs/__init__.py b/asyncpg/protocol/codecs/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/asyncpg/protocol/codecs/array.pyx b/asyncpg/protocol/codecs/array.pyx new file mode 100644 index 0000000..5c13b2e --- /dev/null +++ b/asyncpg/protocol/codecs/array.pyx @@ -0,0 +1,789 @@ +# Copyright (C) 2016-present the ayncpg authors and contributors +# +# +# This module is part of asyncpg and is released under +# the Apache 2.0 License: http://www.apache.org/licenses/LICENSE-2.0 + + +from collections.abc import Container as ContainerABC + + +DEF ARRAY_MAXDIM = 6 # defined in postgresql/src/includes/c.h + +# "NULL" +cdef Py_UCS4 *APG_NULL = [0x004E, 0x0055, 0x004C, 0x004C, 0x0000] + + +ctypedef object (*encode_func_ex)(ConnectionSettings settings, + WriteBuffer buf, + object obj, + const void *arg) + + +ctypedef object (*decode_func_ex)(ConnectionSettings settings, + FastReadBuffer buf, + const void *arg) + + +cdef inline bint _is_trivial_container(object obj): + return cpython.PyUnicode_Check(obj) or cpython.PyBytes_Check(obj) or \ + PyByteArray_Check(obj) or PyMemoryView_Check(obj) + + +cdef inline _is_container(object obj): + return not _is_trivial_container(obj) and isinstance(obj, ContainerABC) + + +cdef inline _is_sub_array(object obj): + return not _is_trivial_container(obj) and isinstance(obj, ContainerABC) \ + and not cpython.PyTuple_Check(obj) + + +cdef _get_array_shape(object obj, int32_t *dims, int32_t *ndims): + cdef: + ssize_t mylen = len(obj) + ssize_t elemlen = -2 + object it + + if mylen > _MAXINT32: + raise ValueError('too many elements in array value') + + if ndims[0] > ARRAY_MAXDIM: + raise ValueError( + 'number of array dimensions ({}) exceed the maximum expected ({})'. + format(ndims[0], ARRAY_MAXDIM)) + + dims[ndims[0] - 1] = mylen + + for elem in obj: + if _is_sub_array(elem): + if elemlen == -2: + elemlen = len(elem) + if elemlen > _MAXINT32: + raise ValueError('too many elements in array value') + ndims[0] += 1 + _get_array_shape(elem, dims, ndims) + else: + if len(elem) != elemlen: + raise ValueError('non-homogeneous array') + else: + if elemlen >= 0: + raise ValueError('non-homogeneous array') + else: + elemlen = -1 + + +cdef _write_array_data(ConnectionSettings settings, object obj, int32_t ndims, + int32_t dim, WriteBuffer elem_data, + encode_func_ex encoder, const void *encoder_arg): + if dim < ndims - 1: + for item in obj: + _write_array_data(settings, item, ndims, dim + 1, elem_data, + encoder, encoder_arg) + else: + for item in obj: + if item is None: + elem_data.write_int32(-1) + else: + try: + encoder(settings, elem_data, item, encoder_arg) + except TypeError as e: + raise ValueError( + 'invalid array element: {}'.format(e.args[0])) from None + + +cdef inline array_encode(ConnectionSettings settings, WriteBuffer buf, + object obj, uint32_t elem_oid, + encode_func_ex encoder, const void *encoder_arg): + cdef: + WriteBuffer elem_data + int32_t dims[ARRAY_MAXDIM] + int32_t ndims = 1 + int32_t i + + if not _is_container(obj): + raise TypeError( + 'a non-trivial iterable expected (got type {!r})'.format( + type(obj).__name__)) + + _get_array_shape(obj, dims, &ndims) + + elem_data = WriteBuffer.new() + + if ndims > 1: + _write_array_data(settings, obj, ndims, 0, elem_data, + encoder, encoder_arg) + else: + for i, item in enumerate(obj): + if item is None: + elem_data.write_int32(-1) + else: + try: + encoder(settings, elem_data, item, encoder_arg) + except TypeError as e: + raise ValueError( + 'invalid array element at index {}: {}'.format( + i, e.args[0])) from None + + buf.write_int32(12 + 8 * ndims + elem_data.len()) + # Number of dimensions + buf.write_int32(ndims) + # flags + buf.write_int32(0) + # element type + buf.write_int32(elem_oid) + # upper / lower bounds + for i in range(ndims): + buf.write_int32(dims[i]) + buf.write_int32(1) + # element data + buf.write_buffer(elem_data) + + +cdef inline array_decode(ConnectionSettings settings, FastReadBuffer buf, + decode_func_ex decoder, const void *decoder_arg): + cdef: + int32_t ndims = hton.unpack_int32(buf.read(4)) + int32_t flags = hton.unpack_int32(buf.read(4)) + uint32_t elem_oid = hton.unpack_int32(buf.read(4)) + list result + int i + int32_t elem_len + int32_t elem_count = 1 + FastReadBuffer elem_buf = FastReadBuffer.new() + int32_t dims[ARRAY_MAXDIM] + Codec elem_codec + + if ndims == 0: + result = cpython.PyList_New(0) + return result + + if ndims > ARRAY_MAXDIM: + raise RuntimeError( + 'number of array dimensions ({}) exceed the maximum expected ({})'. + format(ndims, ARRAY_MAXDIM)) + + if decoder == NULL: + # No decoder is known beforehand, look it up + + elem_codec = settings.get_data_codec(elem_oid) + if elem_codec is None or not elem_codec.has_decoder(): + raise RuntimeError( + 'no decoder for type OID {}'.format(elem_oid)) + + decoder = codec_decode_func_ex + decoder_arg = (elem_codec) + + for i in range(ndims): + dims[i] = hton.unpack_int32(buf.read(4)) + # Ignore the lower bound information + buf.read(4) + + if ndims == 1: + # Fast path for flat arrays + elem_count = dims[0] + result = cpython.PyList_New(elem_count) + + for i in range(elem_count): + elem_len = hton.unpack_int32(buf.read(4)) + if elem_len == -1: + elem = None + else: + elem_buf.slice_from(buf, elem_len) + elem = decoder(settings, elem_buf, decoder_arg) + + cpython.Py_INCREF(elem) + cpython.PyList_SET_ITEM(result, i, elem) + + else: + result = _nested_array_decode(settings, buf, + decoder, decoder_arg, ndims, dims, + elem_buf) + + return result + + +cdef inline _nested_array_decode(ConnectionSettings settings, + FastReadBuffer buf, + decode_func_ex decoder, + const void *decoder_arg, + int32_t ndims, int32_t *dims, + FastReadBuffer elem_buf): + + cdef: + int32_t elem_len + int32_t d1, d2, d3, d4, d5, d6 + list result + object elem + list stride1, stride2, stride3, stride4, stride5 + + # Nested array. The approach here is dumb, but fast: rely + # on the dimension limit and shape data using nested loops. + # Alas, Cython doesn't have preprocessor macros. + # + result = cpython.PyList_New(dims[0]) + + for d1 in range(dims[0]): + stride1 = cpython.PyList_New(dims[1]) + cpython.Py_INCREF(stride1) + cpython.PyList_SET_ITEM(result, d1, stride1) + + for d2 in range(dims[1]): + if ndims == 2: + elem_len = hton.unpack_int32(buf.read(4)) + if elem_len == -1: + elem = None + else: + elem = decoder(settings, + elem_buf.slice_from(buf, elem_len), + decoder_arg) + + cpython.Py_INCREF(elem) + cpython.PyList_SET_ITEM(stride1, d2, elem) + + else: + stride2 = cpython.PyList_New(dims[2]) + cpython.Py_INCREF(stride2) + cpython.PyList_SET_ITEM(stride1, d2, stride2) + + for d3 in range(dims[2]): + if ndims == 3: + elem_len = hton.unpack_int32(buf.read(4)) + if elem_len == -1: + elem = None + else: + elem = decoder(settings, + elem_buf.slice_from(buf, elem_len), + decoder_arg) + + cpython.Py_INCREF(elem) + cpython.PyList_SET_ITEM(stride2, d3, elem) + + else: + stride3 = cpython.PyList_New(dims[3]) + cpython.Py_INCREF(stride3) + cpython.PyList_SET_ITEM(stride2, d3, stride3) + + for d4 in range(dims[3]): + if ndims == 4: + elem_len = hton.unpack_int32(buf.read(4)) + if elem_len == -1: + elem = None + else: + elem = decoder(settings, + elem_buf.slice_from(buf, elem_len), + decoder_arg) + + cpython.Py_INCREF(elem) + cpython.PyList_SET_ITEM(stride3, d4, elem) + + else: + stride4 = cpython.PyList_New(dims[4]) + cpython.Py_INCREF(stride4) + cpython.PyList_SET_ITEM(stride3, d4, stride4) + + for d5 in range(dims[4]): + if ndims == 5: + elem_len = hton.unpack_int32(buf.read(4)) + if elem_len == -1: + elem = None + else: + elem = decoder(settings, + elem_buf.slice_from(buf, elem_len), + decoder_arg) + + cpython.Py_INCREF(elem) + cpython.PyList_SET_ITEM(stride4, d5, elem) + + else: + stride5 = cpython.PyList_New(dims[5]) + cpython.Py_INCREF(stride5) + cpython.PyList_SET_ITEM(stride4, d5, stride5) + + for d6 in range(dims[5]): + elem_len = hton.unpack_int32(buf.read(4)) + if elem_len == -1: + elem = None + else: + elem = decoder(settings, + elem_buf.slice_from(buf, elem_len), + decoder_arg) + + cpython.Py_INCREF(elem) + cpython.PyList_SET_ITEM(stride5, d6, elem) + + return result + + +cdef textarray_decode(ConnectionSettings settings, FastReadBuffer buf, + decode_func_ex decoder, const void *decoder_arg, + Py_UCS4 typdelim): + cdef: + Py_UCS4 *array_text + str s + + # Make a copy of array data since we will be mutating it for + # the purposes of element decoding. + s = text_decode(settings, buf) + array_text = PyUnicode_AsUCS4Copy(s) + + try: + return _textarray_decode( + settings, array_text, decoder, decoder_arg, typdelim) + except ValueError as e: + raise ValueError( + 'malformed array literal {!r}: {}'.format(s, e.args[0])) + finally: + PyMem_Free(array_text) + + +cdef _textarray_decode(ConnectionSettings settings, + Py_UCS4 *array_text, + decode_func_ex decoder, + const void *decoder_arg, + Py_UCS4 typdelim): + + cdef: + bytearray array_bytes + list result + list new_stride + Py_UCS4 *ptr + int32_t ndims = 0 + int32_t ubound = 0 + int32_t lbound = 0 + int32_t dims[ARRAY_MAXDIM] + int32_t inferred_dims[ARRAY_MAXDIM] + int32_t inferred_ndims = 0 + void *strides[ARRAY_MAXDIM] + int32_t indexes[ARRAY_MAXDIM] + int32_t nest_level = 0 + int32_t item_level = 0 + bint end_of_array = False + + bint end_of_item = False + bint has_quoting = False + bint strip_spaces = False + bint in_quotes = False + Py_UCS4 *item_start + Py_UCS4 *item_ptr + Py_UCS4 *item_end + + int i + object item + str item_text + FastReadBuffer item_buf = FastReadBuffer.new() + char *pg_item_str + ssize_t pg_item_len + + ptr = array_text + + while True: + while apg_ascii_isspace(ptr[0]): + ptr += 1 + + if ptr[0] != '[': + # Finished parsing dimensions spec. + break + + ptr += 1 # '[' + + if ndims > ARRAY_MAXDIM: + raise ValueError( + 'number of array dimensions ({}) exceed the ' + 'maximum expected ({})'.format(ndims, ARRAY_MAXDIM)) + + ptr = apg_parse_int32(ptr, &ubound) + if ptr == NULL: + raise ValueError('missing array dimension value') + + if ptr[0] == ':': + ptr += 1 + lbound = ubound + + # [lower:upper] spec. We disregard the lbound for decoding. + ptr = apg_parse_int32(ptr, &ubound) + if ptr == NULL: + raise ValueError('missing array dimension value') + else: + lbound = 1 + + if ptr[0] != ']': + raise ValueError('missing \']\' after array dimensions') + + ptr += 1 # ']' + + dims[ndims] = ubound - lbound + 1 + ndims += 1 + + if ndims != 0: + # If dimensions were given, the '=' token is expected. + if ptr[0] != '=': + raise ValueError('missing \'=\' after array dimensions') + + ptr += 1 # '=' + + # Skip any whitespace after the '=', whitespace + # before was consumed in the above loop. + while apg_ascii_isspace(ptr[0]): + ptr += 1 + + # Infer the dimensions from the brace structure in the + # array literal body, and check that it matches the explicit + # spec. This also validates that the array literal is sane. + _infer_array_dims(ptr, typdelim, inferred_dims, &inferred_ndims) + + if inferred_ndims != ndims: + raise ValueError( + 'specified array dimensions do not match array content') + + for i in range(ndims): + if inferred_dims[i] != dims[i]: + raise ValueError( + 'specified array dimensions do not match array content') + else: + # Infer the dimensions from the brace structure in the array literal + # body. This also validates that the array literal is sane. + _infer_array_dims(ptr, typdelim, dims, &ndims) + + while not end_of_array: + # We iterate over the literal character by character + # and modify the string in-place removing the array-specific + # quoting and determining the boundaries of each element. + end_of_item = has_quoting = in_quotes = False + strip_spaces = True + + # Pointers to array element start, end, and the current pointer + # tracking the position where characters are written when + # escaping is folded. + item_start = item_end = item_ptr = ptr + item_level = 0 + + while not end_of_item: + if ptr[0] == '"': + in_quotes = not in_quotes + if in_quotes: + strip_spaces = False + else: + item_end = item_ptr + has_quoting = True + + elif ptr[0] == '\\': + # Quoted character, collapse the backslash. + ptr += 1 + has_quoting = True + item_ptr[0] = ptr[0] + item_ptr += 1 + strip_spaces = False + item_end = item_ptr + + elif in_quotes: + # Consume the string until we see the closing quote. + item_ptr[0] = ptr[0] + item_ptr += 1 + + elif ptr[0] == '{': + # Nesting level increase. + nest_level += 1 + + indexes[nest_level - 1] = 0 + new_stride = cpython.PyList_New(dims[nest_level - 1]) + strides[nest_level - 1] = \ + (new_stride) + + if nest_level > 1: + cpython.Py_INCREF(new_stride) + cpython.PyList_SET_ITEM( + strides[nest_level - 2], + indexes[nest_level - 2], + new_stride) + else: + result = new_stride + + elif ptr[0] == '}': + if item_level == 0: + # Make sure we keep track of which nesting + # level the item belongs to, as the loop + # will continue to consume closing braces + # until the delimiter or the end of input. + item_level = nest_level + + nest_level -= 1 + + if nest_level == 0: + end_of_array = end_of_item = True + + elif ptr[0] == typdelim: + # Array element delimiter, + end_of_item = True + if item_level == 0: + item_level = nest_level + + elif apg_ascii_isspace(ptr[0]): + if not strip_spaces: + item_ptr[0] = ptr[0] + item_ptr += 1 + # Ignore the leading literal whitespace. + + else: + item_ptr[0] = ptr[0] + item_ptr += 1 + strip_spaces = False + item_end = item_ptr + + ptr += 1 + + # end while not end_of_item + + if item_end == item_start: + # Empty array + continue + + item_end[0] = '\0' + + if not has_quoting and apg_strcasecmp(item_start, APG_NULL) == 0: + # NULL element. + item = None + else: + # XXX: find a way to avoid the redundant encode/decode + # cycle here. + item_text = PyUnicode_FromKindAndData( + PyUnicode_4BYTE_KIND, + item_start, + item_end - item_start) + + # Prepare the element buffer and call the text decoder + # for the element type. + as_pg_string_and_size( + settings, item_text, &pg_item_str, &pg_item_len) + item_buf.buf = pg_item_str + item_buf.len = pg_item_len + item = decoder(settings, item_buf, decoder_arg) + + # Place the decoded element in the array. + cpython.Py_INCREF(item) + cpython.PyList_SET_ITEM( + strides[item_level - 1], + indexes[item_level - 1], + item) + + indexes[nest_level - 1] += 1 + + return result + + +cdef enum _ArrayParseState: + APS_START = 1 + APS_STRIDE_STARTED = 2 + APS_STRIDE_DONE = 3 + APS_STRIDE_DELIMITED = 4 + APS_ELEM_STARTED = 5 + APS_ELEM_DELIMITED = 6 + + +cdef _UnexpectedCharacter(const Py_UCS4 *array_text, const Py_UCS4 *ptr): + return ValueError('unexpected character {!r} at position {}'.format( + cpython.PyUnicode_FromOrdinal(ptr[0]), ptr - array_text + 1)) + + +cdef _infer_array_dims(const Py_UCS4 *array_text, + Py_UCS4 typdelim, + int32_t *dims, + int32_t *ndims): + cdef: + const Py_UCS4 *ptr = array_text + int i + int nest_level = 0 + bint end_of_array = False + bint end_of_item = False + bint in_quotes = False + bint array_is_empty = True + int stride_len[ARRAY_MAXDIM] + int prev_stride_len[ARRAY_MAXDIM] + _ArrayParseState parse_state = APS_START + + for i in range(ARRAY_MAXDIM): + dims[i] = prev_stride_len[i] = 0 + stride_len[i] = 1 + + while not end_of_array: + end_of_item = False + + while not end_of_item: + if ptr[0] == '\0': + raise ValueError('unexpected end of string') + + elif ptr[0] == '"': + if (parse_state not in (APS_STRIDE_STARTED, + APS_ELEM_DELIMITED) and + not (parse_state == APS_ELEM_STARTED and in_quotes)): + raise _UnexpectedCharacter(array_text, ptr) + + in_quotes = not in_quotes + if in_quotes: + parse_state = APS_ELEM_STARTED + array_is_empty = False + + elif ptr[0] == '\\': + if parse_state not in (APS_STRIDE_STARTED, + APS_ELEM_STARTED, + APS_ELEM_DELIMITED): + raise _UnexpectedCharacter(array_text, ptr) + + parse_state = APS_ELEM_STARTED + array_is_empty = False + + if ptr[1] != '\0': + ptr += 1 + else: + raise ValueError('unexpected end of string') + + elif in_quotes: + # Ignore everything inside the quotes. + pass + + elif ptr[0] == '{': + if parse_state not in (APS_START, + APS_STRIDE_STARTED, + APS_STRIDE_DELIMITED): + raise _UnexpectedCharacter(array_text, ptr) + + parse_state = APS_STRIDE_STARTED + if nest_level >= ARRAY_MAXDIM: + raise ValueError( + 'number of array dimensions ({}) exceed the ' + 'maximum expected ({})'.format( + nest_level, ARRAY_MAXDIM)) + + dims[nest_level] = 0 + nest_level += 1 + if ndims[0] < nest_level: + ndims[0] = nest_level + + elif ptr[0] == '}': + if (parse_state not in (APS_ELEM_STARTED, APS_STRIDE_DONE) and + not (nest_level == 1 and + parse_state == APS_STRIDE_STARTED)): + raise _UnexpectedCharacter(array_text, ptr) + + parse_state = APS_STRIDE_DONE + + if nest_level == 0: + raise _UnexpectedCharacter(array_text, ptr) + + nest_level -= 1 + + if (prev_stride_len[nest_level] != 0 and + stride_len[nest_level] != prev_stride_len[nest_level]): + raise ValueError( + 'inconsistent sub-array dimensions' + ' at position {}'.format( + ptr - array_text + 1)) + + prev_stride_len[nest_level] = stride_len[nest_level] + stride_len[nest_level] = 1 + if nest_level == 0: + end_of_array = end_of_item = True + else: + dims[nest_level - 1] += 1 + + elif ptr[0] == typdelim: + if parse_state not in (APS_ELEM_STARTED, APS_STRIDE_DONE): + raise _UnexpectedCharacter(array_text, ptr) + + if parse_state == APS_STRIDE_DONE: + parse_state = APS_STRIDE_DELIMITED + else: + parse_state = APS_ELEM_DELIMITED + end_of_item = True + stride_len[nest_level - 1] += 1 + + elif not apg_ascii_isspace(ptr[0]): + if parse_state not in (APS_STRIDE_STARTED, + APS_ELEM_STARTED, + APS_ELEM_DELIMITED): + raise _UnexpectedCharacter(array_text, ptr) + + parse_state = APS_ELEM_STARTED + array_is_empty = False + + if not end_of_item: + ptr += 1 + + if not array_is_empty: + dims[ndims[0] - 1] += 1 + + ptr += 1 + + # only whitespace is allowed after the closing brace + while ptr[0] != '\0': + if not apg_ascii_isspace(ptr[0]): + raise _UnexpectedCharacter(array_text, ptr) + + ptr += 1 + + if array_is_empty: + ndims[0] = 0 + + +cdef int4_encode_ex(ConnectionSettings settings, WriteBuffer buf, object obj, + const void *arg): + return int4_encode(settings, buf, obj) + + +cdef int4_decode_ex(ConnectionSettings settings, FastReadBuffer buf, + const void *arg): + return int4_decode(settings, buf) + + +cdef arrayoid_encode(ConnectionSettings settings, WriteBuffer buf, items): + array_encode(settings, buf, items, OIDOID, + &int4_encode_ex, NULL) + + +cdef arrayoid_decode(ConnectionSettings settings, FastReadBuffer buf): + return array_decode(settings, buf, &int4_decode_ex, NULL) + + +cdef text_encode_ex(ConnectionSettings settings, WriteBuffer buf, object obj, + const void *arg): + return text_encode(settings, buf, obj) + + +cdef text_decode_ex(ConnectionSettings settings, FastReadBuffer buf, + const void *arg): + return text_decode(settings, buf) + + +cdef arraytext_encode(ConnectionSettings settings, WriteBuffer buf, items): + array_encode(settings, buf, items, TEXTOID, + &text_encode_ex, NULL) + + +cdef arraytext_decode(ConnectionSettings settings, FastReadBuffer buf): + return array_decode(settings, buf, &text_decode_ex, NULL) + + +cdef anyarray_decode(ConnectionSettings settings, FastReadBuffer buf): + return array_decode(settings, buf, NULL, NULL) + + +cdef init_array_codecs(): + register_core_codec(ANYARRAYOID, + NULL, + &anyarray_decode, + PG_FORMAT_BINARY) + + # oid[] and text[] are registered as core codecs + # to make type introspection query work + # + register_core_codec(_OIDOID, + &arrayoid_encode, + &arrayoid_decode, + PG_FORMAT_BINARY) + + register_core_codec(_TEXTOID, + &arraytext_encode, + &arraytext_decode, + PG_FORMAT_BINARY) + +init_array_codecs() diff --git a/asyncpg/protocol/codecs/base.pxd b/asyncpg/protocol/codecs/base.pxd new file mode 100644 index 0000000..fe5d7b0 --- /dev/null +++ b/asyncpg/protocol/codecs/base.pxd @@ -0,0 +1,159 @@ +# Copyright (C) 2016-present the ayncpg authors and contributors +# +# +# This module is part of asyncpg and is released under +# the Apache 2.0 License: http://www.apache.org/licenses/LICENSE-2.0 + + +ctypedef object (*encode_func)(ConnectionSettings settings, + WriteBuffer buf, + object obj) + +ctypedef object (*decode_func)(ConnectionSettings settings, + FastReadBuffer buf) + +ctypedef object (*codec_encode_func)(Codec codec, + ConnectionSettings settings, + WriteBuffer buf, + object obj) + +ctypedef object (*codec_decode_func)(Codec codec, + ConnectionSettings settings, + FastReadBuffer buf) + + +cdef enum CodecType: + CODEC_UNDEFINED = 0 + CODEC_C = 1 + CODEC_PY = 2 + CODEC_ARRAY = 3 + CODEC_COMPOSITE = 4 + CODEC_RANGE = 5 + + +cdef enum CodecFormat: + PG_FORMAT_ANY = -1 + PG_FORMAT_TEXT = 0 + PG_FORMAT_BINARY = 1 + + +cdef class Codec: + cdef: + uint32_t oid + + str name + str schema + str kind + + CodecType type + CodecFormat format + + encode_func c_encoder + decode_func c_decoder + + object py_encoder + object py_decoder + + # arrays + Codec element_codec + Py_UCS4 element_delimiter + + # composite types + tuple element_type_oids + object element_names + list element_codecs + + # Pointers to actual encoder/decoder functions for this codec + codec_encode_func encoder + codec_decode_func decoder + + cdef init(self, str name, str schema, str kind, + CodecType type, CodecFormat format, + encode_func c_encoder, decode_func c_decoder, + object py_encoder, object py_decoder, + Codec element_codec, tuple element_type_oids, + object element_names, list element_codecs, + Py_UCS4 element_delimiter) + + cdef encode_scalar(self, ConnectionSettings settings, WriteBuffer buf, + object obj) + + cdef encode_array(self, ConnectionSettings settings, WriteBuffer buf, + object obj) + + cdef encode_range(self, ConnectionSettings settings, WriteBuffer buf, + object obj) + + cdef encode_composite(self, ConnectionSettings settings, WriteBuffer buf, + object obj) + + cdef encode_in_python(self, ConnectionSettings settings, WriteBuffer buf, + object obj) + + cdef decode_scalar(self, ConnectionSettings settings, FastReadBuffer buf) + + cdef decode_array(self, ConnectionSettings settings, FastReadBuffer buf) + + cdef decode_array_text(self, ConnectionSettings settings, + FastReadBuffer buf) + + cdef decode_range(self, ConnectionSettings settings, FastReadBuffer buf) + + cdef decode_composite(self, ConnectionSettings settings, + FastReadBuffer buf) + + cdef decode_in_python(self, ConnectionSettings settings, + FastReadBuffer buf) + + cdef inline encode(self, + ConnectionSettings settings, + WriteBuffer buf, + object obj) + + cdef inline decode(self, + ConnectionSettings settings, + FastReadBuffer buf) + + cdef has_encoder(self) + cdef has_decoder(self) + cdef is_binary(self) + + cdef inline Codec copy(self) + + @staticmethod + cdef Codec new_array_codec(uint32_t oid, + str name, + str schema, + Codec element_codec, + Py_UCS4 element_delimiter) + + @staticmethod + cdef Codec new_range_codec(uint32_t oid, + str name, + str schema, + Codec element_codec) + + @staticmethod + cdef Codec new_composite_codec(uint32_t oid, + str name, + str schema, + list element_codecs, + tuple element_type_oids, + object element_names) + + @staticmethod + cdef Codec new_python_codec(uint32_t oid, + str name, + str schema, + str kind, + object encoder, + object decoder, + CodecFormat format) + + +cdef class DataCodecConfig: + cdef: + dict _type_codecs_cache + dict _local_type_codecs + + cdef inline Codec get_codec(self, uint32_t oid, CodecFormat format) diff --git a/asyncpg/protocol/codecs/base.pyx b/asyncpg/protocol/codecs/base.pyx new file mode 100644 index 0000000..2da7424 --- /dev/null +++ b/asyncpg/protocol/codecs/base.pyx @@ -0,0 +1,598 @@ +# Copyright (C) 2016-present the ayncpg authors and contributors +# +# +# This module is part of asyncpg and is released under +# the Apache 2.0 License: http://www.apache.org/licenses/LICENSE-2.0 + + +cdef void* binary_codec_map[MAXSUPPORTEDOID + 1] +cdef void* text_codec_map[MAXSUPPORTEDOID + 1] +cdef dict TYPE_CODECS_CACHE = {} +cdef dict EXTRA_CODECS = {} + + +@cython.final +cdef class Codec: + + def __cinit__(self, uint32_t oid): + self.oid = oid + self.type = CODEC_UNDEFINED + + cdef init(self, str name, str schema, str kind, + CodecType type, CodecFormat format, + encode_func c_encoder, decode_func c_decoder, + object py_encoder, object py_decoder, + Codec element_codec, tuple element_type_oids, + object element_names, list element_codecs, + Py_UCS4 element_delimiter): + + self.name = name + self.schema = schema + self.kind = kind + self.type = type + self.format = format + self.c_encoder = c_encoder + self.c_decoder = c_decoder + self.py_encoder = py_encoder + self.py_decoder = py_decoder + self.element_codec = element_codec + self.element_type_oids = element_type_oids + self.element_codecs = element_codecs + self.element_delimiter = element_delimiter + + if element_names is not None: + self.element_names = record.ApgRecordDesc_New( + element_names, tuple(element_names)) + else: + self.element_names = None + + if type == CODEC_C: + self.encoder = &self.encode_scalar + self.decoder = &self.decode_scalar + elif type == CODEC_ARRAY: + self.encoder = &self.encode_array + if format == PG_FORMAT_BINARY: + self.decoder = &self.decode_array + else: + self.decoder = &self.decode_array_text + elif type == CODEC_RANGE: + self.encoder = &self.encode_range + self.decoder = &self.decode_range + elif type == CODEC_COMPOSITE: + self.encoder = &self.encode_composite + self.decoder = &self.decode_composite + elif type == CODEC_PY: + self.encoder = &self.encode_in_python + self.decoder = &self.decode_in_python + else: + raise RuntimeError('unexpected codec type: {}'.format(type)) + + cdef Codec copy(self): + cdef Codec codec + + codec = Codec(self.oid) + codec.init(self.name, self.schema, self.kind, + self.type, self.format, + self.c_encoder, self.c_decoder, + self.py_encoder, self.py_decoder, + self.element_codec, + self.element_type_oids, self.element_names, + self.element_codecs, self.element_delimiter) + + return codec + + cdef encode_scalar(self, ConnectionSettings settings, WriteBuffer buf, + object obj): + self.c_encoder(settings, buf, obj) + + cdef encode_array(self, ConnectionSettings settings, WriteBuffer buf, + object obj): + array_encode(settings, buf, obj, self.element_codec.oid, + codec_encode_func_ex, + (self.element_codec)) + + cdef encode_range(self, ConnectionSettings settings, WriteBuffer buf, + object obj): + range_encode(settings, buf, obj, self.element_codec.oid, + codec_encode_func_ex, + (self.element_codec)) + + cdef encode_composite(self, ConnectionSettings settings, WriteBuffer buf, + object obj): + cdef: + WriteBuffer elem_data + int i + list elem_codecs = self.element_codecs + ssize_t count + + count = len(obj) + if count > _MAXINT32: + raise ValueError('too many elements in composite type record') + + elem_data = WriteBuffer.new() + i = 0 + for item in obj: + elem_data.write_int32(self.element_type_oids[i]) + if item is None: + elem_data.write_int32(-1) + else: + (elem_codecs[i]).encode(settings, elem_data, item) + i += 1 + + record_encode_frame(settings, buf, elem_data, count) + + cdef encode_in_python(self, ConnectionSettings settings, WriteBuffer buf, + object obj): + bb = self.py_encoder(obj) + if self.format == PG_FORMAT_BINARY: + bytea_encode(settings, buf, bb) + else: + text_encode(settings, buf, bb) + + cdef encode(self, ConnectionSettings settings, WriteBuffer buf, + object obj): + return self.encoder(self, settings, buf, obj) + + cdef decode_scalar(self, ConnectionSettings settings, FastReadBuffer buf): + return self.c_decoder(settings, buf) + + cdef decode_array(self, ConnectionSettings settings, FastReadBuffer buf): + return array_decode(settings, buf, codec_decode_func_ex, + (self.element_codec)) + + cdef decode_array_text(self, ConnectionSettings settings, + FastReadBuffer buf): + return textarray_decode(settings, buf, codec_decode_func_ex, + (self.element_codec), + self.element_delimiter) + + cdef decode_range(self, ConnectionSettings settings, FastReadBuffer buf): + return range_decode(settings, buf, codec_decode_func_ex, + (self.element_codec)) + + cdef decode_composite(self, ConnectionSettings settings, + FastReadBuffer buf): + cdef: + object result + uint32_t elem_count + uint32_t i + int32_t elem_len + uint32_t elem_typ + uint32_t received_elem_typ + Codec elem_codec + FastReadBuffer elem_buf = FastReadBuffer.new() + + elem_count = hton.unpack_int32(buf.read(4)) + result = record.ApgRecord_New(self.element_names, elem_count) + for i in range(elem_count): + elem_typ = self.element_type_oids[i] + received_elem_typ = hton.unpack_int32(buf.read(4)) + + if received_elem_typ != elem_typ: + raise RuntimeError( + 'unexpected data type of composite type attribute {}: ' + '{!r}, expected {!r}' + .format( + i, + TYPEMAP.get(received_elem_typ, received_elem_typ), + TYPEMAP.get(elem_typ, elem_typ) + ) + ) + + elem_len = hton.unpack_int32(buf.read(4)) + if elem_len == -1: + elem = None + else: + elem_codec = self.element_codecs[i] + elem = elem_codec.decode(settings, + elem_buf.slice_from(buf, elem_len)) + + cpython.Py_INCREF(elem) + record.ApgRecord_SET_ITEM(result, i, elem) + + return result + + cdef decode_in_python(self, ConnectionSettings settings, + FastReadBuffer buf): + if self.format == PG_FORMAT_BINARY: + bb = bytea_decode(settings, buf) + else: + bb = text_decode(settings, buf) + + return self.py_decoder(bb) + + cdef inline decode(self, ConnectionSettings settings, FastReadBuffer buf): + return self.decoder(self, settings, buf) + + cdef inline has_encoder(self): + cdef Codec elem_codec + + if self.c_encoder is not NULL or self.py_encoder is not None: + return True + + elif self.type == CODEC_ARRAY or self.type == CODEC_RANGE: + return self.element_codec.has_encoder() + + elif self.type == CODEC_COMPOSITE: + for elem_codec in self.element_codecs: + if not elem_codec.has_encoder(): + return False + return True + + else: + return False + + cdef has_decoder(self): + cdef Codec elem_codec + + if self.c_decoder is not NULL or self.py_decoder is not None: + return True + + elif self.type == CODEC_ARRAY or self.type == CODEC_RANGE: + return self.element_codec.has_decoder() + + elif self.type == CODEC_COMPOSITE: + for elem_codec in self.element_codecs: + if not elem_codec.has_decoder(): + return False + return True + + else: + return False + + cdef is_binary(self): + return self.format == PG_FORMAT_BINARY + + def __repr__(self): + return ''.format( + self.oid, + 'NA' if self.element_codec is None else self.element_codec.oid, + has_core_codec(self.oid)) + + @staticmethod + cdef Codec new_array_codec(uint32_t oid, + str name, + str schema, + Codec element_codec, + Py_UCS4 element_delimiter): + cdef Codec codec + codec = Codec(oid) + codec.init(name, schema, 'array', CODEC_ARRAY, element_codec.format, + NULL, NULL, None, None, element_codec, None, None, None, + element_delimiter) + return codec + + @staticmethod + cdef Codec new_range_codec(uint32_t oid, + str name, + str schema, + Codec element_codec): + cdef Codec codec + codec = Codec(oid) + codec.init(name, schema, 'range', CODEC_RANGE, PG_FORMAT_BINARY, + NULL, NULL, None, None, element_codec, None, None, None, + 0) + return codec + + @staticmethod + cdef Codec new_composite_codec(uint32_t oid, + str name, + str schema, + list element_codecs, + tuple element_type_oids, + object element_names): + cdef Codec codec + codec = Codec(oid) + codec.init(name, schema, 'composite', CODEC_COMPOSITE, + PG_FORMAT_BINARY, NULL, NULL, None, None, None, + element_type_oids, element_names, element_codecs, 0) + return codec + + @staticmethod + cdef Codec new_python_codec(uint32_t oid, + str name, + str schema, + str kind, + object encoder, + object decoder, + CodecFormat format): + cdef Codec codec + codec = Codec(oid) + codec.init(name, schema, kind, CODEC_PY, format, NULL, NULL, + encoder, decoder, None, None, None, None, 0) + return codec + + +# Encode callback for arrays +cdef codec_encode_func_ex(ConnectionSettings settings, WriteBuffer buf, + object obj, const void *arg): + return (arg).encode(settings, buf, obj) + + +# Decode callback for arrays +cdef codec_decode_func_ex(ConnectionSettings settings, FastReadBuffer buf, + const void *arg): + return (arg).decode(settings, buf) + + +cdef class DataCodecConfig: + def __init__(self, cache_key): + try: + self._type_codecs_cache = TYPE_CODECS_CACHE[cache_key] + except KeyError: + self._type_codecs_cache = TYPE_CODECS_CACHE[cache_key] = {} + + self._local_type_codecs = {} + + def add_types(self, types): + cdef: + Codec elem_codec + list comp_elem_codecs + CodecFormat format + CodecFormat elem_format + bint has_text_elements + Py_UCS4 elem_delim + + for ti in types: + oid = ti['oid'] + + if not ti['has_bin_io']: + format = PG_FORMAT_TEXT + else: + format = PG_FORMAT_BINARY + + has_text_elements = False + + if self.get_codec(oid, format) is not None: + continue + + name = ti['name'] + schema = ti['ns'] + array_element_oid = ti['elemtype'] + range_subtype_oid = ti['range_subtype'] + if ti['attrtypoids']: + comp_type_attrs = tuple(ti['attrtypoids']) + else: + comp_type_attrs = None + base_type = ti['basetype'] + + if array_element_oid: + # Array type (note, there is no separate 'kind' for arrays) + + # Canonicalize type name to "elemtype[]" + if name.startswith('_'): + name = name[1:] + name = '{}[]'.format(name) + + if ti['elem_has_bin_io']: + elem_format = PG_FORMAT_BINARY + else: + elem_format = PG_FORMAT_TEXT + elem_codec = self.get_codec(array_element_oid, elem_format) + if elem_codec is None: + raise RuntimeError( + 'no codec for array element type {}'.format( + array_element_oid)) + + elem_delim = ti['elemdelim'][0] + + self._type_codecs_cache[oid, elem_format] = \ + Codec.new_array_codec( + oid, name, schema, elem_codec, elem_delim) + + elif ti['kind'] == b'c': + if not comp_type_attrs: + raise RuntimeError( + 'type record missing field types for ' + 'composite {}'.format(oid)) + + # Composite type + + comp_elem_codecs = [] + + for typoid in comp_type_attrs: + elem_codec = self.get_codec(typoid, PG_FORMAT_BINARY) + if elem_codec is None: + elem_codec = self.get_codec(typoid, PG_FORMAT_TEXT) + has_text_elements = True + if elem_codec is None: + raise RuntimeError( + 'no codec for composite attribute type {}'.format( + typoid)) + comp_elem_codecs.append(elem_codec) + + element_names = collections.OrderedDict() + for i, attrname in enumerate(ti['attrnames']): + element_names[attrname] = i + + if has_text_elements: + format = PG_FORMAT_TEXT + + self._type_codecs_cache[oid, format] = \ + Codec.new_composite_codec( + oid, name, schema, comp_elem_codecs, + comp_type_attrs, + element_names) + + elif ti['kind'] == b'd': + # Domain type + + if not base_type: + raise RuntimeError( + 'type record missing base type for domain {}'.format( + oid)) + + elem_codec = self.get_codec(base_type, format) + if elem_codec is None: + raise RuntimeError( + 'no codec for domain base type {}'.format(base_type)) + + self._type_codecs_cache[oid, format] = elem_codec + + elif ti['kind'] == b'r': + # Range type + + if not range_subtype_oid: + raise RuntimeError( + 'type record missing base type for range {}'.format( + oid)) + + if ti['elem_has_bin_io']: + elem_format = PG_FORMAT_BINARY + else: + elem_format = PG_FORMAT_TEXT + elem_codec = self.get_codec(range_subtype_oid, elem_format) + if elem_codec is None: + raise RuntimeError( + 'no codec for range element type {}'.format( + range_subtype_oid)) + + self._type_codecs_cache[oid, elem_format] = \ + Codec.new_range_codec(oid, name, schema, elem_codec) + + else: + if oid <= MAXBUILTINOID: + # This is a non-BKI type, for which ayncpg has no + # defined codec. This should only happen for newly + # added builtin types, for which this version of + # asyncpg is lacking support. + # + raise NotImplementedError( + 'unhandled standard data type {!r} (OID {})'.format( + name, oid)) + else: + # This is a non-BKI type, and as such, has no + # stable OID, so no possibility of a builtin codec. + # In this case, fallback to text format. Applications + # can avoid this by specifying a codec for this type + # using Connection.set_type_codec(). + # + self.set_builtin_type_codec(oid, name, schema, 'scalar', + UNKNOWNOID) + + def add_python_codec(self, typeoid, typename, typeschema, typekind, + encoder, decoder, binary): + format = PG_FORMAT_BINARY if binary else PG_FORMAT_TEXT + + if self.get_codec(typeoid, format) is not None: + raise ValueError('cannot override codec for type {}'.format( + typeoid)) + + self._local_type_codecs[typeoid, format] = \ + Codec.new_python_codec(typeoid, typename, typeschema, typekind, + encoder, decoder, format) + + def set_builtin_type_codec(self, typeoid, typename, typeschema, typekind, + alias_to): + cdef: + Codec codec + Codec target_codec + + for format in (PG_FORMAT_BINARY, PG_FORMAT_TEXT): + if self.get_codec(typeoid, format) is not None: + raise ValueError('cannot override codec for type {}'.format( + typeoid)) + + if isinstance(alias_to, int): + target_codec = self.get_codec(alias_to, format) + else: + target_codec = get_extra_codec(alias_to, format) + + if target_codec is None: + continue + + codec = target_codec.copy() + codec.oid = typeoid + codec.name = typename + codec.schema = typeschema + codec.kind = typekind + + self._local_type_codecs[typeoid, format] = codec + + if ((typeoid, PG_FORMAT_BINARY) not in self._local_type_codecs and + (typeoid, PG_FORMAT_TEXT) not in self._local_type_codecs): + raise ValueError('unknown alias target: {}'.format(alias_to)) + + def clear_type_cache(self): + self._type_codecs_cache.clear() + + cdef inline Codec get_codec(self, uint32_t oid, CodecFormat format): + cdef Codec codec + + codec = get_core_codec(oid, format) + if codec is not None: + return codec + + try: + return self._type_codecs_cache[oid, format] + except KeyError: + try: + return self._local_type_codecs[oid, format] + except KeyError: + return None + + +cdef inline Codec get_core_codec(uint32_t oid, CodecFormat format): + cdef void *ptr + if oid > MAXSUPPORTEDOID: + return None + if format == PG_FORMAT_BINARY: + ptr = binary_codec_map[oid] + else: + ptr = text_codec_map[oid] + if ptr is NULL: + return None + return ptr + + +cdef inline int has_core_codec(uint32_t oid): + return binary_codec_map[oid] != NULL or text_codec_map[oid] != NULL + + +cdef register_core_codec(uint32_t oid, + encode_func encode, + decode_func decode, + CodecFormat format): + + if oid > MAXSUPPORTEDOID: + raise RuntimeError( + 'cannot register core codec for OID {}: it is greater ' + 'than MAXSUPPORTEDOID ({})'.format(oid, MAXSUPPORTEDOID)) + + cdef: + Codec codec + str name + str kind + + name = TYPEMAP[oid] + kind = 'array' if oid in ARRAY_TYPES else 'scalar' + + codec = Codec(oid) + codec.init(name, 'pg_catalog', kind, CODEC_C, format, encode, + decode, None, None, None, None, None, None, 0) + cpython.Py_INCREF(codec) # immortalize + + if format == PG_FORMAT_BINARY: + binary_codec_map[oid] = codec + else: + text_codec_map[oid] = codec + + +cdef register_extra_codec(str name, + encode_func encode, + decode_func decode, + CodecFormat format): + cdef: + Codec codec + str kind + + kind = 'scalar' + + codec = Codec(INVALIDOID) + codec.init(name, None, kind, CODEC_C, format, encode, + decode, None, None, None, None, None, None, 0) + EXTRA_CODECS[name, format] = codec + + +cdef inline Codec get_extra_codec(str name, CodecFormat format): + return EXTRA_CODECS.get((name, format)) diff --git a/asyncpg/protocol/codecs/bits.pyx b/asyncpg/protocol/codecs/bits.pyx new file mode 100644 index 0000000..8c2a3f4 --- /dev/null +++ b/asyncpg/protocol/codecs/bits.pyx @@ -0,0 +1,64 @@ +# Copyright (C) 2016-present the ayncpg authors and contributors +# +# +# This module is part of asyncpg and is released under +# the Apache 2.0 License: http://www.apache.org/licenses/LICENSE-2.0 + + +from asyncpg.types import BitString + + +cdef bits_encode(ConnectionSettings settings, WriteBuffer wbuf, obj): + cdef: + Py_buffer pybuf + bint pybuf_used = False + char *buf + ssize_t len + ssize_t bitlen + + if cpython.PyBytes_CheckExact(obj): + buf = cpython.PyBytes_AS_STRING(obj) + len = cpython.Py_SIZE(obj) + bitlen = len * 8 + elif isinstance(obj, BitString): + cpython.PyBytes_AsStringAndSize(obj.bytes, &buf, &len) + bitlen = obj.__len__() + else: + cpython.PyObject_GetBuffer(obj, &pybuf, cpython.PyBUF_SIMPLE) + pybuf_used = True + buf = pybuf.buf + len = pybuf.len + bitlen = len * 8 + + try: + if bitlen > _MAXINT32: + raise ValueError('bit value too long') + wbuf.write_int32(4 + len) + wbuf.write_int32(bitlen) + wbuf.write_cstr(buf, len) + finally: + if pybuf_used: + cpython.PyBuffer_Release(&pybuf) + + +cdef bits_decode(ConnectionSettings settings, FastReadBuffer buf): + cdef: + int32_t bitlen = hton.unpack_int32(buf.read(4)) + ssize_t buf_len = buf.len + + bytes_ = cpython.PyBytes_FromStringAndSize(buf.read_all(), buf_len) + return BitString.frombytes(bytes_, bitlen) + + +cdef init_bits_codecs(): + register_core_codec(BITOID, + &bits_encode, + &bits_decode, + PG_FORMAT_BINARY) + + register_core_codec(VARBITOID, + &bits_encode, + &bits_decode, + PG_FORMAT_BINARY) + +init_bits_codecs() diff --git a/asyncpg/protocol/codecs/bytea.pyx b/asyncpg/protocol/codecs/bytea.pyx new file mode 100644 index 0000000..04fe5ed --- /dev/null +++ b/asyncpg/protocol/codecs/bytea.pyx @@ -0,0 +1,48 @@ +# Copyright (C) 2016-present the ayncpg authors and contributors +# +# +# This module is part of asyncpg and is released under +# the Apache 2.0 License: http://www.apache.org/licenses/LICENSE-2.0 + + +cdef bytea_encode(ConnectionSettings settings, WriteBuffer wbuf, obj): + cdef: + Py_buffer pybuf + bint pybuf_used = False + char *buf + ssize_t len + + if cpython.PyBytes_CheckExact(obj): + buf = cpython.PyBytes_AS_STRING(obj) + len = cpython.Py_SIZE(obj) + else: + cpython.PyObject_GetBuffer(obj, &pybuf, cpython.PyBUF_SIMPLE) + pybuf_used = True + buf = pybuf.buf + len = pybuf.len + + try: + wbuf.write_int32(len) + wbuf.write_cstr(buf, len) + finally: + if pybuf_used: + cpython.PyBuffer_Release(&pybuf) + + +cdef bytea_decode(ConnectionSettings settings, FastReadBuffer buf): + cdef ssize_t buf_len = buf.len + return cpython.PyBytes_FromStringAndSize(buf.read_all(), buf_len) + + +cdef init_bytea_codecs(): + register_core_codec(BYTEAOID, + &bytea_encode, + &bytea_decode, + PG_FORMAT_BINARY) + + register_core_codec(CHAROID, + &bytea_encode, + &bytea_decode, + PG_FORMAT_BINARY) + +init_bytea_codecs() diff --git a/asyncpg/protocol/codecs/datetime.pyx b/asyncpg/protocol/codecs/datetime.pyx new file mode 100644 index 0000000..0a8d367 --- /dev/null +++ b/asyncpg/protocol/codecs/datetime.pyx @@ -0,0 +1,311 @@ +# Copyright (C) 2016-present the ayncpg authors and contributors +# +# +# This module is part of asyncpg and is released under +# the Apache 2.0 License: http://www.apache.org/licenses/LICENSE-2.0 + + +import datetime + +utc = datetime.timezone.utc +date_from_ordinal = datetime.date.fromordinal +timedelta = datetime.timedelta + +pg_epoch_datetime = datetime.datetime(2000, 1, 1) +cdef int32_t pg_epoch_datetime_ts = \ + cpython.PyLong_AsLong(int(pg_epoch_datetime.timestamp())) + +pg_epoch_datetime_utc = datetime.datetime(2000, 1, 1, tzinfo=utc) +cdef int32_t pg_epoch_datetime_utc_ts = \ + cpython.PyLong_AsLong(pg_epoch_datetime_utc.timestamp()) + +pg_epoch_date = datetime.date(2000, 1, 1) +cdef int32_t pg_date_offset_ord = \ + cpython.PyLong_AsLong(pg_epoch_date.toordinal()) + +# Binary representations of infinity for datetimes. +cdef int64_t pg_time64_infinity = 0x7fffffffffffffff +cdef int64_t pg_time64_negative_infinity = 0x8000000000000000 +cdef int32_t pg_date_infinity = 0x7fffffff +cdef int32_t pg_date_negative_infinity = 0x80000000 + +infinity_datetime = datetime.datetime( + datetime.MAXYEAR, 12, 31, 23, 59, 59, 999999) + +cdef int32_t infinity_datetime_ord = cpython.PyLong_AsLong( + infinity_datetime.toordinal()) + +cdef int64_t infinity_datetime_ts = 252455615999999999 + +negative_infinity_datetime = datetime.datetime( + datetime.MINYEAR, 1, 1, 0, 0, 0, 0) + +cdef int32_t negative_infinity_datetime_ord = cpython.PyLong_AsLong( + negative_infinity_datetime.toordinal()) + +cdef int64_t negative_infinity_datetime_ts = -63082281600000000 + +infinity_date = datetime.date(datetime.MAXYEAR, 12, 31) + +cdef int32_t infinity_date_ord = cpython.PyLong_AsLong( + infinity_date.toordinal()) + +negative_infinity_date = datetime.date(datetime.MINYEAR, 1, 1) + +cdef int32_t negative_infinity_date_ord = cpython.PyLong_AsLong( + negative_infinity_date.toordinal()) + + +cdef inline _encode_time(WriteBuffer buf, int64_t seconds, + int32_t microseconds): + # XXX: add support for double timestamps + # int64 timestamps, + cdef int64_t ts = seconds * 1000000 + microseconds + + if ts == infinity_datetime_ts: + buf.write_int64(pg_time64_infinity) + elif ts == negative_infinity_datetime_ts: + buf.write_int64(pg_time64_negative_infinity) + else: + buf.write_int64(ts) + + +cdef inline int32_t _decode_time(FastReadBuffer buf, int64_t *seconds, + uint32_t *microseconds): + # XXX: add support for double timestamps + # int64 timestamps, + cdef int64_t ts = hton.unpack_int64(buf.read(8)) + + if ts == pg_time64_infinity: + return 1 + elif ts == pg_time64_negative_infinity: + return -1 + + seconds[0] = (ts / 1000000) + microseconds[0] = (ts % 1000000) + + return 0 + + +cdef date_encode(ConnectionSettings settings, WriteBuffer buf, obj): + cdef: + int32_t ordinal = cpython.PyLong_AsLong(obj.toordinal()) + int32_t pg_ordinal + + if ordinal == infinity_date_ord: + pg_ordinal = pg_date_infinity + elif ordinal == negative_infinity_date_ord: + pg_ordinal = pg_date_negative_infinity + else: + pg_ordinal = ordinal - pg_date_offset_ord + + buf.write_int32(4) + buf.write_int32(pg_ordinal) + + +cdef date_decode(ConnectionSettings settings, FastReadBuffer buf): + cdef int32_t pg_ordinal = hton.unpack_int32(buf.read(4)) + + if pg_ordinal == pg_date_infinity: + return infinity_date + elif pg_ordinal == pg_date_negative_infinity: + return negative_infinity_date + else: + return date_from_ordinal(pg_ordinal + pg_date_offset_ord) + + +cdef timestamp_encode(ConnectionSettings settings, WriteBuffer buf, obj): + delta = obj - pg_epoch_datetime + cdef: + int64_t seconds = cpython.PyLong_AsLongLong(delta.days) * 86400 + \ + cpython.PyLong_AsLong(delta.seconds) + int32_t microseconds = cpython.PyLong_AsLong( + delta.microseconds) + + buf.write_int32(8) + _encode_time(buf, seconds, microseconds) + + +cdef timestamp_decode(ConnectionSettings settings, FastReadBuffer buf): + cdef: + int64_t seconds = 0 + uint32_t microseconds = 0 + int32_t inf = _decode_time(buf, &seconds, µseconds) + + if inf > 0: + # positive infinity + return infinity_datetime + elif inf < 0: + # negative infinity + return negative_infinity_datetime + else: + return pg_epoch_datetime.__add__( + timedelta(0, seconds, microseconds)) + + +cdef timestamptz_encode(ConnectionSettings settings, WriteBuffer buf, obj): + buf.write_int32(8) + + if obj == infinity_datetime: + buf.write_int64(pg_time64_infinity) + return + elif obj == negative_infinity_datetime: + buf.write_int64(pg_time64_negative_infinity) + return + + delta = obj.astimezone(utc) - pg_epoch_datetime_utc + cdef: + int64_t seconds = cpython.PyLong_AsLongLong(delta.days) * 86400 + \ + cpython.PyLong_AsLong(delta.seconds) + int32_t microseconds = cpython.PyLong_AsLong( + delta.microseconds) + + _encode_time(buf, seconds, microseconds) + + +cdef timestamptz_decode(ConnectionSettings settings, FastReadBuffer buf): + cdef: + int64_t seconds = 0 + uint32_t microseconds = 0 + int32_t inf = _decode_time(buf, &seconds, µseconds) + + if inf > 0: + # positive infinity + return infinity_datetime + elif inf < 0: + # negative infinity + return negative_infinity_datetime + else: + return pg_epoch_datetime_utc.__add__( + timedelta(0, seconds, microseconds)) + + +cdef time_encode(ConnectionSettings settings, WriteBuffer buf, obj): + cdef: + int64_t seconds = cpython.PyLong_AsLong(obj.hour) * 3600 + \ + cpython.PyLong_AsLong(obj.minute) * 60 + \ + cpython.PyLong_AsLong(obj.second) + int32_t microseconds = cpython.PyLong_AsLong(obj.microsecond) + + buf.write_int32(8) + _encode_time(buf, seconds, microseconds) + + +cdef time_decode(ConnectionSettings settings, FastReadBuffer buf): + cdef: + int64_t seconds = 0 + uint32_t microseconds = 0 + + _decode_time(buf, &seconds, µseconds) + + cdef: + int64_t minutes = (seconds / 60) + int64_t sec = seconds % 60 + int64_t hours = (minutes / 60) + int64_t min = minutes % 60 + + return datetime.time(hours, min, sec, microseconds) + + +cdef timetz_encode(ConnectionSettings settings, WriteBuffer buf, obj): + offset = obj.tzinfo.utcoffset(None) + + cdef: + int32_t offset_sec = \ + cpython.PyLong_AsLong(offset.days) * 24 * 60 * 60 + \ + cpython.PyLong_AsLong(offset.seconds) + + int64_t seconds = cpython.PyLong_AsLong(obj.hour) * 3600 + \ + cpython.PyLong_AsLong(obj.minute) * 60 + \ + cpython.PyLong_AsLong(obj.second) + + int32_t microseconds = cpython.PyLong_AsLong(obj.microsecond) + + buf.write_int32(12) + _encode_time(buf, seconds, microseconds) + buf.write_int32(offset_sec) + + +cdef timetz_decode(ConnectionSettings settings, FastReadBuffer buf): + time = time_decode(settings, buf) + cdef int32_t offset = (hton.unpack_int32(buf.read(4)) / 60) + return time.replace(tzinfo=datetime.timezone(timedelta(minutes=offset))) + + +cdef interval_encode(ConnectionSettings settings, WriteBuffer buf, obj): + cdef: + int32_t days = cpython.PyLong_AsLong(obj.days) + int64_t seconds = cpython.PyLong_AsLongLong(obj.seconds) + int32_t microseconds = cpython.PyLong_AsLong(obj.microseconds) + + buf.write_int32(16) + _encode_time(buf, seconds, microseconds) + buf.write_int32(days) + buf.write_int32(0) # Months + + +cdef interval_decode(ConnectionSettings settings, FastReadBuffer buf): + cdef: + int32_t days + int32_t months + int64_t seconds = 0 + uint32_t microseconds = 0 + + _decode_time(buf, &seconds, µseconds) + days = hton.unpack_int32(buf.read(4)) + months = hton.unpack_int32(buf.read(4)) + + return datetime.timedelta(days=days + months * 30, seconds=seconds, + microseconds=microseconds) + + +cdef init_datetime_codecs(): + register_core_codec(DATEOID, + &date_encode, + &date_decode, + PG_FORMAT_BINARY) + + register_core_codec(TIMEOID, + &time_encode, + &time_decode, + PG_FORMAT_BINARY) + + register_core_codec(TIMETZOID, + &timetz_encode, + &timetz_decode, + PG_FORMAT_BINARY) + + register_core_codec(TIMESTAMPOID, + ×tamp_encode, + ×tamp_decode, + PG_FORMAT_BINARY) + + register_core_codec(TIMESTAMPTZOID, + ×tamptz_encode, + ×tamptz_decode, + PG_FORMAT_BINARY) + + register_core_codec(INTERVALOID, + &interval_encode, + &interval_decode, + PG_FORMAT_BINARY) + + # For obsolete abstime/reltime/tinterval, we do not bother to + # interpret the value, and simply return and pass it as text. + # + register_core_codec(ABSTIMEOID, + &text_encode, + &text_decode, + PG_FORMAT_TEXT) + + register_core_codec(RELTIMEOID, + &text_encode, + &text_decode, + PG_FORMAT_TEXT) + + register_core_codec(TINTERVALOID, + &text_encode, + &text_decode, + PG_FORMAT_TEXT) + +init_datetime_codecs() diff --git a/asyncpg/protocol/codecs/float.pyx b/asyncpg/protocol/codecs/float.pyx new file mode 100644 index 0000000..9ad2c23 --- /dev/null +++ b/asyncpg/protocol/codecs/float.pyx @@ -0,0 +1,49 @@ +# Copyright (C) 2016-present the ayncpg authors and contributors +# +# +# This module is part of asyncpg and is released under +# the Apache 2.0 License: http://www.apache.org/licenses/LICENSE-2.0 + + +from libc cimport math + + +cdef float4_encode(ConnectionSettings settings, WriteBuffer buf, obj): + cdef double dval = cpython.PyFloat_AsDouble(obj) + cdef float fval = dval + if math.isinf(fval) and not math.isinf(dval): + raise ValueError('float value too large to be encoded as FLOAT4') + + buf.write_int32(4) + buf.write_float(fval) + + +cdef float4_decode(ConnectionSettings settings, FastReadBuffer buf): + cdef float f = hton.unpack_float(buf.read(4)) + return cpython.PyFloat_FromDouble(f) + + +cdef float8_encode(ConnectionSettings settings, WriteBuffer buf, obj): + cdef double dval = cpython.PyFloat_AsDouble(obj) + buf.write_int32(8) + buf.write_double(dval) + + +cdef float8_decode(ConnectionSettings settings, FastReadBuffer buf): + cdef double f = hton.unpack_double(buf.read(8)) + return cpython.PyFloat_FromDouble(f) + + +cdef init_float_codecs(): + register_core_codec(FLOAT4OID, + &float4_encode, + &float4_decode, + PG_FORMAT_BINARY) + + register_core_codec(FLOAT8OID, + &float8_encode, + &float8_decode, + PG_FORMAT_BINARY) + + +init_float_codecs() diff --git a/asyncpg/protocol/codecs/geometry.pyx b/asyncpg/protocol/codecs/geometry.pyx new file mode 100644 index 0000000..c4188e3 --- /dev/null +++ b/asyncpg/protocol/codecs/geometry.pyx @@ -0,0 +1,205 @@ +# Copyright (C) 2016-present the ayncpg authors and contributors +# +# +# This module is part of asyncpg and is released under +# the Apache 2.0 License: http://www.apache.org/licenses/LICENSE-2.0 + + +from asyncpg.types import Box, Line, LineSegment, Path, Point, Polygon, Circle + + +cdef inline _encode_points(WriteBuffer wbuf, object points): + cdef object point + + for point in points: + wbuf.write_double(point[0]) + wbuf.write_double(point[1]) + + +cdef inline _decode_points(FastReadBuffer buf): + cdef: + int32_t npts = hton.unpack_int32(buf.read(4)) + pts = cpython.PyTuple_New(npts) + int32_t i + object point + double x + double y + + for i in range(npts): + x = hton.unpack_double(buf.read(8)) + y = hton.unpack_double(buf.read(8)) + point = Point(x, y) + cpython.Py_INCREF(point) + cpython.PyTuple_SET_ITEM(pts, i, point) + + return pts + + +cdef box_encode(ConnectionSettings settings, WriteBuffer wbuf, obj): + wbuf.write_int32(32) + _encode_points(wbuf, (obj[0], obj[1])) + + +cdef box_decode(ConnectionSettings settings, FastReadBuffer buf): + cdef: + double high_x = hton.unpack_double(buf.read(8)) + double high_y = hton.unpack_double(buf.read(8)) + double low_x = hton.unpack_double(buf.read(8)) + double low_y = hton.unpack_double(buf.read(8)) + + return Box(Point(high_x, high_y), Point(low_x, low_y)) + + +cdef line_encode(ConnectionSettings settings, WriteBuffer wbuf, obj): + wbuf.write_int32(24) + wbuf.write_double(obj[0]) + wbuf.write_double(obj[1]) + wbuf.write_double(obj[2]) + + +cdef line_decode(ConnectionSettings settings, FastReadBuffer buf): + cdef: + double A = hton.unpack_double(buf.read(8)) + double B = hton.unpack_double(buf.read(8)) + double C = hton.unpack_double(buf.read(8)) + + return Line(A, B, C) + + +cdef lseg_encode(ConnectionSettings settings, WriteBuffer wbuf, obj): + wbuf.write_int32(32) + _encode_points(wbuf, (obj[0], obj[1])) + + +cdef lseg_decode(ConnectionSettings settings, FastReadBuffer buf): + cdef: + double p1_x = hton.unpack_double(buf.read(8)) + double p1_y = hton.unpack_double(buf.read(8)) + double p2_x = hton.unpack_double(buf.read(8)) + double p2_y = hton.unpack_double(buf.read(8)) + + return LineSegment((p1_x, p1_y), (p2_x, p2_y)) + + +cdef point_encode(ConnectionSettings settings, WriteBuffer wbuf, obj): + wbuf.write_int32(16) + wbuf.write_double(obj[0]) + wbuf.write_double(obj[1]) + + +cdef point_decode(ConnectionSettings settings, FastReadBuffer buf): + cdef: + double x = hton.unpack_double(buf.read(8)) + double y = hton.unpack_double(buf.read(8)) + + return Point(x, y) + + +cdef path_encode(ConnectionSettings settings, WriteBuffer wbuf, obj): + cdef: + int8_t is_closed = 0 + ssize_t npts + ssize_t encoded_len + int32_t i + + if cpython.PyTuple_Check(obj): + is_closed = 1 + elif cpython.PyList_Check(obj): + is_closed = 0 + elif isinstance(obj, Path): + is_closed = obj.is_closed + + npts = len(obj) + encoded_len = 1 + 4 + 16 * npts + if encoded_len > _MAXINT32: + raise ValueError('path value too long') + + wbuf.write_int32(encoded_len) + wbuf.write_byte(is_closed) + wbuf.write_int32(npts) + + _encode_points(wbuf, obj) + + +cdef path_decode(ConnectionSettings settings, FastReadBuffer buf): + cdef: + int8_t is_closed = buf.read(1)[0] + + return Path(*_decode_points(buf), is_closed=is_closed == 1) + + +cdef poly_encode(ConnectionSettings settings, WriteBuffer wbuf, obj): + cdef: + bint is_closed + ssize_t npts + ssize_t encoded_len + int32_t i + + npts = len(obj) + encoded_len = 4 + 16 * npts + if encoded_len > _MAXINT32: + raise ValueError('polygon value too long') + + wbuf.write_int32(encoded_len) + wbuf.write_int32(npts) + _encode_points(wbuf, obj) + + +cdef poly_decode(ConnectionSettings settings, FastReadBuffer buf): + return Polygon(*_decode_points(buf)) + + +cdef circle_encode(ConnectionSettings settings, WriteBuffer wbuf, obj): + wbuf.write_int32(24) + wbuf.write_double(obj[0][0]) + wbuf.write_double(obj[0][1]) + wbuf.write_double(obj[1]) + + +cdef circle_decode(ConnectionSettings settings, FastReadBuffer buf): + cdef: + double center_x = hton.unpack_double(buf.read(8)) + double center_y = hton.unpack_double(buf.read(8)) + double radius = hton.unpack_double(buf.read(8)) + + return Circle((center_x, center_y), radius) + + +cdef init_geometry_codecs(): + register_core_codec(BOXOID, + &box_encode, + &box_decode, + PG_FORMAT_BINARY) + + register_core_codec(LINEOID, + &line_encode, + &line_decode, + PG_FORMAT_BINARY) + + register_core_codec(LSEGOID, + &lseg_encode, + &lseg_decode, + PG_FORMAT_BINARY) + + register_core_codec(POINTOID, + &point_encode, + &point_decode, + PG_FORMAT_BINARY) + + register_core_codec(PATHOID, + &path_encode, + &path_decode, + PG_FORMAT_BINARY) + + register_core_codec(POLYGONOID, + &poly_encode, + &poly_decode, + PG_FORMAT_BINARY) + + register_core_codec(CIRCLEOID, + &circle_encode, + &circle_decode, + PG_FORMAT_BINARY) + + +init_geometry_codecs() diff --git a/asyncpg/protocol/codecs/hstore.pyx b/asyncpg/protocol/codecs/hstore.pyx new file mode 100644 index 0000000..0bbdc66 --- /dev/null +++ b/asyncpg/protocol/codecs/hstore.pyx @@ -0,0 +1,82 @@ +# Copyright (C) 2016-present the ayncpg authors and contributors +# +# +# This module is part of asyncpg and is released under +# the Apache 2.0 License: http://www.apache.org/licenses/LICENSE-2.0 + + +cdef hstore_encode(ConnectionSettings settings, WriteBuffer buf, obj): + cdef: + char *str + ssize_t size + ssize_t count + object items + WriteBuffer item_buf = WriteBuffer.new() + + count = len(obj) + if count > _MAXINT32: + raise ValueError('hstore value is too large') + item_buf.write_int32(count) + + if hasattr(obj, 'items'): + items = obj.items() + else: + items = obj + + for k, v in items: + if k is None: + raise ValueError('null value not allowed in hstore key') + as_pg_string_and_size(settings, k, &str, &size) + item_buf.write_int32(size) + item_buf.write_cstr(str, size) + if v is None: + item_buf.write_int32(-1) + else: + as_pg_string_and_size(settings, v, &str, &size) + item_buf.write_int32(size) + item_buf.write_cstr(str, size) + + buf.write_int32(item_buf.len()) + buf.write_buffer(item_buf) + + +cdef hstore_decode(ConnectionSettings settings, FastReadBuffer buf): + cdef: + dict result + uint32_t elem_count + int32_t elem_len + uint32_t i + str k + str v + + result = {} + + elem_count = hton.unpack_int32(buf.read(4)) + if elem_count == 0: + return result + + for i in range(elem_count): + elem_len = hton.unpack_int32(buf.read(4)) + if elem_len < 0: + raise ValueError('null value not allowed in hstore key') + + k = decode_pg_string(settings, buf.read(elem_len), elem_len) + + elem_len = hton.unpack_int32(buf.read(4)) + if elem_len < 0: + v = None + else: + v = decode_pg_string(settings, buf.read(elem_len), elem_len) + + result[k] = v + + return result + + +cdef init_hstore_codecs(): + register_extra_codec('pg_contrib.hstore', + &hstore_encode, + &hstore_decode, + PG_FORMAT_BINARY) + +init_hstore_codecs() diff --git a/asyncpg/protocol/codecs/int.pyx b/asyncpg/protocol/codecs/int.pyx new file mode 100644 index 0000000..9b95fee --- /dev/null +++ b/asyncpg/protocol/codecs/int.pyx @@ -0,0 +1,79 @@ +# Copyright (C) 2016-present the ayncpg authors and contributors +# +# +# This module is part of asyncpg and is released under +# the Apache 2.0 License: http://www.apache.org/licenses/LICENSE-2.0 + + +cdef bool_encode(ConnectionSettings settings, WriteBuffer buf, obj): + if not cpython.PyBool_Check(obj): + raise TypeError('a boolean is required (got type {})'.format( + type(obj).__name__)) + + buf.write_int32(1) + buf.write_byte(b'\x01' if obj is True else b'\x00') + + +cdef bool_decode(ConnectionSettings settings, FastReadBuffer buf): + return buf.read(1)[0] is b'\x01' + + +cdef int2_encode(ConnectionSettings settings, WriteBuffer buf, obj): + cdef long val = cpython.PyLong_AsLong(obj) + if val < -32767 or val > 32767: + raise ValueError( + 'integer too large to be encoded as INT2: {!r}'.format(val)) + + buf.write_int32(2) + buf.write_int16(val) + + +cdef int2_decode(ConnectionSettings settings, FastReadBuffer buf): + return cpython.PyLong_FromLong(hton.unpack_int16(buf.read(2))) + + +cdef int4_encode(ConnectionSettings settings, WriteBuffer buf, obj): + cdef int32_t val = cpython.PyLong_AsLong(obj) + + buf.write_int32(4) + buf.write_int32(val) + + +cdef int4_decode(ConnectionSettings settings, FastReadBuffer buf): + return cpython.PyLong_FromLong(hton.unpack_int32(buf.read(4))) + + +cdef int8_encode(ConnectionSettings settings, WriteBuffer buf, obj): + cdef int64_t val = cpython.PyLong_AsLongLong(obj) + buf.write_int32(8) + buf.write_int64(val) + + +cdef int8_decode(ConnectionSettings settings, FastReadBuffer buf): + return cpython.PyLong_FromLongLong(hton.unpack_int64(buf.read(8))) + + +cdef init_int_codecs(): + + register_core_codec(BOOLOID, + &bool_encode, + &bool_decode, + PG_FORMAT_BINARY) + + register_core_codec(INT2OID, + &int2_encode, + &int2_decode, + PG_FORMAT_BINARY) + + register_core_codec(INT4OID, + &int4_encode, + &int4_decode, + PG_FORMAT_BINARY) + + register_core_codec(INT8OID, + &int8_encode, + &int8_decode, + PG_FORMAT_BINARY) + + +init_int_codecs() diff --git a/asyncpg/protocol/codecs/json.pyx b/asyncpg/protocol/codecs/json.pyx new file mode 100644 index 0000000..6773d41 --- /dev/null +++ b/asyncpg/protocol/codecs/json.pyx @@ -0,0 +1,42 @@ +# Copyright (C) 2016-present the ayncpg authors and contributors +# +# +# This module is part of asyncpg and is released under +# the Apache 2.0 License: http://www.apache.org/licenses/LICENSE-2.0 + + +cdef jsonb_encode(ConnectionSettings settings, WriteBuffer buf, obj): + cdef: + char *str + ssize_t size + + as_pg_string_and_size(settings, obj, &str, &size) + + if size > 0x7fffffff - 1: + raise ValueError('string too long') + + buf.write_int32(size + 1) + buf.write_byte(1) # JSONB format version + buf.write_cstr(str, size) + + +cdef jsonb_decode(ConnectionSettings settings, FastReadBuffer buf): + cdef uint8_t format = buf.read(1)[0] + + if format != 1: + raise ValueError('unexpected JSONB format: {}'.format(format)) + + return text_decode(settings, buf) + + +cdef init_json_codecs(): + register_core_codec(JSONOID, + &text_encode, + &text_decode, + PG_FORMAT_BINARY) + register_core_codec(JSONBOID, + &jsonb_encode, + &jsonb_decode, + PG_FORMAT_BINARY) + +init_json_codecs() diff --git a/asyncpg/protocol/codecs/misc.pyx b/asyncpg/protocol/codecs/misc.pyx new file mode 100644 index 0000000..01f4a5d --- /dev/null +++ b/asyncpg/protocol/codecs/misc.pyx @@ -0,0 +1,108 @@ +# Copyright (C) 2016-present the ayncpg authors and contributors +# +# +# This module is part of asyncpg and is released under +# the Apache 2.0 License: http://www.apache.org/licenses/LICENSE-2.0 + + +cdef void_encode(ConnectionSettings settings, WriteBuffer buf, obj): + # Void is zero bytes + buf.write_int32(0) + + +cdef void_decode(ConnectionSettings settings, FastReadBuffer buf): + # Do nothing; void will be passed as NULL so this function + # will never be called. + pass + + +cdef init_pseudo_codecs(): + # Void type is returned by SELECT void_returning_function() + register_core_codec(VOIDOID, + &void_encode, + &void_decode, + PG_FORMAT_BINARY) + + # Unknown type, always decoded as text + register_core_codec(UNKNOWNOID, + &text_encode, + &text_decode, + PG_FORMAT_TEXT) + + # OID and friends + oid_types = [ + OIDOID, TIDOID, XIDOID, CIDOID + ] + + for oid_type in oid_types: + register_core_codec(oid_type, + &int4_encode, + &int4_decode, + PG_FORMAT_BINARY) + + # reg* types -- these are really system catalog OIDs, but + # allow the catalog object name as an input. We could just + # decode these as OIDs, but handling them as text seems more + # useful. + # + reg_types = [ + REGPROCOID, REGPROCEDUREOID, REGOPEROID, REGOPERATOROID, + REGCLASSOID, REGTYPEOID, REGCONFIGOID, REGDICTIONARYOID, + REGNAMESPACEOID, REGROLEOID, REFCURSOROID + ] + + for reg_type in reg_types: + register_core_codec(reg_type, + &text_encode, + &text_decode, + PG_FORMAT_TEXT) + + # cstring type is used by Postgres' I/O functions + register_core_codec(CSTRINGOID, + &text_encode, + &text_decode, + PG_FORMAT_BINARY) + + # various system pseudotypes with no I/O + no_io_types = [ + ANYOID, TRIGGEROID, EVENT_TRIGGEROID, LANGUAGE_HANDLEROID, + FDW_HANDLEROID, TSM_HANDLEROID, INTERNALOID, OPAQUEOID, + ANYELEMENTOID, ANYNONARRAYOID, PG_DDL_COMMANDOID, + ] + + register_core_codec(ANYENUMOID, + NULL, + &text_decode, + PG_FORMAT_TEXT) + + for no_io_type in no_io_types: + register_core_codec(no_io_type, + NULL, + NULL, + PG_FORMAT_BINARY) + + # ACL specification string + register_core_codec(ACLITEMOID, + &text_encode, + &text_decode, + PG_FORMAT_TEXT) + + # Postgres' serialized expression tree type + register_core_codec(PG_NODE_TREEOID, + NULL, + &text_decode, + PG_FORMAT_TEXT) + + # pg_lsn type -- a pointer to a location in the XLOG. + register_core_codec(PG_LSNOID, + &int8_encode, + &int8_decode, + PG_FORMAT_BINARY) + + register_core_codec(SMGROID, + &text_encode, + &text_decode, + PG_FORMAT_TEXT) + + +init_pseudo_codecs() diff --git a/asyncpg/protocol/codecs/money.pyx b/asyncpg/protocol/codecs/money.pyx new file mode 100644 index 0000000..edc340b --- /dev/null +++ b/asyncpg/protocol/codecs/money.pyx @@ -0,0 +1,20 @@ +# Copyright (C) 2016-present the ayncpg authors and contributors +# +# +# This module is part of asyncpg and is released under +# the Apache 2.0 License: http://www.apache.org/licenses/LICENSE-2.0 + + +cdef init_monetary_codecs(): + moneyoids = [ + MONEYOID, + ] + + for oid in moneyoids: + register_core_codec(oid, + &text_encode, + &text_decode, + PG_FORMAT_TEXT) + + +init_monetary_codecs() diff --git a/asyncpg/protocol/codecs/network.pyx b/asyncpg/protocol/codecs/network.pyx new file mode 100644 index 0000000..336442d --- /dev/null +++ b/asyncpg/protocol/codecs/network.pyx @@ -0,0 +1,111 @@ +# Copyright (C) 2016-present the ayncpg authors and contributors +# +# +# This module is part of asyncpg and is released under +# the Apache 2.0 License: http://www.apache.org/licenses/LICENSE-2.0 + + +import ipaddress + + +# defined in postgresql/src/include/inet.h +# +DEF PGSQL_AF_INET = 2 # AF_INET +DEF PGSQL_AF_INET6 = 3 # AF_INET + 1 + + +_ipaddr = ipaddress.ip_address +_ipnet = ipaddress.ip_network + + +cdef inline _net_encode(WriteBuffer buf, int32_t version, uint8_t bits, + int8_t is_cidr, bytes addr): + + cdef: + char *addrbytes + ssize_t addrlen + int8_t family + + family = PGSQL_AF_INET if version == 4 else PGSQL_AF_INET6 + cpython.PyBytes_AsStringAndSize(addr, &addrbytes, &addrlen) + + buf.write_int32(4 + addrlen) + buf.write_byte(family) + buf.write_byte(bits) + buf.write_byte(is_cidr) + buf.write_byte(addrlen) + buf.write_cstr(addrbytes, addrlen) + + +cdef net_decode(ConnectionSettings settings, FastReadBuffer buf): + cdef: + int32_t family = buf.read(1)[0] + uint8_t bits = buf.read(1)[0] + uint32_t is_cidr = buf.read(1)[0] + uint32_t addrlen = buf.read(1)[0] + bytes addr + + if family != PGSQL_AF_INET and family != PGSQL_AF_INET6: + raise ValueError('invalid address family in "{}" value'.format( + 'cidr' if is_cidr else 'inet' + )) + + if bits > (32 if family == PGSQL_AF_INET else 128): + raise ValueError('invalid bits in "{}" value'.format( + 'cidr' if is_cidr else 'inet' + )) + + if addrlen != (4 if family == PGSQL_AF_INET else 16): + raise ValueError('invalid length in "{}" value'.format( + 'cidr' if is_cidr else 'inet' + )) + + addr = cpython.PyBytes_FromStringAndSize(buf.read(addrlen), addrlen) + + if is_cidr or bits > 0: + return _ipnet(addr).supernet(new_prefix=cpython.PyLong_FromLong(bits)) + else: + return _ipaddr(addr) + + +cdef cidr_encode(ConnectionSettings settings, WriteBuffer buf, obj): + cdef: + object ipnet + + ipnet = _ipnet(obj) + _net_encode(buf, ipnet.version, ipnet.prefixlen, 1, + ipnet.network_address.packed) + + +cdef inet_encode(ConnectionSettings settings, WriteBuffer buf, obj): + cdef: + object ipaddr + + try: + ipaddr = _ipaddr(obj) + except ValueError: + # PostgreSQL accepts *both* CIDR and host values + # for the host datatype. + cidr_encode(settings, buf, obj) + else: + _net_encode(buf, ipaddr.version, 0, 0, ipaddr.packed) + + +cdef init_network_codecs(): + register_core_codec(CIDROID, + &cidr_encode, + &net_decode, + PG_FORMAT_BINARY) + + register_core_codec(INETOID, + &inet_encode, + &net_decode, + PG_FORMAT_BINARY) + + register_core_codec(MACADDROID, + &text_encode, + &text_decode, + PG_FORMAT_TEXT) + + +init_network_codecs() diff --git a/asyncpg/protocol/codecs/numeric.pyx b/asyncpg/protocol/codecs/numeric.pyx new file mode 100644 index 0000000..bcc2389 --- /dev/null +++ b/asyncpg/protocol/codecs/numeric.pyx @@ -0,0 +1,28 @@ +# Copyright (C) 2016-present the ayncpg authors and contributors +# +# +# This module is part of asyncpg and is released under +# the Apache 2.0 License: http://www.apache.org/licenses/LICENSE-2.0 + + +import decimal + + +_Dec = decimal.Decimal + + +cdef numeric_encode(ConnectionSettings settings, WriteBuffer buf, obj): + text_encode(settings, buf, str(obj)) + + +cdef numeric_decode(ConnectionSettings settings, FastReadBuffer buf): + return _Dec(text_decode(settings, buf)) + + +cdef init_numeric_codecs(): + register_core_codec(NUMERICOID, + &numeric_encode, + &numeric_decode, + PG_FORMAT_TEXT) + +init_numeric_codecs() diff --git a/asyncpg/protocol/codecs/range.pyx b/asyncpg/protocol/codecs/range.pyx new file mode 100644 index 0000000..979caf1 --- /dev/null +++ b/asyncpg/protocol/codecs/range.pyx @@ -0,0 +1,149 @@ +# Copyright (C) 2016-present the ayncpg authors and contributors +# +# +# This module is part of asyncpg and is released under +# the Apache 2.0 License: http://www.apache.org/licenses/LICENSE-2.0 + + +from asyncpg import types as apg_types + +# defined in postgresql/src/include/utils/rangetypes.h +DEF RANGE_EMPTY = 0x01 # range is empty +DEF RANGE_LB_INC = 0x02 # lower bound is inclusive +DEF RANGE_UB_INC = 0x04 # upper bound is inclusive +DEF RANGE_LB_INF = 0x08 # lower bound is -infinity +DEF RANGE_UB_INF = 0x10 # upper bound is +infinity + + +cdef enum _RangeArgumentType: + _RANGE_ARGUMENT_INVALID = 0 + _RANGE_ARGUMENT_TUPLE = 1 + _RANGE_ARGUMENT_RANGE = 2 + + +cdef inline bint _range_has_lbound(uint8_t flags): + return not (flags & (RANGE_EMPTY | RANGE_LB_INF)) + + +cdef inline bint _range_has_ubound(uint8_t flags): + return not (flags & (RANGE_EMPTY | RANGE_UB_INF)) + + +cdef inline _RangeArgumentType _range_type(object obj): + if cpython.PyTuple_Check(obj) or cpython.PyList_Check(obj): + return _RANGE_ARGUMENT_TUPLE + elif isinstance(obj, apg_types.Range): + return _RANGE_ARGUMENT_RANGE + else: + return _RANGE_ARGUMENT_INVALID + + +cdef range_encode(ConnectionSettings settings, WriteBuffer buf, + object obj, uint32_t elem_oid, + encode_func_ex encoder, const void *encoder_arg): + cdef: + ssize_t obj_len + uint8_t flags = 0 + object lower = None + object upper = None + WriteBuffer bounds_data = WriteBuffer.new() + _RangeArgumentType arg_type = _range_type(obj) + + if arg_type == _RANGE_ARGUMENT_INVALID: + raise TypeError( + 'list, tuple or Range object expected (got type {})'.format( + type(obj))) + + elif arg_type == _RANGE_ARGUMENT_TUPLE: + obj_len = len(obj) + if obj_len == 2: + lower = obj[0] + upper = obj[1] + + if lower is None: + flags |= RANGE_LB_INF + + if upper is None: + flags |= RANGE_UB_INF + + flags |= RANGE_LB_INC | RANGE_UB_INC + + elif obj_len == 1: + lower = obj[0] + flags |= RANGE_LB_INC | RANGE_UB_INF + + elif obj_len == 0: + flags |= RANGE_EMPTY + + else: + raise ValueError( + 'expected 0, 1 or 2 elements in range (got {})'.format( + obj_len)) + + else: + if obj.isempty: + flags |= RANGE_EMPTY + else: + lower = obj.lower + upper = obj.upper + + if obj.lower_inc: + flags |= RANGE_LB_INC + elif lower is None: + flags |= RANGE_LB_INF + + if obj.upper_inc: + flags |= RANGE_UB_INC + elif upper is None: + flags |= RANGE_UB_INF + + if _range_has_lbound(flags): + encoder(settings, bounds_data, lower, encoder_arg) + + if _range_has_ubound(flags): + encoder(settings, bounds_data, upper, encoder_arg) + + buf.write_int32(1 + bounds_data.len()) + buf.write_byte(flags) + buf.write_buffer(bounds_data) + + +cdef range_decode(ConnectionSettings settings, FastReadBuffer buf, + decode_func_ex decoder, const void *decoder_arg): + cdef: + uint8_t flags = buf.read(1)[0] + int32_t bound_len + object lower = None + object upper = None + FastReadBuffer bound_buf = FastReadBuffer.new() + + if _range_has_lbound(flags): + bound_len = hton.unpack_int32(buf.read(4)) + if bound_len == -1: + lower = None + else: + bound_buf.slice_from(buf, bound_len) + lower = decoder(settings, bound_buf, decoder_arg) + + if _range_has_ubound(flags): + bound_len = hton.unpack_int32(buf.read(4)) + if bound_len == -1: + upper = None + else: + bound_buf.slice_from(buf, bound_len) + upper = decoder(settings, bound_buf, decoder_arg) + + return apg_types.Range(lower=lower, upper=upper, + lower_inc=(flags & RANGE_LB_INC) != 0, + upper_inc=(flags & RANGE_UB_INC) != 0, + empty=(flags & RANGE_EMPTY) != 0) + + +cdef init_range_codecs(): + register_core_codec(ANYRANGEOID, + NULL, + &text_decode, + PG_FORMAT_TEXT) + + +init_range_codecs() diff --git a/asyncpg/protocol/codecs/record.pyx b/asyncpg/protocol/codecs/record.pyx new file mode 100644 index 0000000..291a0b1 --- /dev/null +++ b/asyncpg/protocol/codecs/record.pyx @@ -0,0 +1,57 @@ +# Copyright (C) 2016-present the ayncpg authors and contributors +# +# +# This module is part of asyncpg and is released under +# the Apache 2.0 License: http://www.apache.org/licenses/LICENSE-2.0 + + +cdef inline record_encode_frame(ConnectionSettings settings, WriteBuffer buf, + WriteBuffer elem_data, int32_t elem_count): + buf.write_int32(4 + elem_data.len()) + # attribute count + buf.write_int32(elem_count) + # encoded attribute data + buf.write_buffer(elem_data) + + +cdef anonymous_record_decode(ConnectionSettings settings, FastReadBuffer buf): + cdef: + tuple result + uint32_t elem_count + int32_t elem_len + uint32_t elem_typ + uint32_t i + Codec elem_codec + FastReadBuffer elem_buf = FastReadBuffer.new() + + elem_count = hton.unpack_int32(buf.read(4)) + result = cpython.PyTuple_New(elem_count) + + for i in range(elem_count): + elem_typ = hton.unpack_int32(buf.read(4)) + elem_len = hton.unpack_int32(buf.read(4)) + + if elem_len == -1: + elem = None + else: + elem_codec = settings.get_data_codec(elem_typ) + if elem_codec is None or not elem_codec.has_decoder(): + raise RuntimeError( + 'no decoder for composite type element in ' + 'position {} of type OID {}'.format(i, elem_typ)) + elem = elem_codec.decode(settings, + elem_buf.slice_from(buf, elem_len)) + + cpython.Py_INCREF(elem) + cpython.PyTuple_SET_ITEM(result, i, elem) + + return result + + +cdef init_record_codecs(): + register_core_codec(RECORDOID, + NULL, + &anonymous_record_decode, + PG_FORMAT_BINARY) + +init_record_codecs() diff --git a/asyncpg/protocol/codecs/text.pyx b/asyncpg/protocol/codecs/text.pyx new file mode 100644 index 0000000..b8397d9 --- /dev/null +++ b/asyncpg/protocol/codecs/text.pyx @@ -0,0 +1,67 @@ +# Copyright (C) 2016-present the ayncpg authors and contributors +# +# +# This module is part of asyncpg and is released under +# the Apache 2.0 License: http://www.apache.org/licenses/LICENSE-2.0 + + +cdef inline as_pg_string_and_size( + ConnectionSettings settings, obj, char **cstr, ssize_t *size): + + if not cpython.PyUnicode_Check(obj): + obj = str(obj) + + if settings.is_encoding_utf8(): + cstr[0] = PyUnicode_AsUTF8AndSize(obj, size) + else: + encoded = settings.get_text_codec().encode(obj) + cpython.PyBytes_AsStringAndSize(encoded, cstr, size) + + if size[0] > 0x7fffffff: + raise ValueError('string too long') + + +cdef text_encode(ConnectionSettings settings, WriteBuffer buf, obj): + cdef: + char *str + ssize_t size + + as_pg_string_and_size(settings, obj, &str, &size) + + buf.write_int32(size) + buf.write_cstr(str, size) + + +cdef inline decode_pg_string(ConnectionSettings settings, const char* data, + ssize_t len): + + if settings.is_encoding_utf8(): + # decode UTF-8 in strict mode + return cpython.PyUnicode_DecodeUTF8(data, len, NULL) + else: + bytes = cpython.PyBytes_FromStringAndSize(data, len) + return settings.get_text_codec().decode(bytes) + + +cdef text_decode(ConnectionSettings settings, FastReadBuffer buf): + cdef ssize_t buf_len = buf.len + return decode_pg_string(settings, buf.read_all(), buf_len) + + +cdef init_text_codecs(): + textoids = [ + NAMEOID, + BPCHAROID, + VARCHAROID, + TEXTOID, + XMLOID + ] + + for oid in textoids: + register_core_codec(oid, + &text_encode, + &text_decode, + PG_FORMAT_BINARY) + + +init_text_codecs() diff --git a/asyncpg/protocol/codecs/textutils.pyx b/asyncpg/protocol/codecs/textutils.pyx new file mode 100644 index 0000000..1a09c17 --- /dev/null +++ b/asyncpg/protocol/codecs/textutils.pyx @@ -0,0 +1,72 @@ +# Copyright (C) 2016-present the ayncpg authors and contributors +# +# +# This module is part of asyncpg and is released under +# the Apache 2.0 License: http://www.apache.org/licenses/LICENSE-2.0 + + + +cdef int apg_strcasecmp(const Py_UCS4 *s1, const Py_UCS4 *s2): + cdef: + uint32_t c1 + uint32_t c2 + int i = 0 + + while True: + c1 = s1[i] + c2 = s2[i] + + if c1 != c2: + if c1 >= 'A' and c1 <= 'Z': + c1 += 'a' - 'A' + if c2 >= 'A' and c2 <= 'Z': + c2 += 'a' - 'A' + + if c1 != c2: + return c1 - c2 + + if c1 == 0 or c2 == 0: + break + + i += 1 + + return 0 + + +cdef inline bint apg_ascii_isspace(Py_UCS4 ch): + return ( + ch == ' ' or + ch == '\n' or + ch == '\r' or + ch == '\t' or + ch == '\v' or + ch == '\f' + ) + + +cdef Py_UCS4 *apg_parse_int32(Py_UCS4 *buf, int32_t *num): + cdef: + Py_UCS4 *p + int32_t n = 0 + int32_t neg = 0 + + if buf[0] == '-': + neg = 1 + buf += 1 + elif buf[0] == '+': + buf += 1 + + p = buf + while p[0] >= '0' and p[0] <= '9': + n = 10 * n - (p[0] - '0') + p += 1 + + if p == buf: + return NULL + + if not neg: + n = -n + + num[0] = n + + return p diff --git a/asyncpg/protocol/codecs/tsearch.pyx b/asyncpg/protocol/codecs/tsearch.pyx new file mode 100644 index 0000000..dd080d5 --- /dev/null +++ b/asyncpg/protocol/codecs/tsearch.pyx @@ -0,0 +1,26 @@ +# Copyright (C) 2016-present the ayncpg authors and contributors +# +# +# This module is part of asyncpg and is released under +# the Apache 2.0 License: http://www.apache.org/licenses/LICENSE-2.0 + + +cdef init_tsearch_codecs(): + ts_oids = [ + TSQUERYOID, + TSVECTOROID, + ] + + for oid in ts_oids: + register_core_codec(oid, + &text_encode, + &text_decode, + PG_FORMAT_TEXT) + + register_core_codec(GTSVECTOROID, + NULL, + &text_decode, + PG_FORMAT_TEXT) + + +init_tsearch_codecs() diff --git a/asyncpg/protocol/codecs/txid.pyx b/asyncpg/protocol/codecs/txid.pyx new file mode 100644 index 0000000..5ea5e41 --- /dev/null +++ b/asyncpg/protocol/codecs/txid.pyx @@ -0,0 +1,71 @@ +# Copyright (C) 2016-present the ayncpg authors and contributors +# +# +# This module is part of asyncpg and is released under +# the Apache 2.0 License: http://www.apache.org/licenses/LICENSE-2.0 + + +cdef txid_snapshot_encode(ConnectionSettings settings, WriteBuffer buf, obj): + cdef: + ssize_t nxip + int64_t xmin + int64_t xmax + int i + WriteBuffer xip_buf = WriteBuffer.new() + + if not (cpython.PyTuple_Check(obj) or cpython.PyList_Check(obj)): + raise TypeError( + 'list or tuple expected (got type {})'.format(type(obj))) + + if len(obj) != 3: + raise ValueError( + 'invalid number of elements in txid_snapshot tuple, expecting 4') + + nxip = len(obj[2]) + if nxip > _MAXINT32: + raise ValueError('txid_snapshot value is too long') + + xmin = obj[0] + xmax = obj[1] + + for i in range(nxip): + xip_buf.write_int64(obj[2][i]) + + buf.write_int32(20 + xip_buf.len()) + + buf.write_int32(nxip) + buf.write_int64(obj[0]) + buf.write_int64(obj[1]) + buf.write_buffer(xip_buf) + + +cdef txid_snapshot_decode(ConnectionSettings settings, FastReadBuffer buf): + cdef: + int32_t nxip + int64_t xmin + int64_t xmax + tuple xip_tup + int32_t i + object xip + + nxip = hton.unpack_int32(buf.read(4)) + xmin = hton.unpack_int64(buf.read(8)) + xmax = hton.unpack_int64(buf.read(8)) + + xip_tup = cpython.PyTuple_New(nxip) + for i in range(nxip): + xip = cpython.PyLong_FromLongLong(hton.unpack_int64(buf.read(8))) + cpython.Py_INCREF(xip) + cpython.PyTuple_SET_ITEM(xip_tup, i, xip) + + return (xmin, xmax, xip_tup) + + +cdef init_txid_codecs(): + register_core_codec(TXID_SNAPSHOTOID, + &txid_snapshot_encode, + &txid_snapshot_decode, + PG_FORMAT_BINARY) + + +init_txid_codecs() diff --git a/asyncpg/protocol/codecs/uuid.pyx b/asyncpg/protocol/codecs/uuid.pyx new file mode 100644 index 0000000..a40ef3a --- /dev/null +++ b/asyncpg/protocol/codecs/uuid.pyx @@ -0,0 +1,31 @@ +# Copyright (C) 2016-present the ayncpg authors and contributors +# +# +# This module is part of asyncpg and is released under +# the Apache 2.0 License: http://www.apache.org/licenses/LICENSE-2.0 + + +import uuid + + +_UUID = uuid.UUID + + +cdef uuid_encode(ConnectionSettings settings, WriteBuffer wbuf, obj): + if cpython.PyUnicode_Check(obj): + obj = _UUID(obj) + + bytea_encode(settings, wbuf, obj.bytes) + + +cdef uuid_decode(ConnectionSettings settings, FastReadBuffer buf): + return _UUID(bytes=bytea_decode(settings, buf)) + + +cdef init_uuid_codecs(): + register_core_codec(UUIDOID, + &uuid_encode, + &uuid_decode, + PG_FORMAT_BINARY) + +init_uuid_codecs() diff --git a/asyncpg/protocol/consts.pxi b/asyncpg/protocol/consts.pxi new file mode 100644 index 0000000..cfa82e6 --- /dev/null +++ b/asyncpg/protocol/consts.pxi @@ -0,0 +1,13 @@ +# Copyright (C) 2016-present the ayncpg authors and contributors +# +# +# This module is part of asyncpg and is released under +# the Apache 2.0 License: http://www.apache.org/licenses/LICENSE-2.0 + + +DEF _BUFFER_INITIAL_SIZE = 1024 +DEF _BUFFER_MAX_GROW = 65536 +DEF _BUFFER_FREELIST_SIZE = 256 +DEF _RECORD_FREELIST_SIZE = 1024 +DEF _MEMORY_FREELIST_SIZE = 1024 +DEF _MAXINT32 = 2**31 - 1 diff --git a/asyncpg/protocol/coreproto.pxd b/asyncpg/protocol/coreproto.pxd new file mode 100644 index 0000000..efe5d1b --- /dev/null +++ b/asyncpg/protocol/coreproto.pxd @@ -0,0 +1,158 @@ +# Copyright (C) 2016-present the ayncpg authors and contributors +# +# +# This module is part of asyncpg and is released under +# the Apache 2.0 License: http://www.apache.org/licenses/LICENSE-2.0 + + +cdef enum ConnectionStatus: + CONNECTION_OK = 1 + CONNECTION_BAD = 2 + CONNECTION_STARTED = 3 # Waiting for connection to be made. + + +cdef enum ProtocolState: + PROTOCOL_IDLE = 0 + + PROTOCOL_FAILED = 1 + + PROTOCOL_ERROR_CONSUME = 2 + + PROTOCOL_AUTH = 10 + PROTOCOL_PREPARE = 11 + PROTOCOL_BIND_EXECUTE = 12 + PROTOCOL_BIND_EXECUTE_MANY = 13 + PROTOCOL_CLOSE_STMT_PORTAL = 14 + PROTOCOL_SIMPLE_QUERY = 15 + PROTOCOL_EXECUTE = 16 + PROTOCOL_BIND = 17 + + +cdef enum AuthenticationMessage: + AUTH_SUCCESSFUL = 0 + AUTH_REQUIRED_KERBEROS = 2 + AUTH_REQUIRED_PASSWORD = 3 + AUTH_REQUIRED_PASSWORDMD5 = 5 + AUTH_REQUIRED_SCMCRED = 6 + AUTH_REQUIRED_GSS = 7 + AUTH_REQUIRED_GSS_CONTINUE = 8 + AUTH_REQUIRED_SSPI = 9 + + +AUTH_METHOD_NAME = { + AUTH_REQUIRED_KERBEROS: 'kerberosv5', + AUTH_REQUIRED_PASSWORD: 'password', + AUTH_REQUIRED_PASSWORDMD5: 'md5', + AUTH_REQUIRED_GSS: 'gss', + AUTH_REQUIRED_SSPI: 'sspi', +} + + +cdef enum ResultType: + RESULT_OK = 1 + RESULT_FAILED = 2 + + +cdef enum TransactionStatus: + PQTRANS_IDLE = 0 # connection idle + PQTRANS_ACTIVE = 1 # command in progress + PQTRANS_INTRANS = 2 # idle, within transaction block + PQTRANS_INERROR = 3 # idle, within failed transaction + PQTRANS_UNKNOWN = 4 # cannot determine status + + +ctypedef object (*decode_row_method)(object, const char*, ssize_t) + + +cdef class CoreProtocol: + cdef: + ReadBuffer buffer + bint _skip_discard + bint _discard_data + + # executemany support data + object _execute_iter + str _execute_portal_name + str _execute_stmt_name + + ConnectionStatus con_status + ProtocolState state + TransactionStatus xact_status + + str encoding + + object transport + + # Dict with all connection arguments + dict con_args + + readonly int32_t backend_pid + readonly int32_t backend_secret + + ## Result + ResultType result_type + object result + bytes result_param_desc + bytes result_row_desc + bytes result_status_msg + + # True - completed, False - suspended + bint result_execute_completed + + cdef _process__auth(self, char mtype) + cdef _process__prepare(self, char mtype) + cdef _process__bind_execute(self, char mtype) + cdef _process__bind_execute_many(self, char mtype) + cdef _process__close_stmt_portal(self, char mtype) + cdef _process__simple_query(self, char mtype) + cdef _process__bind(self, char mtype) + + cdef _parse_msg_authentication(self) + cdef _parse_msg_parameter_status(self) + cdef _parse_msg_notification(self) + cdef _parse_msg_backend_key_data(self) + cdef _parse_msg_ready_for_query(self) + cdef _parse_data_msgs(self) + cdef _parse_msg_error_response(self, is_error) + cdef _parse_msg_command_complete(self) + + cdef _auth_password_message_cleartext(self) + cdef _auth_password_message_md5(self, bytes salt) + + cdef _write(self, buf) + cdef inline _write_sync_message(self) + + cdef _read_server_messages(self) + + cdef _push_result(self) + cdef _reset_result(self) + cdef _set_state(self, ProtocolState new_state) + + cdef _ensure_connected(self) + + cdef WriteBuffer _build_bind_message(self, str portal_name, + str stmt_name, + WriteBuffer bind_data) + + + cdef _connect(self) + cdef _prepare(self, str stmt_name, str query) + cdef _send_bind_message(self, str portal_name, str stmt_name, + WriteBuffer bind_data, int32_t limit) + cdef _bind_execute(self, str portal_name, str stmt_name, + WriteBuffer bind_data, int32_t limit) + cdef _bind_execute_many(self, str portal_name, str stmt_name, + object bind_data) + cdef _bind(self, str portal_name, str stmt_name, + WriteBuffer bind_data) + cdef _execute(self, str portal_name, int32_t limit) + cdef _close(self, str name, bint is_portal) + cdef _simple_query(self, str query) + cdef _terminate(self) + + cdef _decode_row(self, const char* buf, ssize_t buf_len) + + cdef _on_result(self) + cdef _on_notification(self, pid, channel, payload) + cdef _set_server_parameter(self, name, val) + cdef _on_connection_lost(self, exc) diff --git a/asyncpg/protocol/coreproto.pyx b/asyncpg/protocol/coreproto.pyx new file mode 100644 index 0000000..b72cdff --- /dev/null +++ b/asyncpg/protocol/coreproto.pyx @@ -0,0 +1,756 @@ +# Copyright (C) 2016-present the ayncpg authors and contributors +# +# +# This module is part of asyncpg and is released under +# the Apache 2.0 License: http://www.apache.org/licenses/LICENSE-2.0 + + +from hashlib import md5 as hashlib_md5 # for MD5 authentication + + +cdef class CoreProtocol: + + def __init__(self, con_args): + self.buffer = ReadBuffer() + self.user = con_args.get('user') + self.password = con_args.get('password') + self.auth_msg = None + self.con_args = con_args + self.transport = None + self.con_status = CONNECTION_BAD + self.state = PROTOCOL_IDLE + self.xact_status = PQTRANS_IDLE + self.encoding = 'utf-8' + + self._skip_discard = False + + # executemany support data + self._execute_iter = None + self._execute_portal_name = None + self._execute_stmt_name = None + + self._reset_result() + + cdef _write(self, buf): + self.transport.write(memoryview(buf)) + + cdef inline _write_sync_message(self): + self.transport.write(SYNC_MESSAGE) + + cdef _read_server_messages(self): + cdef: + char mtype + ProtocolState state + + while self.buffer.has_message() == 1: + mtype = self.buffer.get_message_type() + state = self.state + + try: + if mtype == b'S': + # ParameterStatus + self._parse_msg_parameter_status() + continue + elif mtype == b'A': + # NotificationResponse + self._parse_msg_notification() + continue + + if state == PROTOCOL_AUTH: + self._process__auth(mtype) + + elif state == PROTOCOL_PREPARE: + self._process__prepare(mtype) + + elif state == PROTOCOL_BIND_EXECUTE: + self._process__bind_execute(mtype) + + elif state == PROTOCOL_BIND_EXECUTE_MANY: + self._process__bind_execute_many(mtype) + + elif state == PROTOCOL_EXECUTE: + self._process__bind_execute(mtype) + + elif state == PROTOCOL_BIND: + self._process__bind(mtype) + + elif state == PROTOCOL_CLOSE_STMT_PORTAL: + self._process__close_stmt_portal(mtype) + + elif state == PROTOCOL_SIMPLE_QUERY: + self._process__simple_query(mtype) + + elif state == PROTOCOL_ERROR_CONSUME: + # Error in protocol (on asyncpg side); + # discard all messages until sync message + + if mtype == b'Z': + # Sync point, self to push the result + if self.result_type != RESULT_FAILED: + self.result_type = RESULT_FAILED + self.result = RuntimeError( + 'unknown error in protocol implementation') + + self._push_result() + + else: + self.buffer.consume_message() + + else: + raise RuntimeError( + 'protocol is in an unknown state {}'.format(state)) + + except Exception as ex: + self.result_type = RESULT_FAILED + self.result = ex + + if mtype == b'Z': + self._push_result() + else: + self.state = PROTOCOL_ERROR_CONSUME + + finally: + if self._skip_discard: + self._skip_discard = False + else: + self.buffer.discard_message() + + cdef _process__auth(self, char mtype): + if mtype == b'R': + # Authentication... + self._parse_msg_authentication() + if self.result_type != RESULT_OK: + self.con_status = CONNECTION_BAD + self._push_result() + self.transport.close() + + elif self.auth_msg is not None: + # Server wants us to send auth data, so do that. + self._write(self.auth_msg) + self.auth_msg = None + + elif mtype == b'K': + # BackendKeyData + self._parse_msg_backend_key_data() + + elif mtype == b'E': + # ErrorResponse + self.con_status = CONNECTION_BAD + self._parse_msg_error_response(True) + self._push_result() + + elif mtype == b'Z': + # ReadyForQuery + self._parse_msg_ready_for_query() + self.con_status = CONNECTION_OK + self._push_result() + + cdef _process__prepare(self, char mtype): + if mtype == b't': + # Parameters description + self.result_param_desc = self.buffer.consume_message().as_bytes() + + elif mtype == b'1': + # ParseComplete + self.buffer.consume_message() + + elif mtype == b'T': + # Row description + self.result_row_desc = self.buffer.consume_message().as_bytes() + + elif mtype == b'E': + # ErrorResponse + self._parse_msg_error_response(True) + + elif mtype == b'Z': + # ReadyForQuery + self._parse_msg_ready_for_query() + self._push_result() + + elif mtype == b'n': + # NoData + self.buffer.consume_message() + + cdef _process__bind_execute(self, char mtype): + if mtype == b'D': + # DataRow + self._parse_data_msgs() + + elif mtype == b's': + # PortalSuspended + self.buffer.consume_message() + + elif mtype == b'C': + # CommandComplete + self.result_execute_completed = True + self._parse_msg_command_complete() + + elif mtype == b'E': + # ErrorResponse + self._parse_msg_error_response(True) + + elif mtype == b'2': + # BindComplete + self.buffer.consume_message() + + elif mtype == b'Z': + # ReadyForQuery + self._parse_msg_ready_for_query() + self._push_result() + + elif mtype == b'I': + # EmptyQueryResponse + self.buffer.consume_message() + + cdef _process__bind_execute_many(self, char mtype): + cdef WriteBuffer buf + + if mtype == b'D': + # DataRow + self._parse_data_msgs() + + elif mtype == b's': + # PortalSuspended + self.buffer.consume_message() + + elif mtype == b'C': + # CommandComplete + self._parse_msg_command_complete() + + elif mtype == b'E': + # ErrorResponse + self._parse_msg_error_response(True) + + elif mtype == b'2': + # BindComplete + self.buffer.consume_message() + + elif mtype == b'Z': + # ReadyForQuery + self._parse_msg_ready_for_query() + if self.result_type == RESULT_FAILED: + self._push_result() + else: + try: + buf = next(self._execute_iter) + except StopIteration: + self._push_result() + else: + # Next iteration over the executemany() arg sequence + self._send_bind_message( + self._execute_portal_name, self._execute_stmt_name, + buf, 0) + + elif mtype == b'I': + # EmptyQueryResponse + self.buffer.consume_message() + + cdef _process__bind(self, char mtype): + if mtype == b'E': + # ErrorResponse + self._parse_msg_error_response(True) + + elif mtype == b'2': + # BindComplete + self.buffer.consume_message() + + elif mtype == b'Z': + # ReadyForQuery + self._parse_msg_ready_for_query() + self._push_result() + + cdef _process__close_stmt_portal(self, char mtype): + if mtype == b'E': + # ErrorResponse + self._parse_msg_error_response(True) + + elif mtype == b'3': + # CloseComplete + self.buffer.consume_message() + + elif mtype == b'Z': + # ReadyForQuery + self._parse_msg_ready_for_query() + self._push_result() + + cdef _process__simple_query(self, char mtype): + if mtype in {b'D', b'I', b'N', b'T'}: + # 'D' - DataRow + # 'I' - EmptyQueryResponse + # 'N' - NoticeResponse + # 'T' - RowDescription + self.buffer.consume_message() + + elif mtype == b'E': + # ErrorResponse + self._parse_msg_error_response(True) + + elif mtype == b'Z': + # ReadyForQuery + self._parse_msg_ready_for_query() + self._push_result() + + elif mtype == b'C': + # CommandComplete + self._parse_msg_command_complete() + + else: + # We don't really care about COPY IN etc + self.buffer.consume_message() + + cdef _parse_msg_command_complete(self): + cdef: + char* cbuf + ssize_t cbuf_len + + cbuf = self.buffer.try_consume_message(&cbuf_len) + if cbuf != NULL and cbuf_len > 0: + msg = cpython.PyBytes_FromStringAndSize(cbuf, cbuf_len - 1) + else: + msg = self.buffer.read_cstr() + self.result_status_msg = msg + + cdef _parse_data_msgs(self): + cdef: + ReadBuffer buf = self.buffer + list rows + decode_row_method decoder = self._decode_row + + char* cbuf + ssize_t cbuf_len + object row + Memory mem + + if ASYNCPG_DEBUG: + if buf.get_message_type() != b'D': + raise RuntimeError( + '_parse_data_msgs: first message is not "D"') + + if self._discard_data: + while True: + buf.consume_message() + if not buf.has_message() or buf.get_message_type() != b'D': + self._skip_discard = True + return + + if ASYNCPG_DEBUG: + if type(self.result) is not list: + raise RuntimeError( + '_parse_data_msgs: result is not a list, but {!r}'. + format(self.result)) + + rows = self.result + while True: + cbuf = buf.try_consume_message(&cbuf_len) + if cbuf != NULL: + row = decoder(self, cbuf, cbuf_len) + else: + mem = buf.consume_message() + row = decoder(self, mem.buf, mem.length) + + cpython.PyList_Append(rows, row) + + if not buf.has_message() or buf.get_message_type() != b'D': + self._skip_discard = True + return + + cdef _parse_msg_backend_key_data(self): + self.backend_pid = self.buffer.read_int32() + self.backend_secret = self.buffer.read_int32() + + cdef _parse_msg_parameter_status(self): + name = self.buffer.read_cstr() + name = name.decode(self.encoding) + + val = self.buffer.read_cstr() + val = val.decode(self.encoding) + + self._set_server_parameter(name, val) + + cdef _parse_msg_notification(self): + pid = self.buffer.read_int32() + channel = self.buffer.read_cstr().decode(self.encoding) + payload = self.buffer.read_cstr().decode(self.encoding) + self._on_notification(pid, channel, payload) + + cdef _parse_msg_authentication(self): + cdef: + int32_t status + bytes md5_salt + + status = self.buffer.read_int32() + + if status == AUTH_SUCCESSFUL: + # AuthenticationOk + self.result_type = RESULT_OK + + elif status == AUTH_REQUIRED_PASSWORD: + # AuthenticationCleartextPassword + self.result_type = RESULT_OK + self.auth_msg = self._auth_password_message_cleartext() + + elif status == AUTH_REQUIRED_PASSWORDMD5: + # AuthenticationMD5Password + # Note: MD5 salt is passed as a four-byte sequence + md5_salt = cpython.PyBytes_FromStringAndSize( + self.buffer.read_bytes(4), 4) + self.auth_msg = self._auth_password_message_md5(md5_salt) + + elif status in (AUTH_REQUIRED_KERBEROS, AUTH_REQUIRED_SCMCRED, + AUTH_REQUIRED_GSS, AUTH_REQUIRED_GSS_CONTINUE, + AUTH_REQUIRED_SSPI): + self.result_type = RESULT_FAILED + self.result = apg_exc.InterfaceError( + 'unsupported authentication method requested by the ' + 'server: {!r}'.format(AUTH_METHOD_NAME[status])) + + else: + self.result_type = RESULT_FAILED + self.result = apg_exc.InterfaceError( + 'unsupported authentication method requested by the ' + 'server: {}'.format(status)) + + self.buffer.consume_message() + + cdef _auth_password_message_cleartext(self): + cdef: + WriteBuffer msg + + msg = WriteBuffer.new_message(b'p') + msg.write_bytestring(self.password.encode('ascii')) + msg.end_message() + + return msg + + cdef _auth_password_message_md5(self, bytes salt): + cdef: + WriteBuffer msg + + msg = WriteBuffer.new_message(b'p') + + # 'md5' + md5(md5(password + username) + salt)) + userpass = ((self.password or '') + (self.user or '')).encode('ascii') + hash = hashlib_md5(hashlib_md5(userpass).hexdigest().\ + encode('ascii') + salt).hexdigest().encode('ascii') + + msg.write_bytestring(b'md5' + hash) + msg.end_message() + + return msg + + cdef _parse_msg_ready_for_query(self): + cdef char status = self.buffer.read_byte() + + if status == b'I': + self.xact_status = PQTRANS_IDLE + elif status == b'T': + self.xact_status = PQTRANS_INTRANS + elif status == b'E': + self.xact_status = PQTRANS_INERROR + else: + self.xact_status = PQTRANS_UNKNOWN + + cdef _parse_msg_error_response(self, is_error): + cdef: + char code + bytes message + dict parsed = {} + + while True: + code = self.buffer.read_byte() + if code == 0: + break + + message = self.buffer.read_cstr() + + parsed[chr(code)] = message.decode() + + if is_error: + self.result_type = RESULT_FAILED + self.result = parsed + + cdef _push_result(self): + try: + self._on_result() + finally: + self._set_state(PROTOCOL_IDLE) + self._reset_result() + + cdef _reset_result(self): + self.result_type = RESULT_OK + self.result = None + self.result_param_desc = None + self.result_row_desc = None + self.result_status_msg = None + self.result_execute_completed = False + self._discard_data = False + + cdef _set_state(self, ProtocolState new_state): + if new_state == PROTOCOL_IDLE: + if self.state == PROTOCOL_FAILED: + raise RuntimeError( + 'cannot switch to "idle" state; ' + 'protocol is in the "failed" state') + elif self.state == PROTOCOL_IDLE: + raise RuntimeError( + 'protocol is already in the "idle" state') + else: + self.state = new_state + + elif new_state == PROTOCOL_FAILED: + self.state = PROTOCOL_FAILED + + else: + if self.state == PROTOCOL_IDLE: + self.state = new_state + + elif self.state == PROTOCOL_FAILED: + raise RuntimeError( + 'cannot switch to state {}; ' + 'protocol is in the "failed" state'.format(new_state)) + else: + raise RuntimeError( + 'cannot switch to state {}; ' + 'another operation ({}) is in progress'.format( + new_state, self.state)) + + cdef _ensure_connected(self): + if self.con_status != CONNECTION_OK: + raise RuntimeError('not connected') + + cdef WriteBuffer _build_bind_message(self, str portal_name, + str stmt_name, + WriteBuffer bind_data): + cdef WriteBuffer buf + + buf = WriteBuffer.new_message(b'B') + buf.write_str(portal_name, self.encoding) + buf.write_str(stmt_name, self.encoding) + + # Arguments + buf.write_buffer(bind_data) + + buf.end_message() + return buf + + # API for subclasses + + cdef _connect(self): + cdef: + WriteBuffer buf + WriteBuffer outbuf + + if self.con_status != CONNECTION_BAD: + raise RuntimeError('already connected') + + self._set_state(PROTOCOL_AUTH) + self.con_status = CONNECTION_STARTED + + # Assemble a startup message + buf = WriteBuffer() + + # protocol version + buf.write_int16(3) + buf.write_int16(0) + + buf.write_bytestring(b'client_encoding') + buf.write_bytestring("'{}'".format(self.encoding).encode('ascii')) + + for param in self.con_args: + if param == 'password': + continue + buf.write_str(param, self.encoding) + buf.write_str(self.con_args[param], self.encoding) + + buf.write_bytestring(b'') + + # Send the buffer + outbuf = WriteBuffer() + outbuf.write_int32(buf.len() + 4) + outbuf.write_buffer(buf) + self._write(outbuf) + + cdef _prepare(self, str stmt_name, str query): + cdef: + WriteBuffer packet + WriteBuffer buf + + self._ensure_connected() + self._set_state(PROTOCOL_PREPARE) + + packet = WriteBuffer.new() + + buf = WriteBuffer.new_message(b'P') + buf.write_str(stmt_name, self.encoding) + buf.write_str(query, self.encoding) + buf.write_int16(0) + buf.end_message() + packet.write_buffer(buf) + + buf = WriteBuffer.new_message(b'D') + buf.write_byte(b'S') + buf.write_str(stmt_name, self.encoding) + buf.end_message() + packet.write_buffer(buf) + + packet.write_bytes(SYNC_MESSAGE) + + self.transport.write(memoryview(packet)) + + cdef _send_bind_message(self, str portal_name, str stmt_name, + WriteBuffer bind_data, int32_t limit): + + cdef WriteBuffer buf + + buf = self._build_bind_message(portal_name, stmt_name, bind_data) + self._write(buf) + + buf = WriteBuffer.new_message(b'E') + buf.write_str(portal_name, self.encoding) # name of the portal + buf.write_int32(limit) # number of rows to return; 0 - all + buf.end_message() + self._write(buf) + + self._write_sync_message() + + cdef _bind_execute(self, str portal_name, str stmt_name, + WriteBuffer bind_data, int32_t limit): + + cdef WriteBuffer buf + + self._ensure_connected() + self._set_state(PROTOCOL_BIND_EXECUTE) + + self.result = [] + + self._send_bind_message(portal_name, stmt_name, bind_data, limit) + + cdef _bind_execute_many(self, str portal_name, str stmt_name, + object bind_data): + + cdef WriteBuffer buf + + self._ensure_connected() + self._set_state(PROTOCOL_BIND_EXECUTE_MANY) + + self.result = None + self._discard_data = True + self._execute_iter = bind_data + self._execute_portal_name = portal_name + self._execute_stmt_name = stmt_name + + try: + buf = next(bind_data) + except StopIteration: + self._push_result() + else: + self._send_bind_message(portal_name, stmt_name, buf, 0) + + cdef _execute(self, str portal_name, int32_t limit): + cdef WriteBuffer buf + + self._ensure_connected() + self._set_state(PROTOCOL_EXECUTE) + + self.result = [] + + buf = WriteBuffer.new_message(b'E') + buf.write_str(portal_name, self.encoding) # name of the portal + buf.write_int32(limit) # number of rows to return; 0 - all + buf.end_message() + self._write(buf) + self._write_sync_message() + + cdef _bind(self, str portal_name, str stmt_name, + WriteBuffer bind_data): + + cdef WriteBuffer buf + + self._ensure_connected() + self._set_state(PROTOCOL_BIND) + + buf = self._build_bind_message(portal_name, stmt_name, bind_data) + self._write(buf) + self._write_sync_message() + + cdef _close(self, str name, bint is_portal): + cdef WriteBuffer buf + + self._ensure_connected() + self._set_state(PROTOCOL_CLOSE_STMT_PORTAL) + + buf = WriteBuffer.new_message(b'C') + + if is_portal: + buf.write_byte(b'P') + else: + buf.write_byte(b'S') + + buf.write_str(name, self.encoding) + buf.end_message() + self._write(buf) + + self._write_sync_message() + + cdef _simple_query(self, str query): + cdef WriteBuffer buf + self._ensure_connected() + self._set_state(PROTOCOL_SIMPLE_QUERY) + buf = WriteBuffer.new_message(b'Q') + buf.write_str(query, self.encoding) + buf.end_message() + self._write(buf) + + cdef _terminate(self): + cdef WriteBuffer buf + self._ensure_connected() + buf = WriteBuffer.new_message(b'X') + buf.end_message() + self._write(buf) + + cdef _decode_row(self, const char* buf, ssize_t buf_len): + pass + + cdef _set_server_parameter(self, name, val): + pass + + cdef _on_result(self): + pass + + cdef _on_notification(self, pid, channel, payload): + pass + + cdef _on_connection_lost(self, exc): + pass + + # asyncio callbacks: + + def data_received(self, data): + self.buffer.feed_data(data) + self._read_server_messages() + + def connection_made(self, transport): + self.transport = transport + + sock = transport.get_extra_info('socket') + if (sock is not None and + (not hasattr(socket, 'AF_UNIX') + or sock.family != socket.AF_UNIX)): + sock.setsockopt(socket.IPPROTO_TCP, + socket.TCP_NODELAY, 1) + + try: + self._connect() + except Exception as ex: + transport.abort() + self.con_status = CONNECTION_BAD + self._set_state(PROTOCOL_FAILED) + self._on_error(ex) + + def connection_lost(self, exc): + self.con_status = CONNECTION_BAD + self._set_state(PROTOCOL_FAILED) + self._on_connection_lost(exc) + + +cdef bytes SYNC_MESSAGE = bytes(WriteBuffer.new_message(b'S').end_message()) diff --git a/asyncpg/protocol/debug.h b/asyncpg/protocol/debug.h new file mode 100644 index 0000000..31df2df --- /dev/null +++ b/asyncpg/protocol/debug.h @@ -0,0 +1,3 @@ +#ifndef ASYNCPG_DEBUG +#define ASYNCPG_DEBUG 0 +#endif diff --git a/asyncpg/protocol/debug.pxd b/asyncpg/protocol/debug.pxd new file mode 100644 index 0000000..ce3c61e --- /dev/null +++ b/asyncpg/protocol/debug.pxd @@ -0,0 +1,3 @@ +cdef extern from "debug.h": + + cdef int ASYNCPG_DEBUG diff --git a/asyncpg/protocol/encodings.pyx b/asyncpg/protocol/encodings.pyx new file mode 100644 index 0000000..baeba90 --- /dev/null +++ b/asyncpg/protocol/encodings.pyx @@ -0,0 +1,63 @@ +# Copyright (C) 2016-present the ayncpg authors and contributors +# +# +# This module is part of asyncpg and is released under +# the Apache 2.0 License: http://www.apache.org/licenses/LICENSE-2.0 + + +'''Map PostgreSQL encoding names to Python encoding names + +https://www.postgresql.org/docs/current/static/multibyte.html#CHARSET-TABLE +''' + +cdef dict ENCODINGS_MAP = { + 'abc': 'cp1258', + 'alt': 'cp866', + 'euc_cn': 'euccn', + 'euc_jp': 'eucjp', + 'euc_kr': 'euckr', + 'koi8r': 'koi8_r', + 'koi8u': 'koi8_u', + 'shift_jis_2004': 'euc_jis_2004', + 'sjis': 'shift_jis', + 'sql_ascii': 'ascii', + 'vscii': 'cp1258', + 'tcvn': 'cp1258', + 'tcvn5712': 'cp1258', + 'unicode': 'utf_8', + 'win': 'cp1521', + 'win1250': 'cp1250', + 'win1251': 'cp1251', + 'win1252': 'cp1252', + 'win1253': 'cp1253', + 'win1254': 'cp1254', + 'win1255': 'cp1255', + 'win1256': 'cp1256', + 'win1257': 'cp1257', + 'win1258': 'cp1258', + 'win866': 'cp866', + 'win874': 'cp874', + 'win932': 'cp932', + 'win936': 'cp936', + 'win949': 'cp949', + 'win950': 'cp950', + 'windows1250': 'cp1250', + 'windows1251': 'cp1251', + 'windows1252': 'cp1252', + 'windows1253': 'cp1253', + 'windows1254': 'cp1254', + 'windows1255': 'cp1255', + 'windows1256': 'cp1256', + 'windows1257': 'cp1257', + 'windows1258': 'cp1258', + 'windows866': 'cp866', + 'windows874': 'cp874', + 'windows932': 'cp932', + 'windows936': 'cp936', + 'windows949': 'cp949', + 'windows950': 'cp950', +} + + +cdef get_python_encoding(pg_encoding): + return ENCODINGS_MAP.get(pg_encoding.lower(), pg_encoding.lower()) diff --git a/asyncpg/protocol/hton.pxd b/asyncpg/protocol/hton.pxd new file mode 100644 index 0000000..402a289 --- /dev/null +++ b/asyncpg/protocol/hton.pxd @@ -0,0 +1,84 @@ +# Copyright (C) 2016-present the ayncpg authors and contributors +# +# +# This module is part of asyncpg and is released under +# the Apache 2.0 License: http://www.apache.org/licenses/LICENSE-2.0 + + +from libc.stdint cimport int16_t, int32_t, uint16_t, uint32_t, int64_t, uint64_t + + +IF UNAME_SYSNAME == "Windows": + cdef extern from "winsock2.h": + uint32_t htonl(uint32_t hostlong) + uint16_t htons(uint16_t hostshort) + uint32_t ntohl(uint32_t netlong) + uint16_t ntohs(uint16_t netshort) +ELSE: + cdef extern from "arpa/inet.h": + uint32_t htonl(uint32_t hostlong) + uint16_t htons(uint16_t hostshort) + uint32_t ntohl(uint32_t netlong) + uint16_t ntohs(uint16_t netshort) + + +cdef inline void pack_int16(char* buf, int16_t x): + (buf)[0] = htons(x) + + +cdef inline int16_t unpack_int16(const char* buf): + return ntohs((buf)[0]) + + +cdef inline void pack_int32(char* buf, int32_t x): + (buf)[0] = htonl(x) + + +cdef inline int32_t unpack_int32(const char* buf): + return ntohl((buf)[0]) + + +cdef inline void pack_int64(char* buf, int64_t x): + (buf)[0] = htonl(((x) >> 32)) + (&buf[4])[0] = htonl((x)) + + +cdef inline int64_t unpack_int64(const char* buf): + cdef int64_t hh = unpack_int32(buf) + cdef uint32_t hl = unpack_int32(&buf[4]) + + return (hh << 32) | hl + + +cdef union _floatconv: + uint32_t i + float f + + +cdef inline int32_t pack_float(char* buf, float f): + cdef _floatconv v + v.f = f + pack_int32(buf, v.i) + + +cdef inline float unpack_float(const char* buf): + cdef _floatconv v + v.i = unpack_int32(buf) + return v.f + + +cdef union _doubleconv: + uint64_t i + double f + + +cdef inline int64_t pack_double(char* buf, double f): + cdef _doubleconv v + v.f = f + pack_int64(buf, v.i) + + +cdef inline double unpack_double(const char* buf): + cdef _doubleconv v + v.i = unpack_int64(buf) + return v.f diff --git a/asyncpg/protocol/pgtypes.pxi b/asyncpg/protocol/pgtypes.pxi new file mode 100644 index 0000000..1798323 --- /dev/null +++ b/asyncpg/protocol/pgtypes.pxi @@ -0,0 +1,182 @@ +# Copyright (C) 2016-present the ayncpg authors and contributors +# +# +# This module is part of asyncpg and is released under +# the Apache 2.0 License: http://www.apache.org/licenses/LICENSE-2.0 + + +# GENERATED FROM pg_catalog.pg_type +# DO NOT MODIFY, use tools/generate_type_map.py to update + +DEF INVALIDOID = 0 +DEF MAXBUILTINOID = 9999 +DEF MAXSUPPORTEDOID = 4096 + +DEF BOOLOID = 16 +DEF BYTEAOID = 17 +DEF CHAROID = 18 +DEF NAMEOID = 19 +DEF INT8OID = 20 +DEF INT2OID = 21 +DEF INT4OID = 23 +DEF REGPROCOID = 24 +DEF TEXTOID = 25 +DEF OIDOID = 26 +DEF TIDOID = 27 +DEF XIDOID = 28 +DEF CIDOID = 29 +DEF PG_DDL_COMMANDOID = 32 +DEF JSONOID = 114 +DEF XMLOID = 142 +DEF PG_NODE_TREEOID = 194 +DEF SMGROID = 210 +DEF POINTOID = 600 +DEF LSEGOID = 601 +DEF PATHOID = 602 +DEF BOXOID = 603 +DEF POLYGONOID = 604 +DEF LINEOID = 628 +DEF CIDROID = 650 +DEF FLOAT4OID = 700 +DEF FLOAT8OID = 701 +DEF ABSTIMEOID = 702 +DEF RELTIMEOID = 703 +DEF TINTERVALOID = 704 +DEF UNKNOWNOID = 705 +DEF CIRCLEOID = 718 +DEF MONEYOID = 790 +DEF MACADDROID = 829 +DEF INETOID = 869 +DEF _TEXTOID = 1009 +DEF _OIDOID = 1028 +DEF ACLITEMOID = 1033 +DEF BPCHAROID = 1042 +DEF VARCHAROID = 1043 +DEF DATEOID = 1082 +DEF TIMEOID = 1083 +DEF TIMESTAMPOID = 1114 +DEF TIMESTAMPTZOID = 1184 +DEF INTERVALOID = 1186 +DEF TIMETZOID = 1266 +DEF BITOID = 1560 +DEF VARBITOID = 1562 +DEF NUMERICOID = 1700 +DEF REFCURSOROID = 1790 +DEF REGPROCEDUREOID = 2202 +DEF REGOPEROID = 2203 +DEF REGOPERATOROID = 2204 +DEF REGCLASSOID = 2205 +DEF REGTYPEOID = 2206 +DEF RECORDOID = 2249 +DEF CSTRINGOID = 2275 +DEF ANYOID = 2276 +DEF ANYARRAYOID = 2277 +DEF VOIDOID = 2278 +DEF TRIGGEROID = 2279 +DEF LANGUAGE_HANDLEROID = 2280 +DEF INTERNALOID = 2281 +DEF OPAQUEOID = 2282 +DEF ANYELEMENTOID = 2283 +DEF ANYNONARRAYOID = 2776 +DEF UUIDOID = 2950 +DEF TXID_SNAPSHOTOID = 2970 +DEF FDW_HANDLEROID = 3115 +DEF PG_LSNOID = 3220 +DEF TSM_HANDLEROID = 3310 +DEF ANYENUMOID = 3500 +DEF TSVECTOROID = 3614 +DEF TSQUERYOID = 3615 +DEF GTSVECTOROID = 3642 +DEF REGCONFIGOID = 3734 +DEF REGDICTIONARYOID = 3769 +DEF JSONBOID = 3802 +DEF ANYRANGEOID = 3831 +DEF EVENT_TRIGGEROID = 3838 +DEF REGNAMESPACEOID = 4089 +DEF REGROLEOID = 4096 + +cdef ARRAY_TYPES = (_TEXTOID, _OIDOID,) + +TYPEMAP = { + ABSTIMEOID: 'abstime', + ACLITEMOID: 'aclitem', + ANYARRAYOID: 'anyarray', + ANYELEMENTOID: 'anyelement', + ANYENUMOID: 'anyenum', + ANYNONARRAYOID: 'anynonarray', + ANYOID: 'any', + ANYRANGEOID: 'anyrange', + BITOID: 'bit', + BOOLOID: 'bool', + BOXOID: 'box', + BPCHAROID: 'bpchar', + BYTEAOID: 'bytea', + CHAROID: 'char', + CIDOID: 'cid', + CIDROID: 'cidr', + CIRCLEOID: 'circle', + CSTRINGOID: 'cstring', + DATEOID: 'date', + EVENT_TRIGGEROID: 'event_trigger', + FDW_HANDLEROID: 'fdw_handler', + FLOAT4OID: 'float4', + FLOAT8OID: 'float8', + GTSVECTOROID: 'gtsvector', + INETOID: 'inet', + INT2OID: 'int2', + INT4OID: 'int4', + INT8OID: 'int8', + INTERNALOID: 'internal', + INTERVALOID: 'interval', + JSONBOID: 'jsonb', + JSONOID: 'json', + LANGUAGE_HANDLEROID: 'language_handler', + LINEOID: 'line', + LSEGOID: 'lseg', + MACADDROID: 'macaddr', + MONEYOID: 'money', + NAMEOID: 'name', + NUMERICOID: 'numeric', + OIDOID: 'oid', + OPAQUEOID: 'opaque', + PATHOID: 'path', + PG_DDL_COMMANDOID: 'pg_ddl_command', + PG_LSNOID: 'pg_lsn', + PG_NODE_TREEOID: 'pg_node_tree', + POINTOID: 'point', + POLYGONOID: 'polygon', + RECORDOID: 'record', + REFCURSOROID: 'refcursor', + REGCLASSOID: 'regclass', + REGCONFIGOID: 'regconfig', + REGDICTIONARYOID: 'regdictionary', + REGNAMESPACEOID: 'regnamespace', + REGOPERATOROID: 'regoperator', + REGOPEROID: 'regoper', + REGPROCEDUREOID: 'regprocedure', + REGPROCOID: 'regproc', + REGROLEOID: 'regrole', + REGTYPEOID: 'regtype', + RELTIMEOID: 'reltime', + SMGROID: 'smgr', + TEXTOID: 'text', + TIDOID: 'tid', + TIMEOID: 'time', + TIMESTAMPOID: 'timestamp', + TIMESTAMPTZOID: 'timestamptz', + TIMETZOID: 'timetz', + TINTERVALOID: 'tinterval', + TRIGGEROID: 'trigger', + TSM_HANDLEROID: 'tsm_handler', + TSQUERYOID: 'tsquery', + TSVECTOROID: 'tsvector', + TXID_SNAPSHOTOID: 'txid_snapshot', + UNKNOWNOID: 'unknown', + UUIDOID: 'uuid', + VARBITOID: 'varbit', + VARCHAROID: 'varchar', + VOIDOID: 'void', + XIDOID: 'xid', + XMLOID: 'xml', + _OIDOID: 'oid[]', + _TEXTOID: 'text[]'} diff --git a/asyncpg/protocol/prepared_stmt.pxd b/asyncpg/protocol/prepared_stmt.pxd new file mode 100644 index 0000000..f71b599 --- /dev/null +++ b/asyncpg/protocol/prepared_stmt.pxd @@ -0,0 +1,37 @@ +# Copyright (C) 2016-present the ayncpg authors and contributors +# +# +# This module is part of asyncpg and is released under +# the Apache 2.0 License: http://www.apache.org/licenses/LICENSE-2.0 + + +cdef class PreparedStatementState: + cdef: + readonly str name + readonly str query + readonly bint closed + readonly int refs + + FastReadBuffer buffer + + list row_desc + list parameters_desc + + BaseProtocol protocol + ConnectionSettings settings + + int16_t args_num + bint have_text_args + tuple args_codecs + + int16_t cols_num + object cols_desc + bint have_text_cols + tuple rows_codecs + + cdef _encode_bind_msg(self, args) + cdef _ensure_rows_decoder(self) + cdef _ensure_args_encoder(self) + cdef _set_row_desc(self, object desc) + cdef _set_args_desc(self, object desc) + cdef _decode_row(self, const char* cbuf, ssize_t buf_len) diff --git a/asyncpg/protocol/prepared_stmt.pyx b/asyncpg/protocol/prepared_stmt.pyx new file mode 100644 index 0000000..0da8e50 --- /dev/null +++ b/asyncpg/protocol/prepared_stmt.pyx @@ -0,0 +1,313 @@ +# Copyright (C) 2016-present the ayncpg authors and contributors +# +# +# This module is part of asyncpg and is released under +# the Apache 2.0 License: http://www.apache.org/licenses/LICENSE-2.0 + + +@cython.final +cdef class PreparedStatementState: + + def __cinit__(self, str name, str query, BaseProtocol protocol): + self.name = name + self.query = query + self.protocol = protocol + self.settings = protocol.settings + self.row_desc = self.parameters_desc = None + self.args_codecs = self.rows_codecs = None + self.args_num = self.cols_num = 0 + self.cols_desc = None + self.closed = False + self.refs = 0 + self.buffer = FastReadBuffer.new() + + def _get_parameters(self): + cdef Codec codec + + result = [] + for oid in self.parameters_desc: + codec = self.settings.get_data_codec(oid) + if codec is None: + raise RuntimeError + result.append(apg_types.Type( + oid, codec.name, codec.kind, codec.schema)) + + return tuple(result) + + def _get_attributes(self): + cdef Codec codec + + result = [] + for d in self.row_desc: + name = d[0] + oid = d[3] + + codec = self.settings.get_data_codec(oid) + if codec is None: + raise RuntimeError + + name = name.decode(self.settings._encoding) + + result.append( + apg_types.Attribute(name, + apg_types.Type(oid, codec.name, codec.kind, codec.schema))) + + return tuple(result) + + def _init_types(self): + cdef: + Codec codec + set result = set() + + if self.parameters_desc: + for p_oid in self.parameters_desc: + codec = self.settings.get_data_codec(p_oid) + if codec is None or not codec.has_encoder(): + result.add(p_oid) + + if self.row_desc: + for rdesc in self.row_desc: + codec = self.settings.get_data_codec((rdesc[3])) + if codec is None or not codec.has_decoder(): + result.add(rdesc[3]) + + if len(result): + return result + else: + return True + + def attach(self): + self.refs += 1 + + def detach(self): + self.refs -= 1 + + def mark_closed(self): + self.closed = True + + cdef _encode_bind_msg(self, args): + cdef: + int idx + WriteBuffer writer + Codec codec + + self._ensure_args_encoder() + self._ensure_rows_decoder() + + writer = WriteBuffer.new() + + if self.args_num != len(args): + raise ValueError( + 'number of arguments ({}) does not match ' + 'number of parameters ({})'.format( + len(args), self.args_num)) + + if self.have_text_args: + writer.write_int16(self.args_num) + for idx from 0 <= idx < self.args_num: + codec = (self.args_codecs[idx]) + writer.write_int16(codec.format) + else: + # All arguments are in binary format + writer.write_int32(0x00010001) + + writer.write_int16(self.args_num) + + for idx from 0 <= idx < self.args_num: + arg = args[idx] + if arg is None: + writer.write_int32(-1) + else: + codec = (self.args_codecs[idx]) + codec.encode(self.settings, writer, arg) + + if self.have_text_cols: + writer.write_int16(self.cols_num) + for idx from 0 <= idx < self.cols_num: + codec = (self.rows_codecs[idx]) + writer.write_int16(codec.format) + else: + # All columns are in binary format + writer.write_int32(0x00010001) + + return writer + + cdef _ensure_rows_decoder(self): + cdef: + list cols_names + object cols_mapping + tuple row + int oid + Codec codec + list codecs + + if self.cols_desc is not None: + return + + if self.cols_num == 0: + self.cols_desc = record.ApgRecordDesc_New({}, ()) + return + + cols_mapping = collections.OrderedDict() + cols_names = [] + codecs = [] + for i from 0 <= i < self.cols_num: + row = self.row_desc[i] + col_name = row[0].decode(self.settings._encoding) + cols_mapping[col_name] = i + cols_names.append(col_name) + oid = row[3] + codec = self.settings.get_data_codec(oid) + if codec is None or not codec.has_decoder(): + raise RuntimeError('no decoder for OID {}'.format(oid)) + if not codec.is_binary(): + self.have_text_cols = True + + codecs.append(codec) + + self.cols_desc = record.ApgRecordDesc_New( + cols_mapping, tuple(cols_names)) + + self.rows_codecs = tuple(codecs) + + cdef _ensure_args_encoder(self): + cdef: + int p_oid + Codec codec + list codecs = [] + + if self.args_num == 0 or self.args_codecs is not None: + return + + for i from 0 <= i < self.args_num: + p_oid = self.parameters_desc[i] + codec = self.settings.get_data_codec(p_oid) + if codec is None or not codec.has_encoder(): + raise RuntimeError('no encoder for OID {}'.format(p_oid)) + if codec.type not in {}: + self.have_text_args = True + + codecs.append(codec) + + self.args_codecs = tuple(codecs) + + cdef _set_row_desc(self, object desc): + self.row_desc = _decode_row_desc(desc) + self.cols_num = (len(self.row_desc)) + + cdef _set_args_desc(self, object desc): + self.parameters_desc = _decode_parameters_desc(desc) + self.args_num = (len(self.parameters_desc)) + + cdef _decode_row(self, const char* cbuf, ssize_t buf_len): + cdef: + Codec codec + int16_t fnum + int32_t flen + object dec_row + tuple rows_codecs = self.rows_codecs + ConnectionSettings settings = self.settings + int32_t i + FastReadBuffer rbuf = self.buffer + ssize_t bl + + rbuf.buf = cbuf + rbuf.len = buf_len + + fnum = hton.unpack_int16(rbuf.read(2)) + + if fnum != self.cols_num: + raise RuntimeError( + 'number of columns in result ({}) is ' + 'different from what was described ({})'.format( + fnum, self.cols_num)) + + if rows_codecs is None or len(rows_codecs) < fnum: + if fnum > 0: + # It's OK to have no rows_codecs for empty records + raise RuntimeError('invalid rows_codecs') + + dec_row = record.ApgRecord_New(self.cols_desc, fnum) + for i in range(fnum): + flen = hton.unpack_int32(rbuf.read(4)) + + if flen == -1: + val = None + else: + # Clamp buffer size to that of the reported field length + # to make sure that codecs can rely on read_all() working + # properly. + bl = rbuf.len + if flen > bl: + # Check for overflow + rbuf._raise_ins_err(flen, bl) + rbuf.len = flen + codec = cpython.PyTuple_GET_ITEM(rows_codecs, i) + val = codec.decode(settings, rbuf) + if rbuf.len != 0: + raise BufferError( + 'unexpected trailing {} bytes in buffer'.format( + rbuf.len)) + rbuf.len = bl - flen + + cpython.Py_INCREF(val) + record.ApgRecord_SET_ITEM(dec_row, i, val) + + if rbuf.len != 0: + raise BufferError('unexpected trailing {} bytes in buffer'.format( + rbuf.len)) + + return dec_row + + +cdef _decode_parameters_desc(object desc): + cdef: + ReadBuffer reader + int16_t nparams + int32_t p_oid + list result = [] + + reader = ReadBuffer.new_message_parser(desc) + nparams = reader.read_int16() + + for i from 0 <= i < nparams: + p_oid = reader.read_int32() + result.append(p_oid) + + return result + + +cdef _decode_row_desc(object desc): + cdef: + ReadBuffer reader + + int16_t nfields + + bytes f_name + int32_t f_table_oid + int16_t f_column_num + int32_t f_dt_oid + int16_t f_dt_size + int32_t f_dt_mod + int16_t f_format + + list result + + reader = ReadBuffer.new_message_parser(desc) + nfields = reader.read_int16() + result = [] + + for i from 0 <= i < nfields: + f_name = reader.read_cstr() + f_table_oid = reader.read_int32() + f_column_num = reader.read_int16() + f_dt_oid = reader.read_int32() + f_dt_size = reader.read_int16() + f_dt_mod = reader.read_int32() + f_format = reader.read_int16() + + result.append( + (f_name, f_table_oid, f_column_num, f_dt_oid, + f_dt_size, f_dt_mod, f_format)) + + return result diff --git a/asyncpg/protocol/protocol.c b/asyncpg/protocol/protocol.c new file mode 100644 index 0000000..27aba80 --- /dev/null +++ b/asyncpg/protocol/protocol.c @@ -0,0 +1,75615 @@ +/* Generated by Cython 0.25.2 */ + +/* BEGIN: Cython Metadata +{ + "distutils": { + "depends": [ + "asyncpg/protocol/debug.h" + ], + "extra_compile_args": [ + "-O2", + "-Wall", + "-Wsign-compare", + "-Wconversion" + ] + }, + "module_name": "asyncpg.protocol.protocol" +} +END: Cython Metadata */ + +#define PY_SSIZE_T_CLEAN +#include "Python.h" +#ifndef Py_PYTHON_H + #error Python headers needed to compile C extensions, please install development version of Python. +#elif PY_VERSION_HEX < 0x02060000 || (0x03000000 <= PY_VERSION_HEX && PY_VERSION_HEX < 0x03020000) + #error Cython requires Python 2.6+ or Python 3.2+. +#else +#define CYTHON_ABI "0_25_2" +#include +#ifndef offsetof + #define offsetof(type, member) ( (size_t) & ((type*)0) -> member ) +#endif +#if !defined(WIN32) && !defined(MS_WINDOWS) + #ifndef __stdcall + #define __stdcall + #endif + #ifndef __cdecl + #define __cdecl + #endif + #ifndef __fastcall + #define __fastcall + #endif +#endif +#ifndef DL_IMPORT + #define DL_IMPORT(t) t +#endif +#ifndef DL_EXPORT + #define DL_EXPORT(t) t +#endif +#ifndef HAVE_LONG_LONG + #if PY_VERSION_HEX >= 0x03030000 || (PY_MAJOR_VERSION == 2 && PY_VERSION_HEX >= 0x02070000) + #define HAVE_LONG_LONG + #endif +#endif +#ifndef PY_LONG_LONG + #define PY_LONG_LONG LONG_LONG +#endif +#ifndef Py_HUGE_VAL + #define Py_HUGE_VAL HUGE_VAL +#endif +#ifdef PYPY_VERSION + #define CYTHON_COMPILING_IN_PYPY 1 + #define CYTHON_COMPILING_IN_PYSTON 0 + #define CYTHON_COMPILING_IN_CPYTHON 0 + #undef CYTHON_USE_TYPE_SLOTS + #define CYTHON_USE_TYPE_SLOTS 0 + #undef CYTHON_USE_ASYNC_SLOTS + #define CYTHON_USE_ASYNC_SLOTS 0 + #undef CYTHON_USE_PYLIST_INTERNALS + #define CYTHON_USE_PYLIST_INTERNALS 0 + #undef CYTHON_USE_UNICODE_INTERNALS + #define CYTHON_USE_UNICODE_INTERNALS 0 + #undef CYTHON_USE_UNICODE_WRITER + #define CYTHON_USE_UNICODE_WRITER 0 + #undef CYTHON_USE_PYLONG_INTERNALS + #define CYTHON_USE_PYLONG_INTERNALS 0 + #undef CYTHON_AVOID_BORROWED_REFS + #define CYTHON_AVOID_BORROWED_REFS 1 + #undef CYTHON_ASSUME_SAFE_MACROS + #define CYTHON_ASSUME_SAFE_MACROS 0 + #undef CYTHON_UNPACK_METHODS + #define CYTHON_UNPACK_METHODS 0 + #undef CYTHON_FAST_THREAD_STATE + #define CYTHON_FAST_THREAD_STATE 0 + #undef CYTHON_FAST_PYCALL + #define CYTHON_FAST_PYCALL 0 +#elif defined(PYSTON_VERSION) + #define CYTHON_COMPILING_IN_PYPY 0 + #define CYTHON_COMPILING_IN_PYSTON 1 + #define CYTHON_COMPILING_IN_CPYTHON 0 + #ifndef CYTHON_USE_TYPE_SLOTS + #define CYTHON_USE_TYPE_SLOTS 1 + #endif + #undef CYTHON_USE_ASYNC_SLOTS + #define CYTHON_USE_ASYNC_SLOTS 0 + #undef CYTHON_USE_PYLIST_INTERNALS + #define CYTHON_USE_PYLIST_INTERNALS 0 + #ifndef CYTHON_USE_UNICODE_INTERNALS + #define CYTHON_USE_UNICODE_INTERNALS 1 + #endif + #undef CYTHON_USE_UNICODE_WRITER + #define CYTHON_USE_UNICODE_WRITER 0 + #undef CYTHON_USE_PYLONG_INTERNALS + #define CYTHON_USE_PYLONG_INTERNALS 0 + #ifndef CYTHON_AVOID_BORROWED_REFS + #define CYTHON_AVOID_BORROWED_REFS 0 + #endif + #ifndef CYTHON_ASSUME_SAFE_MACROS + #define CYTHON_ASSUME_SAFE_MACROS 1 + #endif + #ifndef CYTHON_UNPACK_METHODS + #define CYTHON_UNPACK_METHODS 1 + #endif + #undef CYTHON_FAST_THREAD_STATE + #define CYTHON_FAST_THREAD_STATE 0 + #undef CYTHON_FAST_PYCALL + #define CYTHON_FAST_PYCALL 0 +#else + #define CYTHON_COMPILING_IN_PYPY 0 + #define CYTHON_COMPILING_IN_PYSTON 0 + #define CYTHON_COMPILING_IN_CPYTHON 1 + #ifndef CYTHON_USE_TYPE_SLOTS + #define CYTHON_USE_TYPE_SLOTS 1 + #endif + #if PY_MAJOR_VERSION < 3 + #undef CYTHON_USE_ASYNC_SLOTS + #define CYTHON_USE_ASYNC_SLOTS 0 + #elif !defined(CYTHON_USE_ASYNC_SLOTS) + #define CYTHON_USE_ASYNC_SLOTS 1 + #endif + #if PY_VERSION_HEX < 0x02070000 + #undef CYTHON_USE_PYLONG_INTERNALS + #define CYTHON_USE_PYLONG_INTERNALS 0 + #elif !defined(CYTHON_USE_PYLONG_INTERNALS) + #define CYTHON_USE_PYLONG_INTERNALS 1 + #endif + #ifndef CYTHON_USE_PYLIST_INTERNALS + #define CYTHON_USE_PYLIST_INTERNALS 1 + #endif + #ifndef CYTHON_USE_UNICODE_INTERNALS + #define CYTHON_USE_UNICODE_INTERNALS 1 + #endif + #if PY_VERSION_HEX < 0x030300F0 + #undef CYTHON_USE_UNICODE_WRITER + #define CYTHON_USE_UNICODE_WRITER 0 + #elif !defined(CYTHON_USE_UNICODE_WRITER) + #define CYTHON_USE_UNICODE_WRITER 1 + #endif + #ifndef CYTHON_AVOID_BORROWED_REFS + #define CYTHON_AVOID_BORROWED_REFS 0 + #endif + #ifndef CYTHON_ASSUME_SAFE_MACROS + #define CYTHON_ASSUME_SAFE_MACROS 1 + #endif + #ifndef CYTHON_UNPACK_METHODS + #define CYTHON_UNPACK_METHODS 1 + #endif + #ifndef CYTHON_FAST_THREAD_STATE + #define CYTHON_FAST_THREAD_STATE 1 + #endif + #ifndef CYTHON_FAST_PYCALL + #define CYTHON_FAST_PYCALL 1 + #endif +#endif +#if !defined(CYTHON_FAST_PYCCALL) +#define CYTHON_FAST_PYCCALL (CYTHON_FAST_PYCALL && PY_VERSION_HEX >= 0x030600B1) +#endif +#if CYTHON_USE_PYLONG_INTERNALS + #include "longintrepr.h" + #undef SHIFT + #undef BASE + #undef MASK +#endif +#if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX < 0x02070600 && !defined(Py_OptimizeFlag) + #define Py_OptimizeFlag 0 +#endif +#define __PYX_BUILD_PY_SSIZE_T "n" +#define CYTHON_FORMAT_SSIZE_T "z" +#if PY_MAJOR_VERSION < 3 + #define __Pyx_BUILTIN_MODULE_NAME "__builtin__" + #define __Pyx_PyCode_New(a, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos)\ + PyCode_New(a+k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos) + #define __Pyx_DefaultClassType PyClass_Type +#else + #define __Pyx_BUILTIN_MODULE_NAME "builtins" + #define __Pyx_PyCode_New(a, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos)\ + PyCode_New(a, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos) + #define __Pyx_DefaultClassType PyType_Type +#endif +#ifndef Py_TPFLAGS_CHECKTYPES + #define Py_TPFLAGS_CHECKTYPES 0 +#endif +#ifndef Py_TPFLAGS_HAVE_INDEX + #define Py_TPFLAGS_HAVE_INDEX 0 +#endif +#ifndef Py_TPFLAGS_HAVE_NEWBUFFER + #define Py_TPFLAGS_HAVE_NEWBUFFER 0 +#endif +#ifndef Py_TPFLAGS_HAVE_FINALIZE + #define Py_TPFLAGS_HAVE_FINALIZE 0 +#endif +#ifndef METH_FASTCALL + #define METH_FASTCALL 0x80 + typedef PyObject *(*__Pyx_PyCFunctionFast) (PyObject *self, PyObject **args, + Py_ssize_t nargs, PyObject *kwnames); +#else + #define __Pyx_PyCFunctionFast _PyCFunctionFast +#endif +#if CYTHON_FAST_PYCCALL +#define __Pyx_PyFastCFunction_Check(func)\ + ((PyCFunction_Check(func) && (METH_FASTCALL == (PyCFunction_GET_FLAGS(func) & ~(METH_CLASS | METH_STATIC | METH_COEXIST))))) +#else +#define __Pyx_PyFastCFunction_Check(func) 0 +#endif +#if PY_VERSION_HEX > 0x03030000 && defined(PyUnicode_KIND) + #define CYTHON_PEP393_ENABLED 1 + #define __Pyx_PyUnicode_READY(op) (likely(PyUnicode_IS_READY(op)) ?\ + 0 : _PyUnicode_Ready((PyObject *)(op))) + #define __Pyx_PyUnicode_GET_LENGTH(u) PyUnicode_GET_LENGTH(u) + #define __Pyx_PyUnicode_READ_CHAR(u, i) PyUnicode_READ_CHAR(u, i) + #define __Pyx_PyUnicode_MAX_CHAR_VALUE(u) PyUnicode_MAX_CHAR_VALUE(u) + #define __Pyx_PyUnicode_KIND(u) PyUnicode_KIND(u) + #define __Pyx_PyUnicode_DATA(u) PyUnicode_DATA(u) + #define __Pyx_PyUnicode_READ(k, d, i) PyUnicode_READ(k, d, i) + #define __Pyx_PyUnicode_WRITE(k, d, i, ch) PyUnicode_WRITE(k, d, i, ch) + #define __Pyx_PyUnicode_IS_TRUE(u) (0 != (likely(PyUnicode_IS_READY(u)) ? PyUnicode_GET_LENGTH(u) : PyUnicode_GET_SIZE(u))) +#else + #define CYTHON_PEP393_ENABLED 0 + #define PyUnicode_1BYTE_KIND 1 + #define PyUnicode_2BYTE_KIND 2 + #define PyUnicode_4BYTE_KIND 4 + #define __Pyx_PyUnicode_READY(op) (0) + #define __Pyx_PyUnicode_GET_LENGTH(u) PyUnicode_GET_SIZE(u) + #define __Pyx_PyUnicode_READ_CHAR(u, i) ((Py_UCS4)(PyUnicode_AS_UNICODE(u)[i])) + #define __Pyx_PyUnicode_MAX_CHAR_VALUE(u) ((sizeof(Py_UNICODE) == 2) ? 65535 : 1114111) + #define __Pyx_PyUnicode_KIND(u) (sizeof(Py_UNICODE)) + #define __Pyx_PyUnicode_DATA(u) ((void*)PyUnicode_AS_UNICODE(u)) + #define __Pyx_PyUnicode_READ(k, d, i) ((void)(k), (Py_UCS4)(((Py_UNICODE*)d)[i])) + #define __Pyx_PyUnicode_WRITE(k, d, i, ch) (((void)(k)), ((Py_UNICODE*)d)[i] = ch) + #define __Pyx_PyUnicode_IS_TRUE(u) (0 != PyUnicode_GET_SIZE(u)) +#endif +#if CYTHON_COMPILING_IN_PYPY + #define __Pyx_PyUnicode_Concat(a, b) PyNumber_Add(a, b) + #define __Pyx_PyUnicode_ConcatSafe(a, b) PyNumber_Add(a, b) +#else + #define __Pyx_PyUnicode_Concat(a, b) PyUnicode_Concat(a, b) + #define __Pyx_PyUnicode_ConcatSafe(a, b) ((unlikely((a) == Py_None) || unlikely((b) == Py_None)) ?\ + PyNumber_Add(a, b) : __Pyx_PyUnicode_Concat(a, b)) +#endif +#if CYTHON_COMPILING_IN_PYPY && !defined(PyUnicode_Contains) + #define PyUnicode_Contains(u, s) PySequence_Contains(u, s) +#endif +#if CYTHON_COMPILING_IN_PYPY && !defined(PyByteArray_Check) + #define PyByteArray_Check(obj) PyObject_TypeCheck(obj, &PyByteArray_Type) +#endif +#if CYTHON_COMPILING_IN_PYPY && !defined(PyObject_Format) + #define PyObject_Format(obj, fmt) PyObject_CallMethod(obj, "__format__", "O", fmt) +#endif +#if CYTHON_COMPILING_IN_PYPY && !defined(PyObject_Malloc) + #define PyObject_Malloc(s) PyMem_Malloc(s) + #define PyObject_Free(p) PyMem_Free(p) + #define PyObject_Realloc(p) PyMem_Realloc(p) +#endif +#if CYTHON_COMPILING_IN_PYSTON + #define __Pyx_PyCode_HasFreeVars(co) PyCode_HasFreeVars(co) + #define __Pyx_PyFrame_SetLineNumber(frame, lineno) PyFrame_SetLineNumber(frame, lineno) +#else + #define __Pyx_PyCode_HasFreeVars(co) (PyCode_GetNumFree(co) > 0) + #define __Pyx_PyFrame_SetLineNumber(frame, lineno) (frame)->f_lineno = (lineno) +#endif +#define __Pyx_PyString_FormatSafe(a, b) ((unlikely((a) == Py_None)) ? PyNumber_Remainder(a, b) : __Pyx_PyString_Format(a, b)) +#define __Pyx_PyUnicode_FormatSafe(a, b) ((unlikely((a) == Py_None)) ? PyNumber_Remainder(a, b) : PyUnicode_Format(a, b)) +#if PY_MAJOR_VERSION >= 3 + #define __Pyx_PyString_Format(a, b) PyUnicode_Format(a, b) +#else + #define __Pyx_PyString_Format(a, b) PyString_Format(a, b) +#endif +#if PY_MAJOR_VERSION < 3 && !defined(PyObject_ASCII) + #define PyObject_ASCII(o) PyObject_Repr(o) +#endif +#if PY_MAJOR_VERSION >= 3 + #define PyBaseString_Type PyUnicode_Type + #define PyStringObject PyUnicodeObject + #define PyString_Type PyUnicode_Type + #define PyString_Check PyUnicode_Check + #define PyString_CheckExact PyUnicode_CheckExact +#endif +#if PY_MAJOR_VERSION >= 3 + #define __Pyx_PyBaseString_Check(obj) PyUnicode_Check(obj) + #define __Pyx_PyBaseString_CheckExact(obj) PyUnicode_CheckExact(obj) +#else + #define __Pyx_PyBaseString_Check(obj) (PyString_Check(obj) || PyUnicode_Check(obj)) + #define __Pyx_PyBaseString_CheckExact(obj) (PyString_CheckExact(obj) || PyUnicode_CheckExact(obj)) +#endif +#ifndef PySet_CheckExact + #define PySet_CheckExact(obj) (Py_TYPE(obj) == &PySet_Type) +#endif +#define __Pyx_TypeCheck(obj, type) PyObject_TypeCheck(obj, (PyTypeObject *)type) +#define __Pyx_PyException_Check(obj) __Pyx_TypeCheck(obj, PyExc_Exception) +#if PY_MAJOR_VERSION >= 3 + #define PyIntObject PyLongObject + #define PyInt_Type PyLong_Type + #define PyInt_Check(op) PyLong_Check(op) + #define PyInt_CheckExact(op) PyLong_CheckExact(op) + #define PyInt_FromString PyLong_FromString + #define PyInt_FromUnicode PyLong_FromUnicode + #define PyInt_FromLong PyLong_FromLong + #define PyInt_FromSize_t PyLong_FromSize_t + #define PyInt_FromSsize_t PyLong_FromSsize_t + #define PyInt_AsLong PyLong_AsLong + #define PyInt_AS_LONG PyLong_AS_LONG + #define PyInt_AsSsize_t PyLong_AsSsize_t + #define PyInt_AsUnsignedLongMask PyLong_AsUnsignedLongMask + #define PyInt_AsUnsignedLongLongMask PyLong_AsUnsignedLongLongMask + #define PyNumber_Int PyNumber_Long +#endif +#if PY_MAJOR_VERSION >= 3 + #define PyBoolObject PyLongObject +#endif +#if PY_MAJOR_VERSION >= 3 && CYTHON_COMPILING_IN_PYPY + #ifndef PyUnicode_InternFromString + #define PyUnicode_InternFromString(s) PyUnicode_FromString(s) + #endif +#endif +#if PY_VERSION_HEX < 0x030200A4 + typedef long Py_hash_t; + #define __Pyx_PyInt_FromHash_t PyInt_FromLong + #define __Pyx_PyInt_AsHash_t PyInt_AsLong +#else + #define __Pyx_PyInt_FromHash_t PyInt_FromSsize_t + #define __Pyx_PyInt_AsHash_t PyInt_AsSsize_t +#endif +#if PY_MAJOR_VERSION >= 3 + #define __Pyx_PyMethod_New(func, self, klass) ((self) ? PyMethod_New(func, self) : PyInstanceMethod_New(func)) +#else + #define __Pyx_PyMethod_New(func, self, klass) PyMethod_New(func, self, klass) +#endif +#if CYTHON_USE_ASYNC_SLOTS + #if PY_VERSION_HEX >= 0x030500B1 + #define __Pyx_PyAsyncMethodsStruct PyAsyncMethods + #define __Pyx_PyType_AsAsync(obj) (Py_TYPE(obj)->tp_as_async) + #else + typedef struct { + unaryfunc am_await; + unaryfunc am_aiter; + unaryfunc am_anext; + } __Pyx_PyAsyncMethodsStruct; + #define __Pyx_PyType_AsAsync(obj) ((__Pyx_PyAsyncMethodsStruct*) (Py_TYPE(obj)->tp_reserved)) + #endif +#else + #define __Pyx_PyType_AsAsync(obj) NULL +#endif +#ifndef CYTHON_RESTRICT + #if defined(__GNUC__) + #define CYTHON_RESTRICT __restrict__ + #elif defined(_MSC_VER) && _MSC_VER >= 1400 + #define CYTHON_RESTRICT __restrict + #elif defined (__STDC_VERSION__) && __STDC_VERSION__ >= 199901L + #define CYTHON_RESTRICT restrict + #else + #define CYTHON_RESTRICT + #endif +#endif +#ifndef CYTHON_UNUSED +# if defined(__GNUC__) +# if !(defined(__cplusplus)) || (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)) +# define CYTHON_UNUSED __attribute__ ((__unused__)) +# else +# define CYTHON_UNUSED +# endif +# elif defined(__ICC) || (defined(__INTEL_COMPILER) && !defined(_MSC_VER)) +# define CYTHON_UNUSED __attribute__ ((__unused__)) +# else +# define CYTHON_UNUSED +# endif +#endif +#ifndef CYTHON_MAYBE_UNUSED_VAR +# if defined(__cplusplus) + template void CYTHON_MAYBE_UNUSED_VAR( const T& ) { } +# else +# define CYTHON_MAYBE_UNUSED_VAR(x) (void)(x) +# endif +#endif +#ifndef CYTHON_NCP_UNUSED +# if CYTHON_COMPILING_IN_CPYTHON +# define CYTHON_NCP_UNUSED +# else +# define CYTHON_NCP_UNUSED CYTHON_UNUSED +# endif +#endif +#define __Pyx_void_to_None(void_result) ((void)(void_result), Py_INCREF(Py_None), Py_None) + +#ifndef CYTHON_INLINE + #if defined(__clang__) + #define CYTHON_INLINE __inline__ __attribute__ ((__unused__)) + #elif defined(__GNUC__) + #define CYTHON_INLINE __inline__ + #elif defined(_MSC_VER) + #define CYTHON_INLINE __inline + #elif defined (__STDC_VERSION__) && __STDC_VERSION__ >= 199901L + #define CYTHON_INLINE inline + #else + #define CYTHON_INLINE + #endif +#endif + +#if defined(WIN32) || defined(MS_WINDOWS) + #define _USE_MATH_DEFINES +#endif +#include +#ifdef NAN +#define __PYX_NAN() ((float) NAN) +#else +static CYTHON_INLINE float __PYX_NAN() { + float value; + memset(&value, 0xFF, sizeof(value)); + return value; +} +#endif +#if defined(__CYGWIN__) && defined(_LDBL_EQ_DBL) +#define __Pyx_truncl trunc +#else +#define __Pyx_truncl truncl +#endif + + +#define __PYX_ERR(f_index, lineno, Ln_error) \ +{ \ + __pyx_filename = __pyx_f[f_index]; __pyx_lineno = lineno; __pyx_clineno = __LINE__; goto Ln_error; \ +} + +#if PY_MAJOR_VERSION >= 3 + #define __Pyx_PyNumber_Divide(x,y) PyNumber_TrueDivide(x,y) + #define __Pyx_PyNumber_InPlaceDivide(x,y) PyNumber_InPlaceTrueDivide(x,y) +#else + #define __Pyx_PyNumber_Divide(x,y) PyNumber_TrueDivide(x,y) + #define __Pyx_PyNumber_InPlaceDivide(x,y) PyNumber_InPlaceTrueDivide(x,y) +#endif + +#ifndef __PYX_EXTERN_C + #ifdef __cplusplus + #define __PYX_EXTERN_C extern "C" + #else + #define __PYX_EXTERN_C extern + #endif +#endif + +#define __PYX_HAVE__asyncpg__protocol__protocol +#define __PYX_HAVE_API__asyncpg__protocol__protocol +#include +#include "debug.h" +#include +#include +#include "pythread.h" +#include "record/recordobj.h" +#include "arpa/inet.h" +#include +#ifdef _OPENMP +#include +#endif /* _OPENMP */ + +#ifdef PYREX_WITHOUT_ASSERTIONS +#define CYTHON_WITHOUT_ASSERTIONS +#endif + +typedef struct {PyObject **p; const char *s; const Py_ssize_t n; const char* encoding; + const char is_unicode; const char is_str; const char intern; } __Pyx_StringTabEntry; + +#define __PYX_DEFAULT_STRING_ENCODING_IS_ASCII 0 +#define __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT 0 +#define __PYX_DEFAULT_STRING_ENCODING "" +#define __Pyx_PyObject_FromString __Pyx_PyBytes_FromString +#define __Pyx_PyObject_FromStringAndSize __Pyx_PyBytes_FromStringAndSize +#define __Pyx_uchar_cast(c) ((unsigned char)c) +#define __Pyx_long_cast(x) ((long)x) +#define __Pyx_fits_Py_ssize_t(v, type, is_signed) (\ + (sizeof(type) < sizeof(Py_ssize_t)) ||\ + (sizeof(type) > sizeof(Py_ssize_t) &&\ + likely(v < (type)PY_SSIZE_T_MAX ||\ + v == (type)PY_SSIZE_T_MAX) &&\ + (!is_signed || likely(v > (type)PY_SSIZE_T_MIN ||\ + v == (type)PY_SSIZE_T_MIN))) ||\ + (sizeof(type) == sizeof(Py_ssize_t) &&\ + (is_signed || likely(v < (type)PY_SSIZE_T_MAX ||\ + v == (type)PY_SSIZE_T_MAX))) ) +#if defined (__cplusplus) && __cplusplus >= 201103L + #include + #define __Pyx_sst_abs(value) std::abs(value) +#elif SIZEOF_INT >= SIZEOF_SIZE_T + #define __Pyx_sst_abs(value) abs(value) +#elif SIZEOF_LONG >= SIZEOF_SIZE_T + #define __Pyx_sst_abs(value) labs(value) +#elif defined (_MSC_VER) && defined (_M_X64) + #define __Pyx_sst_abs(value) _abs64(value) +#elif defined (__STDC_VERSION__) && __STDC_VERSION__ >= 199901L + #define __Pyx_sst_abs(value) llabs(value) +#elif defined (__GNUC__) + #define __Pyx_sst_abs(value) __builtin_llabs(value) +#else + #define __Pyx_sst_abs(value) ((value<0) ? -value : value) +#endif +static CYTHON_INLINE char* __Pyx_PyObject_AsString(PyObject*); +static CYTHON_INLINE char* __Pyx_PyObject_AsStringAndSize(PyObject*, Py_ssize_t* length); +#define __Pyx_PyByteArray_FromString(s) PyByteArray_FromStringAndSize((const char*)s, strlen((const char*)s)) +#define __Pyx_PyByteArray_FromStringAndSize(s, l) PyByteArray_FromStringAndSize((const char*)s, l) +#define __Pyx_PyBytes_FromString PyBytes_FromString +#define __Pyx_PyBytes_FromStringAndSize PyBytes_FromStringAndSize +static CYTHON_INLINE PyObject* __Pyx_PyUnicode_FromString(const char*); +#if PY_MAJOR_VERSION < 3 + #define __Pyx_PyStr_FromString __Pyx_PyBytes_FromString + #define __Pyx_PyStr_FromStringAndSize __Pyx_PyBytes_FromStringAndSize +#else + #define __Pyx_PyStr_FromString __Pyx_PyUnicode_FromString + #define __Pyx_PyStr_FromStringAndSize __Pyx_PyUnicode_FromStringAndSize +#endif +#define __Pyx_PyObject_AsSString(s) ((signed char*) __Pyx_PyObject_AsString(s)) +#define __Pyx_PyObject_AsUString(s) ((unsigned char*) __Pyx_PyObject_AsString(s)) +#define __Pyx_PyObject_FromCString(s) __Pyx_PyObject_FromString((const char*)s) +#define __Pyx_PyBytes_FromCString(s) __Pyx_PyBytes_FromString((const char*)s) +#define __Pyx_PyByteArray_FromCString(s) __Pyx_PyByteArray_FromString((const char*)s) +#define __Pyx_PyStr_FromCString(s) __Pyx_PyStr_FromString((const char*)s) +#define __Pyx_PyUnicode_FromCString(s) __Pyx_PyUnicode_FromString((const char*)s) +#if PY_MAJOR_VERSION < 3 +static CYTHON_INLINE size_t __Pyx_Py_UNICODE_strlen(const Py_UNICODE *u) +{ + const Py_UNICODE *u_end = u; + while (*u_end++) ; + return (size_t)(u_end - u - 1); +} +#else +#define __Pyx_Py_UNICODE_strlen Py_UNICODE_strlen +#endif +#define __Pyx_PyUnicode_FromUnicode(u) PyUnicode_FromUnicode(u, __Pyx_Py_UNICODE_strlen(u)) +#define __Pyx_PyUnicode_FromUnicodeAndLength PyUnicode_FromUnicode +#define __Pyx_PyUnicode_AsUnicode PyUnicode_AsUnicode +#define __Pyx_NewRef(obj) (Py_INCREF(obj), obj) +#define __Pyx_Owned_Py_None(b) __Pyx_NewRef(Py_None) +#define __Pyx_PyBool_FromLong(b) ((b) ? __Pyx_NewRef(Py_True) : __Pyx_NewRef(Py_False)) +static CYTHON_INLINE int __Pyx_PyObject_IsTrue(PyObject*); +static CYTHON_INLINE PyObject* __Pyx_PyNumber_IntOrLong(PyObject* x); +static CYTHON_INLINE Py_ssize_t __Pyx_PyIndex_AsSsize_t(PyObject*); +static CYTHON_INLINE PyObject * __Pyx_PyInt_FromSize_t(size_t); +#if CYTHON_ASSUME_SAFE_MACROS +#define __pyx_PyFloat_AsDouble(x) (PyFloat_CheckExact(x) ? PyFloat_AS_DOUBLE(x) : PyFloat_AsDouble(x)) +#else +#define __pyx_PyFloat_AsDouble(x) PyFloat_AsDouble(x) +#endif +#define __pyx_PyFloat_AsFloat(x) ((float) __pyx_PyFloat_AsDouble(x)) +#if PY_MAJOR_VERSION >= 3 +#define __Pyx_PyNumber_Int(x) (PyLong_CheckExact(x) ? __Pyx_NewRef(x) : PyNumber_Long(x)) +#else +#define __Pyx_PyNumber_Int(x) (PyInt_CheckExact(x) ? __Pyx_NewRef(x) : PyNumber_Int(x)) +#endif +#define __Pyx_PyNumber_Float(x) (PyFloat_CheckExact(x) ? __Pyx_NewRef(x) : PyNumber_Float(x)) +#if PY_MAJOR_VERSION < 3 && __PYX_DEFAULT_STRING_ENCODING_IS_ASCII +static int __Pyx_sys_getdefaultencoding_not_ascii; +static int __Pyx_init_sys_getdefaultencoding_params(void) { + PyObject* sys; + PyObject* default_encoding = NULL; + PyObject* ascii_chars_u = NULL; + PyObject* ascii_chars_b = NULL; + const char* default_encoding_c; + sys = PyImport_ImportModule("sys"); + if (!sys) goto bad; + default_encoding = PyObject_CallMethod(sys, (char*) "getdefaultencoding", NULL); + Py_DECREF(sys); + if (!default_encoding) goto bad; + default_encoding_c = PyBytes_AsString(default_encoding); + if (!default_encoding_c) goto bad; + if (strcmp(default_encoding_c, "ascii") == 0) { + __Pyx_sys_getdefaultencoding_not_ascii = 0; + } else { + char ascii_chars[128]; + int c; + for (c = 0; c < 128; c++) { + ascii_chars[c] = c; + } + __Pyx_sys_getdefaultencoding_not_ascii = 1; + ascii_chars_u = PyUnicode_DecodeASCII(ascii_chars, 128, NULL); + if (!ascii_chars_u) goto bad; + ascii_chars_b = PyUnicode_AsEncodedString(ascii_chars_u, default_encoding_c, NULL); + if (!ascii_chars_b || !PyBytes_Check(ascii_chars_b) || memcmp(ascii_chars, PyBytes_AS_STRING(ascii_chars_b), 128) != 0) { + PyErr_Format( + PyExc_ValueError, + "This module compiled with c_string_encoding=ascii, but default encoding '%.200s' is not a superset of ascii.", + default_encoding_c); + goto bad; + } + Py_DECREF(ascii_chars_u); + Py_DECREF(ascii_chars_b); + } + Py_DECREF(default_encoding); + return 0; +bad: + Py_XDECREF(default_encoding); + Py_XDECREF(ascii_chars_u); + Py_XDECREF(ascii_chars_b); + return -1; +} +#endif +#if __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT && PY_MAJOR_VERSION >= 3 +#define __Pyx_PyUnicode_FromStringAndSize(c_str, size) PyUnicode_DecodeUTF8(c_str, size, NULL) +#else +#define __Pyx_PyUnicode_FromStringAndSize(c_str, size) PyUnicode_Decode(c_str, size, __PYX_DEFAULT_STRING_ENCODING, NULL) +#if __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT +static char* __PYX_DEFAULT_STRING_ENCODING; +static int __Pyx_init_sys_getdefaultencoding_params(void) { + PyObject* sys; + PyObject* default_encoding = NULL; + char* default_encoding_c; + sys = PyImport_ImportModule("sys"); + if (!sys) goto bad; + default_encoding = PyObject_CallMethod(sys, (char*) (const char*) "getdefaultencoding", NULL); + Py_DECREF(sys); + if (!default_encoding) goto bad; + default_encoding_c = PyBytes_AsString(default_encoding); + if (!default_encoding_c) goto bad; + __PYX_DEFAULT_STRING_ENCODING = (char*) malloc(strlen(default_encoding_c)); + if (!__PYX_DEFAULT_STRING_ENCODING) goto bad; + strcpy(__PYX_DEFAULT_STRING_ENCODING, default_encoding_c); + Py_DECREF(default_encoding); + return 0; +bad: + Py_XDECREF(default_encoding); + return -1; +} +#endif +#endif + + +/* Test for GCC > 2.95 */ +#if defined(__GNUC__) && (__GNUC__ > 2 || (__GNUC__ == 2 && (__GNUC_MINOR__ > 95))) + #define likely(x) __builtin_expect(!!(x), 1) + #define unlikely(x) __builtin_expect(!!(x), 0) +#else /* !__GNUC__ or GCC < 2.95 */ + #define likely(x) (x) + #define unlikely(x) (x) +#endif /* __GNUC__ */ + +static PyObject *__pyx_m; +static PyObject *__pyx_d; +static PyObject *__pyx_b; +static PyObject *__pyx_empty_tuple; +static PyObject *__pyx_empty_bytes; +static PyObject *__pyx_empty_unicode; +static int __pyx_lineno; +static int __pyx_clineno = 0; +static const char * __pyx_cfilenm= __FILE__; +static const char *__pyx_filename; + + +static const char *__pyx_f[] = { + "asyncpg/protocol/settings.pyx", + "asyncpg/protocol/buffer.pyx", + "asyncpg/protocol/codecs/base.pyx", + "asyncpg/protocol/codecs/int.pyx", + "asyncpg/protocol/coreproto.pyx", + "asyncpg/protocol/encodings.pyx", + "asyncpg/protocol/codecs/bytea.pyx", + "asyncpg/protocol/codecs/text.pyx", + "asyncpg/protocol/codecs/bits.pyx", + "asyncpg/protocol/codecs/datetime.pyx", + "asyncpg/protocol/codecs/float.pyx", + "asyncpg/protocol/codecs/geometry.pyx", + "asyncpg/protocol/codecs/json.pyx", + "asyncpg/protocol/codecs/money.pyx", + "asyncpg/protocol/codecs/network.pyx", + "asyncpg/protocol/codecs/numeric.pyx", + "asyncpg/protocol/codecs/tsearch.pyx", + "asyncpg/protocol/codecs/txid.pyx", + "asyncpg/protocol/codecs/uuid.pyx", + "asyncpg/protocol/codecs/misc.pyx", + "asyncpg/protocol/codecs/array.pyx", + "asyncpg/protocol/codecs/range.pyx", + "asyncpg/protocol/codecs/record.pyx", + "asyncpg/protocol/codecs/hstore.pyx", + "asyncpg/protocol/coreproto.pxd", + "asyncpg/protocol/prepared_stmt.pyx", + "asyncpg/protocol/prepared_stmt.pxd", + "asyncpg/protocol/protocol.pyx", + "asyncpg/protocol/protocol.pxd", + "type.pxd", + "bool.pxd", + "complex.pxd", + "asyncpg/protocol/pgtypes.pxi", +}; + +/*--- Type declarations ---*/ +struct __pyx_obj_7asyncpg_8protocol_8protocol_Memory; +struct __pyx_obj_7asyncpg_8protocol_8protocol_WriteBuffer; +struct __pyx_obj_7asyncpg_8protocol_8protocol_ReadBuffer; +struct __pyx_obj_7asyncpg_8protocol_8protocol_FastReadBuffer; +struct __pyx_obj_7asyncpg_8protocol_8protocol_Codec; +struct __pyx_obj_7asyncpg_8protocol_8protocol_DataCodecConfig; +struct __pyx_obj_7asyncpg_8protocol_8protocol_ConnectionSettings; +struct __pyx_obj_7asyncpg_8protocol_8protocol_CoreProtocol; +struct __pyx_obj_7asyncpg_8protocol_8protocol_PreparedStatementState; +struct __pyx_obj_7asyncpg_8protocol_8protocol_BaseProtocol; +struct __pyx_obj_7asyncpg_8protocol_8protocol___pyx_scope_struct__prepare; +struct __pyx_obj_7asyncpg_8protocol_8protocol___pyx_scope_struct_1_bind_execute; +struct __pyx_obj_7asyncpg_8protocol_8protocol___pyx_scope_struct_2_bind_execute_many; +struct __pyx_obj_7asyncpg_8protocol_8protocol___pyx_scope_struct_3_genexpr; +struct __pyx_obj_7asyncpg_8protocol_8protocol___pyx_scope_struct_4_bind; +struct __pyx_obj_7asyncpg_8protocol_8protocol___pyx_scope_struct_5_execute; +struct __pyx_obj_7asyncpg_8protocol_8protocol___pyx_scope_struct_6_query; +struct __pyx_obj_7asyncpg_8protocol_8protocol___pyx_scope_struct_7_close_statement; +struct __pyx_obj_7asyncpg_8protocol_8protocol___pyx_scope_struct_8_close; +union __pyx_t_7asyncpg_8protocol_4hton__floatconv; +union __pyx_t_7asyncpg_8protocol_4hton__doubleconv; + +/* "hton.pxd":53 + * + * + * cdef union _floatconv: # <<<<<<<<<<<<<< + * uint32_t i + * float f + */ +union __pyx_t_7asyncpg_8protocol_4hton__floatconv { + uint32_t i; + float f; +}; + +/* "hton.pxd":70 + * + * + * cdef union _doubleconv: # <<<<<<<<<<<<<< + * uint64_t i + * double f + */ +union __pyx_t_7asyncpg_8protocol_4hton__doubleconv { + uint64_t i; + double f; +}; +struct __pyx_opt_args_7asyncpg_8protocol_8protocol_18ConnectionSettings_get_data_codec; + +/* "asyncpg/protocol/codecs/base.pxd":25 + * + * + * cdef enum CodecType: # <<<<<<<<<<<<<< + * CODEC_UNDEFINED = 0 + * CODEC_C = 1 + */ +enum __pyx_t_7asyncpg_8protocol_8protocol_CodecType { + __pyx_e_7asyncpg_8protocol_8protocol_CODEC_UNDEFINED = 0, + __pyx_e_7asyncpg_8protocol_8protocol_CODEC_C = 1, + __pyx_e_7asyncpg_8protocol_8protocol_CODEC_PY = 2, + __pyx_e_7asyncpg_8protocol_8protocol_CODEC_ARRAY = 3, + __pyx_e_7asyncpg_8protocol_8protocol_CODEC_COMPOSITE = 4, + __pyx_e_7asyncpg_8protocol_8protocol_CODEC_RANGE = 5 +}; + +/* "asyncpg/protocol/codecs/base.pxd":34 + * + * + * cdef enum CodecFormat: # <<<<<<<<<<<<<< + * PG_FORMAT_ANY = -1 + * PG_FORMAT_TEXT = 0 + */ +enum __pyx_t_7asyncpg_8protocol_8protocol_CodecFormat { + __pyx_e_7asyncpg_8protocol_8protocol_PG_FORMAT_ANY = -1L, + __pyx_e_7asyncpg_8protocol_8protocol_PG_FORMAT_TEXT = 0, + __pyx_e_7asyncpg_8protocol_8protocol_PG_FORMAT_BINARY = 1 +}; + +/* "asyncpg/protocol/coreproto.pxd":8 + * + * + * cdef enum ConnectionStatus: # <<<<<<<<<<<<<< + * CONNECTION_OK = 1 + * CONNECTION_BAD = 2 + */ +enum __pyx_t_7asyncpg_8protocol_8protocol_ConnectionStatus { + __pyx_e_7asyncpg_8protocol_8protocol_CONNECTION_OK = 1, + __pyx_e_7asyncpg_8protocol_8protocol_CONNECTION_BAD = 2, + __pyx_e_7asyncpg_8protocol_8protocol_CONNECTION_STARTED = 3 +}; + +/* "asyncpg/protocol/coreproto.pxd":14 + * + * + * cdef enum ProtocolState: # <<<<<<<<<<<<<< + * PROTOCOL_IDLE = 0 + * + */ +enum __pyx_t_7asyncpg_8protocol_8protocol_ProtocolState { + __pyx_e_7asyncpg_8protocol_8protocol_PROTOCOL_IDLE = 0, + __pyx_e_7asyncpg_8protocol_8protocol_PROTOCOL_FAILED = 1, + __pyx_e_7asyncpg_8protocol_8protocol_PROTOCOL_ERROR_CONSUME = 2, + __pyx_e_7asyncpg_8protocol_8protocol_PROTOCOL_AUTH = 10, + __pyx_e_7asyncpg_8protocol_8protocol_PROTOCOL_PREPARE = 11, + __pyx_e_7asyncpg_8protocol_8protocol_PROTOCOL_BIND_EXECUTE = 12, + __pyx_e_7asyncpg_8protocol_8protocol_PROTOCOL_BIND_EXECUTE_MANY = 13, + __pyx_e_7asyncpg_8protocol_8protocol_PROTOCOL_CLOSE_STMT_PORTAL = 14, + __pyx_e_7asyncpg_8protocol_8protocol_PROTOCOL_SIMPLE_QUERY = 15, + __pyx_e_7asyncpg_8protocol_8protocol_PROTOCOL_EXECUTE = 16, + __pyx_e_7asyncpg_8protocol_8protocol_PROTOCOL_BIND = 17 +}; + +/* "asyncpg/protocol/coreproto.pxd":31 + * + * + * cdef enum AuthenticationMessage: # <<<<<<<<<<<<<< + * AUTH_SUCCESSFUL = 0 + * AUTH_REQUIRED_KERBEROS = 2 + */ +enum __pyx_t_7asyncpg_8protocol_8protocol_AuthenticationMessage { + __pyx_e_7asyncpg_8protocol_8protocol_AUTH_SUCCESSFUL = 0, + __pyx_e_7asyncpg_8protocol_8protocol_AUTH_REQUIRED_KERBEROS = 2, + __pyx_e_7asyncpg_8protocol_8protocol_AUTH_REQUIRED_PASSWORD = 3, + __pyx_e_7asyncpg_8protocol_8protocol_AUTH_REQUIRED_PASSWORDMD5 = 5, + __pyx_e_7asyncpg_8protocol_8protocol_AUTH_REQUIRED_SCMCRED = 6, + __pyx_e_7asyncpg_8protocol_8protocol_AUTH_REQUIRED_GSS = 7, + __pyx_e_7asyncpg_8protocol_8protocol_AUTH_REQUIRED_GSS_CONTINUE = 8, + __pyx_e_7asyncpg_8protocol_8protocol_AUTH_REQUIRED_SSPI = 9 +}; + +/* "asyncpg/protocol/coreproto.pxd":51 + * + * + * cdef enum ResultType: # <<<<<<<<<<<<<< + * RESULT_OK = 1 + * RESULT_FAILED = 2 + */ +enum __pyx_t_7asyncpg_8protocol_8protocol_ResultType { + __pyx_e_7asyncpg_8protocol_8protocol_RESULT_OK = 1, + __pyx_e_7asyncpg_8protocol_8protocol_RESULT_FAILED = 2 +}; + +/* "asyncpg/protocol/coreproto.pxd":56 + * + * + * cdef enum TransactionStatus: # <<<<<<<<<<<<<< + * PQTRANS_IDLE = 0 # connection idle + * PQTRANS_ACTIVE = 1 # command in progress + */ +enum __pyx_t_7asyncpg_8protocol_8protocol_TransactionStatus { + __pyx_e_7asyncpg_8protocol_8protocol_PQTRANS_IDLE = 0, + __pyx_e_7asyncpg_8protocol_8protocol_PQTRANS_ACTIVE = 1, + __pyx_e_7asyncpg_8protocol_8protocol_PQTRANS_INTRANS = 2, + __pyx_e_7asyncpg_8protocol_8protocol_PQTRANS_INERROR = 3, + __pyx_e_7asyncpg_8protocol_8protocol_PQTRANS_UNKNOWN = 4 +}; + +/* "asyncpg/protocol/codecs/base.pxd":8 + * + * + * ctypedef object (*encode_func)(ConnectionSettings settings, # <<<<<<<<<<<<<< + * WriteBuffer buf, + * object obj) + */ +typedef PyObject *(*__pyx_t_7asyncpg_8protocol_8protocol_encode_func)(struct __pyx_obj_7asyncpg_8protocol_8protocol_ConnectionSettings *, struct __pyx_obj_7asyncpg_8protocol_8protocol_WriteBuffer *, PyObject *); + +/* "asyncpg/protocol/codecs/base.pxd":12 + * object obj) + * + * ctypedef object (*decode_func)(ConnectionSettings settings, # <<<<<<<<<<<<<< + * FastReadBuffer buf) + * + */ +typedef PyObject *(*__pyx_t_7asyncpg_8protocol_8protocol_decode_func)(struct __pyx_obj_7asyncpg_8protocol_8protocol_ConnectionSettings *, struct __pyx_obj_7asyncpg_8protocol_8protocol_FastReadBuffer *); + +/* "asyncpg/protocol/codecs/base.pxd":15 + * FastReadBuffer buf) + * + * ctypedef object (*codec_encode_func)(Codec codec, # <<<<<<<<<<<<<< + * ConnectionSettings settings, + * WriteBuffer buf, + */ +typedef PyObject *(*__pyx_t_7asyncpg_8protocol_8protocol_codec_encode_func)(struct __pyx_obj_7asyncpg_8protocol_8protocol_Codec *, struct __pyx_obj_7asyncpg_8protocol_8protocol_ConnectionSettings *, struct __pyx_obj_7asyncpg_8protocol_8protocol_WriteBuffer *, PyObject *); + +/* "asyncpg/protocol/codecs/base.pxd":20 + * object obj) + * + * ctypedef object (*codec_decode_func)(Codec codec, # <<<<<<<<<<<<<< + * ConnectionSettings settings, + * FastReadBuffer buf) + */ +typedef PyObject *(*__pyx_t_7asyncpg_8protocol_8protocol_codec_decode_func)(struct __pyx_obj_7asyncpg_8protocol_8protocol_Codec *, struct __pyx_obj_7asyncpg_8protocol_8protocol_ConnectionSettings *, struct __pyx_obj_7asyncpg_8protocol_8protocol_FastReadBuffer *); + +/* "asyncpg/protocol/settings.pxd":25 + * cpdef inline set_builtin_type_codec( + * self, typeoid, typename, typeschema, typekind, alias_to) + * cpdef inline Codec get_data_codec(self, uint32_t oid, CodecFormat format=*) # <<<<<<<<<<<<<< + */ +struct __pyx_opt_args_7asyncpg_8protocol_8protocol_18ConnectionSettings_get_data_codec { + int __pyx_n; + enum __pyx_t_7asyncpg_8protocol_8protocol_CodecFormat format; +}; + +/* "asyncpg/protocol/coreproto.pxd":64 + * + * + * ctypedef object (*decode_row_method)(object, const char*, ssize_t) # <<<<<<<<<<<<<< + * + * + */ +typedef PyObject *(*__pyx_t_7asyncpg_8protocol_8protocol_decode_row_method)(PyObject *, char const *, Py_ssize_t); + +/* "asyncpg/protocol/codecs/array.pyx":574 + * + * + * cdef enum _ArrayParseState: # <<<<<<<<<<<<<< + * APS_START = 1 + * APS_STRIDE_STARTED = 2 + */ +enum __pyx_t_7asyncpg_8protocol_8protocol__ArrayParseState { + __pyx_e_7asyncpg_8protocol_8protocol_APS_START = 1, + __pyx_e_7asyncpg_8protocol_8protocol_APS_STRIDE_STARTED = 2, + __pyx_e_7asyncpg_8protocol_8protocol_APS_STRIDE_DONE = 3, + __pyx_e_7asyncpg_8protocol_8protocol_APS_STRIDE_DELIMITED = 4, + __pyx_e_7asyncpg_8protocol_8protocol_APS_ELEM_STARTED = 5, + __pyx_e_7asyncpg_8protocol_8protocol_APS_ELEM_DELIMITED = 6 +}; + +/* "asyncpg/protocol/codecs/range.pyx":18 + * + * + * cdef enum _RangeArgumentType: # <<<<<<<<<<<<<< + * _RANGE_ARGUMENT_INVALID = 0 + * _RANGE_ARGUMENT_TUPLE = 1 + */ +enum __pyx_t_7asyncpg_8protocol_8protocol__RangeArgumentType { + __pyx_e_7asyncpg_8protocol_8protocol__RANGE_ARGUMENT_INVALID = 0, + __pyx_e_7asyncpg_8protocol_8protocol__RANGE_ARGUMENT_TUPLE = 1, + __pyx_e_7asyncpg_8protocol_8protocol__RANGE_ARGUMENT_RANGE = 2 +}; + +/* "asyncpg/protocol/codecs/array.pyx":17 + * + * + * ctypedef object (*encode_func_ex)(ConnectionSettings settings, # <<<<<<<<<<<<<< + * WriteBuffer buf, + * object obj, + */ +typedef PyObject *(*__pyx_t_7asyncpg_8protocol_8protocol_encode_func_ex)(struct __pyx_obj_7asyncpg_8protocol_8protocol_ConnectionSettings *, struct __pyx_obj_7asyncpg_8protocol_8protocol_WriteBuffer *, PyObject *, void const *); + +/* "asyncpg/protocol/codecs/array.pyx":23 + * + * + * ctypedef object (*decode_func_ex)(ConnectionSettings settings, # <<<<<<<<<<<<<< + * FastReadBuffer buf, + * const void *arg) + */ +typedef PyObject *(*__pyx_t_7asyncpg_8protocol_8protocol_decode_func_ex)(struct __pyx_obj_7asyncpg_8protocol_8protocol_ConnectionSettings *, struct __pyx_obj_7asyncpg_8protocol_8protocol_FastReadBuffer *, void const *); + +/* "asyncpg/protocol/buffer.pxd":8 + * + * + * cdef class Memory: # <<<<<<<<<<<<<< + * cdef: + * char* buf + */ +struct __pyx_obj_7asyncpg_8protocol_8protocol_Memory { + PyObject_HEAD + struct __pyx_vtabstruct_7asyncpg_8protocol_8protocol_Memory *__pyx_vtab; + char *buf; + PyObject *owner; + Py_ssize_t length; +}; + + +/* "asyncpg/protocol/buffer.pxd":20 + * + * + * cdef class WriteBuffer: # <<<<<<<<<<<<<< + * cdef: + * # Preallocated small buffer + */ +struct __pyx_obj_7asyncpg_8protocol_8protocol_WriteBuffer { + PyObject_HEAD + struct __pyx_vtabstruct_7asyncpg_8protocol_8protocol_WriteBuffer *__pyx_vtab; + int _smallbuf_inuse; + char _smallbuf[0x400]; + char *_buf; + Py_ssize_t _size; + Py_ssize_t _length; + int _view_count; + int _message_mode; +}; + + +/* "asyncpg/protocol/buffer.pxd":65 + * + * + * cdef class ReadBuffer: # <<<<<<<<<<<<<< + * cdef: + * # A deque of buffers (bytes objects) + */ +struct __pyx_obj_7asyncpg_8protocol_8protocol_ReadBuffer { + PyObject_HEAD + struct __pyx_vtabstruct_7asyncpg_8protocol_8protocol_ReadBuffer *__pyx_vtab; + PyObject *_bufs; + PyObject *_bufs_append; + PyObject *_bufs_popleft; + PyObject *_buf0; + PyObject *_buf0_prev; + int32_t _bufs_len; + Py_ssize_t _pos0; + Py_ssize_t _len0; + Py_ssize_t _length; + char _current_message_type; + int _current_message_len; + Py_ssize_t _current_message_len_unread; + int _current_message_ready; +}; + + +/* "asyncpg/protocol/buffer.pxd":119 + * + * + * cdef class FastReadBuffer: # <<<<<<<<<<<<<< + * cdef: + * const char* buf + */ +struct __pyx_obj_7asyncpg_8protocol_8protocol_FastReadBuffer { + PyObject_HEAD + struct __pyx_vtabstruct_7asyncpg_8protocol_8protocol_FastReadBuffer *__pyx_vtab; + char const *buf; + Py_ssize_t len; +}; + + +/* "asyncpg/protocol/codecs/base.pxd":40 + * + * + * cdef class Codec: # <<<<<<<<<<<<<< + * cdef: + * uint32_t oid + */ +struct __pyx_obj_7asyncpg_8protocol_8protocol_Codec { + PyObject_HEAD + struct __pyx_vtabstruct_7asyncpg_8protocol_8protocol_Codec *__pyx_vtab; + uint32_t oid; + PyObject *name; + PyObject *schema; + PyObject *kind; + enum __pyx_t_7asyncpg_8protocol_8protocol_CodecType type; + enum __pyx_t_7asyncpg_8protocol_8protocol_CodecFormat format; + __pyx_t_7asyncpg_8protocol_8protocol_encode_func c_encoder; + __pyx_t_7asyncpg_8protocol_8protocol_decode_func c_decoder; + PyObject *py_encoder; + PyObject *py_decoder; + struct __pyx_obj_7asyncpg_8protocol_8protocol_Codec *element_codec; + Py_UCS4 element_delimiter; + PyObject *element_type_oids; + PyObject *element_names; + PyObject *element_codecs; + __pyx_t_7asyncpg_8protocol_8protocol_codec_encode_func encoder; + __pyx_t_7asyncpg_8protocol_8protocol_codec_decode_func decoder; +}; + + +/* "asyncpg/protocol/codecs/base.pxd":154 + * + * + * cdef class DataCodecConfig: # <<<<<<<<<<<<<< + * cdef: + * dict _type_codecs_cache + */ +struct __pyx_obj_7asyncpg_8protocol_8protocol_DataCodecConfig { + PyObject_HEAD + struct __pyx_vtabstruct_7asyncpg_8protocol_8protocol_DataCodecConfig *__pyx_vtab; + PyObject *_type_codecs_cache; + PyObject *_local_type_codecs; +}; + + +/* "asyncpg/protocol/settings.pxd":8 + * + * + * cdef class ConnectionSettings: # <<<<<<<<<<<<<< + * cdef: + * str _encoding + */ +struct __pyx_obj_7asyncpg_8protocol_8protocol_ConnectionSettings { + PyObject_HEAD + struct __pyx_vtabstruct_7asyncpg_8protocol_8protocol_ConnectionSettings *__pyx_vtab; + PyObject *_encoding; + PyObject *_codec; + PyObject *_settings; + int _is_utf8; + struct __pyx_obj_7asyncpg_8protocol_8protocol_DataCodecConfig *_data_codecs; +}; + + +/* "asyncpg/protocol/coreproto.pxd":67 + * + * + * cdef class CoreProtocol: # <<<<<<<<<<<<<< + * cdef: + * ReadBuffer buffer + */ +struct __pyx_obj_7asyncpg_8protocol_8protocol_CoreProtocol { + PyObject_HEAD + struct __pyx_vtabstruct_7asyncpg_8protocol_8protocol_CoreProtocol *__pyx_vtab; + struct __pyx_obj_7asyncpg_8protocol_8protocol_ReadBuffer *buffer; + int _skip_discard; + int _discard_data; + PyObject *_execute_iter; + PyObject *_execute_portal_name; + PyObject *_execute_stmt_name; + enum __pyx_t_7asyncpg_8protocol_8protocol_ConnectionStatus con_status; + enum __pyx_t_7asyncpg_8protocol_8protocol_ProtocolState state; + enum __pyx_t_7asyncpg_8protocol_8protocol_TransactionStatus xact_status; + PyObject *encoding; + PyObject *transport; + PyObject *con_args; + int32_t backend_pid; + int32_t backend_secret; + enum __pyx_t_7asyncpg_8protocol_8protocol_ResultType result_type; + PyObject *result; + PyObject *result_param_desc; + PyObject *result_row_desc; + PyObject *result_status_msg; + int result_execute_completed; +}; + + +/* "asyncpg/protocol/prepared_stmt.pxd":8 + * + * + * cdef class PreparedStatementState: # <<<<<<<<<<<<<< + * cdef: + * readonly str name + */ +struct __pyx_obj_7asyncpg_8protocol_8protocol_PreparedStatementState { + PyObject_HEAD + struct __pyx_vtabstruct_7asyncpg_8protocol_8protocol_PreparedStatementState *__pyx_vtab; + PyObject *name; + PyObject *query; + int closed; + int refs; + struct __pyx_obj_7asyncpg_8protocol_8protocol_FastReadBuffer *buffer; + PyObject *row_desc; + PyObject *parameters_desc; + struct __pyx_obj_7asyncpg_8protocol_8protocol_BaseProtocol *protocol; + struct __pyx_obj_7asyncpg_8protocol_8protocol_ConnectionSettings *settings; + int16_t args_num; + int have_text_args; + PyObject *args_codecs; + int16_t cols_num; + PyObject *cols_desc; + int have_text_cols; + PyObject *rows_codecs; +}; + + +/* "asyncpg/protocol/protocol.pxd":25 + * + * + * cdef class BaseProtocol(CoreProtocol): # <<<<<<<<<<<<<< + * + * cdef: + */ +struct __pyx_obj_7asyncpg_8protocol_8protocol_BaseProtocol { + struct __pyx_obj_7asyncpg_8protocol_8protocol_CoreProtocol __pyx_base; + PyObject *loop; + PyObject *address; + struct __pyx_obj_7asyncpg_8protocol_8protocol_ConnectionSettings *settings; + PyObject *cancel_sent_waiter; + PyObject *cancel_waiter; + PyObject *waiter; + int return_extra; + PyObject *create_future; + PyObject *timeout_handle; + PyObject *timeout_callback; + PyObject *completed_callback; + PyObject *connection; + PyObject *last_query; + int uid_counter; + int closing; + uint64_t queries_count; + struct __pyx_obj_7asyncpg_8protocol_8protocol_PreparedStatementState *statement; +}; + + +/* "asyncpg/protocol/protocol.pyx":123 + * return self.settings + * + * async def prepare(self, stmt_name, query, timeout): # <<<<<<<<<<<<<< + * if self.cancel_waiter is not None: + * await self.cancel_waiter + */ +struct __pyx_obj_7asyncpg_8protocol_8protocol___pyx_scope_struct__prepare { + PyObject_HEAD + PyObject *__pyx_v_query; + struct __pyx_obj_7asyncpg_8protocol_8protocol_BaseProtocol *__pyx_v_self; + PyObject *__pyx_v_stmt_name; + PyObject *__pyx_v_timeout; +}; + + +/* "asyncpg/protocol/protocol.pyx":142 + * return await self._new_waiter(timeout) + * + * async def bind_execute(self, PreparedStatementState state, args, # <<<<<<<<<<<<<< + * str portal_name, int limit, return_extra, + * timeout): + */ +struct __pyx_obj_7asyncpg_8protocol_8protocol___pyx_scope_struct_1_bind_execute { + PyObject_HEAD + PyObject *__pyx_v_args; + int __pyx_v_limit; + PyObject *__pyx_v_portal_name; + PyObject *__pyx_v_return_extra; + struct __pyx_obj_7asyncpg_8protocol_8protocol_BaseProtocol *__pyx_v_self; + struct __pyx_obj_7asyncpg_8protocol_8protocol_PreparedStatementState *__pyx_v_state; + PyObject *__pyx_v_timeout; +}; + + +/* "asyncpg/protocol/protocol.pyx":167 + * return await self._new_waiter(timeout) + * + * async def bind_execute_many(self, PreparedStatementState state, args, # <<<<<<<<<<<<<< + * str portal_name, timeout): + * + */ +struct __pyx_obj_7asyncpg_8protocol_8protocol___pyx_scope_struct_2_bind_execute_many { + PyObject_HEAD + PyObject *__pyx_v_arg_bufs; + PyObject *__pyx_v_args; + PyObject *__pyx_v_data_gen; + PyObject *__pyx_v_genexpr; + PyObject *__pyx_v_portal_name; + struct __pyx_obj_7asyncpg_8protocol_8protocol_BaseProtocol *__pyx_v_self; + struct __pyx_obj_7asyncpg_8protocol_8protocol_PreparedStatementState *__pyx_v_state; + PyObject *__pyx_v_timeout; + PyObject *__pyx_v_waiter; +}; + + +/* "asyncpg/protocol/protocol.pyx":181 + * # this generator expression to keep the memory pressure under + * # control. + * data_gen = (state._encode_bind_msg(b) for b in args) # <<<<<<<<<<<<<< + * arg_bufs = iter(data_gen) + * + */ +struct __pyx_obj_7asyncpg_8protocol_8protocol___pyx_scope_struct_3_genexpr { + PyObject_HEAD + struct __pyx_obj_7asyncpg_8protocol_8protocol___pyx_scope_struct_2_bind_execute_many *__pyx_outer_scope; + PyObject *__pyx_v_b; + PyObject *__pyx_t_0; + Py_ssize_t __pyx_t_1; + PyObject *(*__pyx_t_2)(PyObject *); +}; + + +/* "asyncpg/protocol/protocol.pyx":198 + * return await waiter + * + * async def bind(self, PreparedStatementState state, args, # <<<<<<<<<<<<<< + * str portal_name, timeout): + * + */ +struct __pyx_obj_7asyncpg_8protocol_8protocol___pyx_scope_struct_4_bind { + PyObject_HEAD + PyObject *__pyx_v_args; + PyObject *__pyx_v_portal_name; + struct __pyx_obj_7asyncpg_8protocol_8protocol_BaseProtocol *__pyx_v_self; + struct __pyx_obj_7asyncpg_8protocol_8protocol_PreparedStatementState *__pyx_v_state; + PyObject *__pyx_v_timeout; +}; + + +/* "asyncpg/protocol/protocol.pyx":219 + * return await self._new_waiter(timeout) + * + * async def execute(self, PreparedStatementState state, # <<<<<<<<<<<<<< + * str portal_name, int limit, return_extra, + * timeout): + */ +struct __pyx_obj_7asyncpg_8protocol_8protocol___pyx_scope_struct_5_execute { + PyObject_HEAD + int __pyx_v_limit; + PyObject *__pyx_v_portal_name; + PyObject *__pyx_v_return_extra; + struct __pyx_obj_7asyncpg_8protocol_8protocol_BaseProtocol *__pyx_v_self; + struct __pyx_obj_7asyncpg_8protocol_8protocol_PreparedStatementState *__pyx_v_state; + PyObject *__pyx_v_timeout; +}; + + +/* "asyncpg/protocol/protocol.pyx":242 + * return await self._new_waiter(timeout) + * + * async def query(self, query, timeout): # <<<<<<<<<<<<<< + * if self.cancel_waiter is not None: + * await self.cancel_waiter + */ +struct __pyx_obj_7asyncpg_8protocol_8protocol___pyx_scope_struct_6_query { + PyObject_HEAD + PyObject *__pyx_v_query; + struct __pyx_obj_7asyncpg_8protocol_8protocol_BaseProtocol *__pyx_v_self; + PyObject *__pyx_v_timeout; +}; + + +/* "asyncpg/protocol/protocol.pyx":257 + * return await self._new_waiter(timeout) + * + * async def close_statement(self, PreparedStatementState state, timeout): # <<<<<<<<<<<<<< + * if self.cancel_waiter is not None: + * await self.cancel_waiter + */ +struct __pyx_obj_7asyncpg_8protocol_8protocol___pyx_scope_struct_7_close_statement { + PyObject_HEAD + struct __pyx_obj_7asyncpg_8protocol_8protocol_BaseProtocol *__pyx_v_self; + struct __pyx_obj_7asyncpg_8protocol_8protocol_PreparedStatementState *__pyx_v_state; + PyObject *__pyx_v_timeout; +}; + + +/* "asyncpg/protocol/protocol.pyx":289 + * self.transport.abort() + * + * async def close(self): # <<<<<<<<<<<<<< + * if self.cancel_waiter is not None: + * await self.cancel_waiter + */ +struct __pyx_obj_7asyncpg_8protocol_8protocol___pyx_scope_struct_8_close { + PyObject_HEAD + struct __pyx_obj_7asyncpg_8protocol_8protocol_BaseProtocol *__pyx_v_self; +}; + + + +/* "asyncpg/protocol/buffer.pyx":18 + * @cython.final + * @cython.freelist(_MEMORY_FREELIST_SIZE) + * cdef class Memory: # <<<<<<<<<<<<<< + * + * cdef as_bytes(self): + */ + +struct __pyx_vtabstruct_7asyncpg_8protocol_8protocol_Memory { + PyObject *(*as_bytes)(struct __pyx_obj_7asyncpg_8protocol_8protocol_Memory *); + struct __pyx_obj_7asyncpg_8protocol_8protocol_Memory *(*new)(char *, PyObject *, Py_ssize_t); +}; +static struct __pyx_vtabstruct_7asyncpg_8protocol_8protocol_Memory *__pyx_vtabptr_7asyncpg_8protocol_8protocol_Memory; +static PyObject *__pyx_f_7asyncpg_8protocol_8protocol_6Memory_as_bytes(struct __pyx_obj_7asyncpg_8protocol_8protocol_Memory *); +static CYTHON_INLINE struct __pyx_obj_7asyncpg_8protocol_8protocol_Memory *__pyx_f_7asyncpg_8protocol_8protocol_6Memory_new(char *, PyObject *, Py_ssize_t); + + +/* "asyncpg/protocol/buffer.pyx":36 + * @cython.final + * @cython.freelist(_BUFFER_FREELIST_SIZE) + * cdef class WriteBuffer: # <<<<<<<<<<<<<< + * + * def __cinit__(self): + */ + +struct __pyx_vtabstruct_7asyncpg_8protocol_8protocol_WriteBuffer { + PyObject *(*_check_readonly)(struct __pyx_obj_7asyncpg_8protocol_8protocol_WriteBuffer *); + PyObject *(*len)(struct __pyx_obj_7asyncpg_8protocol_8protocol_WriteBuffer *); + PyObject *(*_ensure_alloced)(struct __pyx_obj_7asyncpg_8protocol_8protocol_WriteBuffer *, Py_ssize_t); + PyObject *(*_reallocate)(struct __pyx_obj_7asyncpg_8protocol_8protocol_WriteBuffer *, Py_ssize_t); + PyObject *(*start_message)(struct __pyx_obj_7asyncpg_8protocol_8protocol_WriteBuffer *, char); + PyObject *(*end_message)(struct __pyx_obj_7asyncpg_8protocol_8protocol_WriteBuffer *); + PyObject *(*write_buffer)(struct __pyx_obj_7asyncpg_8protocol_8protocol_WriteBuffer *, struct __pyx_obj_7asyncpg_8protocol_8protocol_WriteBuffer *); + PyObject *(*write_byte)(struct __pyx_obj_7asyncpg_8protocol_8protocol_WriteBuffer *, char); + PyObject *(*write_bytes)(struct __pyx_obj_7asyncpg_8protocol_8protocol_WriteBuffer *, PyObject *); + PyObject *(*write_bytestring)(struct __pyx_obj_7asyncpg_8protocol_8protocol_WriteBuffer *, PyObject *); + PyObject *(*write_str)(struct __pyx_obj_7asyncpg_8protocol_8protocol_WriteBuffer *, PyObject *, PyObject *); + PyObject *(*write_cstr)(struct __pyx_obj_7asyncpg_8protocol_8protocol_WriteBuffer *, char *, Py_ssize_t); + PyObject *(*write_int16)(struct __pyx_obj_7asyncpg_8protocol_8protocol_WriteBuffer *, int16_t); + PyObject *(*write_int32)(struct __pyx_obj_7asyncpg_8protocol_8protocol_WriteBuffer *, int32_t); + PyObject *(*write_int64)(struct __pyx_obj_7asyncpg_8protocol_8protocol_WriteBuffer *, int64_t); + PyObject *(*write_float)(struct __pyx_obj_7asyncpg_8protocol_8protocol_WriteBuffer *, float); + PyObject *(*write_double)(struct __pyx_obj_7asyncpg_8protocol_8protocol_WriteBuffer *, double); + struct __pyx_obj_7asyncpg_8protocol_8protocol_WriteBuffer *(*new_message)(char); + struct __pyx_obj_7asyncpg_8protocol_8protocol_WriteBuffer *(*new)(void); +}; +static struct __pyx_vtabstruct_7asyncpg_8protocol_8protocol_WriteBuffer *__pyx_vtabptr_7asyncpg_8protocol_8protocol_WriteBuffer; +static CYTHON_INLINE PyObject *__pyx_f_7asyncpg_8protocol_8protocol_11WriteBuffer__check_readonly(struct __pyx_obj_7asyncpg_8protocol_8protocol_WriteBuffer *); +static CYTHON_INLINE PyObject *__pyx_f_7asyncpg_8protocol_8protocol_11WriteBuffer_len(struct __pyx_obj_7asyncpg_8protocol_8protocol_WriteBuffer *); +static CYTHON_INLINE PyObject *__pyx_f_7asyncpg_8protocol_8protocol_11WriteBuffer__ensure_alloced(struct __pyx_obj_7asyncpg_8protocol_8protocol_WriteBuffer *, Py_ssize_t); +static PyObject *__pyx_f_7asyncpg_8protocol_8protocol_11WriteBuffer__reallocate(struct __pyx_obj_7asyncpg_8protocol_8protocol_WriteBuffer *, Py_ssize_t); +static CYTHON_INLINE PyObject *__pyx_f_7asyncpg_8protocol_8protocol_11WriteBuffer_start_message(struct __pyx_obj_7asyncpg_8protocol_8protocol_WriteBuffer *, char); +static CYTHON_INLINE PyObject *__pyx_f_7asyncpg_8protocol_8protocol_11WriteBuffer_end_message(struct __pyx_obj_7asyncpg_8protocol_8protocol_WriteBuffer *); +static PyObject *__pyx_f_7asyncpg_8protocol_8protocol_11WriteBuffer_write_buffer(struct __pyx_obj_7asyncpg_8protocol_8protocol_WriteBuffer *, struct __pyx_obj_7asyncpg_8protocol_8protocol_WriteBuffer *); +static PyObject *__pyx_f_7asyncpg_8protocol_8protocol_11WriteBuffer_write_byte(struct __pyx_obj_7asyncpg_8protocol_8protocol_WriteBuffer *, char); +static PyObject *__pyx_f_7asyncpg_8protocol_8protocol_11WriteBuffer_write_bytes(struct __pyx_obj_7asyncpg_8protocol_8protocol_WriteBuffer *, PyObject *); +static PyObject *__pyx_f_7asyncpg_8protocol_8protocol_11WriteBuffer_write_bytestring(struct __pyx_obj_7asyncpg_8protocol_8protocol_WriteBuffer *, PyObject *); +static PyObject *__pyx_f_7asyncpg_8protocol_8protocol_11WriteBuffer_write_str(struct __pyx_obj_7asyncpg_8protocol_8protocol_WriteBuffer *, PyObject *, PyObject *); +static PyObject *__pyx_f_7asyncpg_8protocol_8protocol_11WriteBuffer_write_cstr(struct __pyx_obj_7asyncpg_8protocol_8protocol_WriteBuffer *, char *, Py_ssize_t); +static PyObject *__pyx_f_7asyncpg_8protocol_8protocol_11WriteBuffer_write_int16(struct __pyx_obj_7asyncpg_8protocol_8protocol_WriteBuffer *, int16_t); +static PyObject *__pyx_f_7asyncpg_8protocol_8protocol_11WriteBuffer_write_int32(struct __pyx_obj_7asyncpg_8protocol_8protocol_WriteBuffer *, int32_t); +static PyObject *__pyx_f_7asyncpg_8protocol_8protocol_11WriteBuffer_write_int64(struct __pyx_obj_7asyncpg_8protocol_8protocol_WriteBuffer *, int64_t); +static PyObject *__pyx_f_7asyncpg_8protocol_8protocol_11WriteBuffer_write_float(struct __pyx_obj_7asyncpg_8protocol_8protocol_WriteBuffer *, float); +static PyObject *__pyx_f_7asyncpg_8protocol_8protocol_11WriteBuffer_write_double(struct __pyx_obj_7asyncpg_8protocol_8protocol_WriteBuffer *, double); +static struct __pyx_obj_7asyncpg_8protocol_8protocol_WriteBuffer *__pyx_f_7asyncpg_8protocol_8protocol_11WriteBuffer_new_message(char); +static struct __pyx_obj_7asyncpg_8protocol_8protocol_WriteBuffer *__pyx_f_7asyncpg_8protocol_8protocol_11WriteBuffer_new(void); + + +/* "asyncpg/protocol/buffer.pyx":231 + * @cython.final + * @cython.freelist(_BUFFER_FREELIST_SIZE) + * cdef class ReadBuffer: # <<<<<<<<<<<<<< + * + * def __cinit__(self): + */ + +struct __pyx_vtabstruct_7asyncpg_8protocol_8protocol_ReadBuffer { + PyObject *(*feed_data)(struct __pyx_obj_7asyncpg_8protocol_8protocol_ReadBuffer *, PyObject *); + PyObject *(*_ensure_first_buf)(struct __pyx_obj_7asyncpg_8protocol_8protocol_ReadBuffer *); + PyObject *(*_switch_to_next_buf)(struct __pyx_obj_7asyncpg_8protocol_8protocol_ReadBuffer *); + PyObject *(*read_byte)(struct __pyx_obj_7asyncpg_8protocol_8protocol_ReadBuffer *); + char *(*_try_read_bytes)(struct __pyx_obj_7asyncpg_8protocol_8protocol_ReadBuffer *, Py_ssize_t); + PyObject *(*read)(struct __pyx_obj_7asyncpg_8protocol_8protocol_ReadBuffer *, Py_ssize_t); + PyObject *(*read_bytes)(struct __pyx_obj_7asyncpg_8protocol_8protocol_ReadBuffer *, Py_ssize_t); + PyObject *(*read_int32)(struct __pyx_obj_7asyncpg_8protocol_8protocol_ReadBuffer *); + PyObject *(*read_int16)(struct __pyx_obj_7asyncpg_8protocol_8protocol_ReadBuffer *); + PyObject *(*read_cstr)(struct __pyx_obj_7asyncpg_8protocol_8protocol_ReadBuffer *); + int32_t (*has_message)(struct __pyx_obj_7asyncpg_8protocol_8protocol_ReadBuffer *); + char *(*try_consume_message)(struct __pyx_obj_7asyncpg_8protocol_8protocol_ReadBuffer *, Py_ssize_t *); + struct __pyx_obj_7asyncpg_8protocol_8protocol_Memory *(*consume_message)(struct __pyx_obj_7asyncpg_8protocol_8protocol_ReadBuffer *); + PyObject *(*discard_message)(struct __pyx_obj_7asyncpg_8protocol_8protocol_ReadBuffer *); + PyObject *(*_discard_message)(struct __pyx_obj_7asyncpg_8protocol_8protocol_ReadBuffer *); + char (*get_message_type)(struct __pyx_obj_7asyncpg_8protocol_8protocol_ReadBuffer *); + int32_t (*get_message_length)(struct __pyx_obj_7asyncpg_8protocol_8protocol_ReadBuffer *); + struct __pyx_obj_7asyncpg_8protocol_8protocol_ReadBuffer *(*new_message_parser)(PyObject *); +}; +static struct __pyx_vtabstruct_7asyncpg_8protocol_8protocol_ReadBuffer *__pyx_vtabptr_7asyncpg_8protocol_8protocol_ReadBuffer; +static PyObject *__pyx_f_7asyncpg_8protocol_8protocol_10ReadBuffer_feed_data(struct __pyx_obj_7asyncpg_8protocol_8protocol_ReadBuffer *, PyObject *); +static CYTHON_INLINE PyObject *__pyx_f_7asyncpg_8protocol_8protocol_10ReadBuffer__ensure_first_buf(struct __pyx_obj_7asyncpg_8protocol_8protocol_ReadBuffer *); +static PyObject *__pyx_f_7asyncpg_8protocol_8protocol_10ReadBuffer__switch_to_next_buf(struct __pyx_obj_7asyncpg_8protocol_8protocol_ReadBuffer *); +static CYTHON_INLINE PyObject *__pyx_f_7asyncpg_8protocol_8protocol_10ReadBuffer_read_byte(struct __pyx_obj_7asyncpg_8protocol_8protocol_ReadBuffer *); +static CYTHON_INLINE char *__pyx_f_7asyncpg_8protocol_8protocol_10ReadBuffer__try_read_bytes(struct __pyx_obj_7asyncpg_8protocol_8protocol_ReadBuffer *, Py_ssize_t); +static CYTHON_INLINE PyObject *__pyx_f_7asyncpg_8protocol_8protocol_10ReadBuffer_read(struct __pyx_obj_7asyncpg_8protocol_8protocol_ReadBuffer *, Py_ssize_t); +static CYTHON_INLINE PyObject *__pyx_f_7asyncpg_8protocol_8protocol_10ReadBuffer_read_bytes(struct __pyx_obj_7asyncpg_8protocol_8protocol_ReadBuffer *, Py_ssize_t); +static CYTHON_INLINE PyObject *__pyx_f_7asyncpg_8protocol_8protocol_10ReadBuffer_read_int32(struct __pyx_obj_7asyncpg_8protocol_8protocol_ReadBuffer *); +static CYTHON_INLINE PyObject *__pyx_f_7asyncpg_8protocol_8protocol_10ReadBuffer_read_int16(struct __pyx_obj_7asyncpg_8protocol_8protocol_ReadBuffer *); +static CYTHON_INLINE PyObject *__pyx_f_7asyncpg_8protocol_8protocol_10ReadBuffer_read_cstr(struct __pyx_obj_7asyncpg_8protocol_8protocol_ReadBuffer *); +static int32_t __pyx_f_7asyncpg_8protocol_8protocol_10ReadBuffer_has_message(struct __pyx_obj_7asyncpg_8protocol_8protocol_ReadBuffer *); +static CYTHON_INLINE char *__pyx_f_7asyncpg_8protocol_8protocol_10ReadBuffer_try_consume_message(struct __pyx_obj_7asyncpg_8protocol_8protocol_ReadBuffer *, Py_ssize_t *); +static struct __pyx_obj_7asyncpg_8protocol_8protocol_Memory *__pyx_f_7asyncpg_8protocol_8protocol_10ReadBuffer_consume_message(struct __pyx_obj_7asyncpg_8protocol_8protocol_ReadBuffer *); +static PyObject *__pyx_f_7asyncpg_8protocol_8protocol_10ReadBuffer_discard_message(struct __pyx_obj_7asyncpg_8protocol_8protocol_ReadBuffer *); +static CYTHON_INLINE PyObject *__pyx_f_7asyncpg_8protocol_8protocol_10ReadBuffer__discard_message(struct __pyx_obj_7asyncpg_8protocol_8protocol_ReadBuffer *); +static CYTHON_INLINE char __pyx_f_7asyncpg_8protocol_8protocol_10ReadBuffer_get_message_type(struct __pyx_obj_7asyncpg_8protocol_8protocol_ReadBuffer *); +static CYTHON_INLINE int32_t __pyx_f_7asyncpg_8protocol_8protocol_10ReadBuffer_get_message_length(struct __pyx_obj_7asyncpg_8protocol_8protocol_ReadBuffer *); +static struct __pyx_obj_7asyncpg_8protocol_8protocol_ReadBuffer *__pyx_f_7asyncpg_8protocol_8protocol_10ReadBuffer_new_message_parser(PyObject *); + + +/* "asyncpg/protocol/buffer.pyx":582 + * @cython.final + * @cython.freelist(_BUFFER_FREELIST_SIZE) + * cdef class FastReadBuffer: # <<<<<<<<<<<<<< + * + * cdef inline const char* read(self, ssize_t n) except NULL: + */ + +struct __pyx_vtabstruct_7asyncpg_8protocol_8protocol_FastReadBuffer { + char const *(*read)(struct __pyx_obj_7asyncpg_8protocol_8protocol_FastReadBuffer *, Py_ssize_t); + char const *(*read_all)(struct __pyx_obj_7asyncpg_8protocol_8protocol_FastReadBuffer *); + struct __pyx_obj_7asyncpg_8protocol_8protocol_FastReadBuffer *(*slice_from)(struct __pyx_obj_7asyncpg_8protocol_8protocol_FastReadBuffer *, struct __pyx_obj_7asyncpg_8protocol_8protocol_FastReadBuffer *, Py_ssize_t); + PyObject *(*_raise_ins_err)(struct __pyx_obj_7asyncpg_8protocol_8protocol_FastReadBuffer *, Py_ssize_t, Py_ssize_t); + struct __pyx_obj_7asyncpg_8protocol_8protocol_FastReadBuffer *(*new)(void); +}; +static struct __pyx_vtabstruct_7asyncpg_8protocol_8protocol_FastReadBuffer *__pyx_vtabptr_7asyncpg_8protocol_8protocol_FastReadBuffer; +static CYTHON_INLINE char const *__pyx_f_7asyncpg_8protocol_8protocol_14FastReadBuffer_read(struct __pyx_obj_7asyncpg_8protocol_8protocol_FastReadBuffer *, Py_ssize_t); +static CYTHON_INLINE char const *__pyx_f_7asyncpg_8protocol_8protocol_14FastReadBuffer_read_all(struct __pyx_obj_7asyncpg_8protocol_8protocol_FastReadBuffer *); +static CYTHON_INLINE struct __pyx_obj_7asyncpg_8protocol_8protocol_FastReadBuffer *__pyx_f_7asyncpg_8protocol_8protocol_14FastReadBuffer_slice_from(struct __pyx_obj_7asyncpg_8protocol_8protocol_FastReadBuffer *, struct __pyx_obj_7asyncpg_8protocol_8protocol_FastReadBuffer *, Py_ssize_t); +static PyObject *__pyx_f_7asyncpg_8protocol_8protocol_14FastReadBuffer__raise_ins_err(struct __pyx_obj_7asyncpg_8protocol_8protocol_FastReadBuffer *, Py_ssize_t, Py_ssize_t); +static struct __pyx_obj_7asyncpg_8protocol_8protocol_FastReadBuffer *__pyx_f_7asyncpg_8protocol_8protocol_14FastReadBuffer_new(void); + + +/* "asyncpg/protocol/codecs/base.pyx":15 + * + * @cython.final + * cdef class Codec: # <<<<<<<<<<<<<< + * + * def __cinit__(self, uint32_t oid): + */ + +struct __pyx_vtabstruct_7asyncpg_8protocol_8protocol_Codec { + PyObject *(*init)(struct __pyx_obj_7asyncpg_8protocol_8protocol_Codec *, PyObject *, PyObject *, PyObject *, enum __pyx_t_7asyncpg_8protocol_8protocol_CodecType, enum __pyx_t_7asyncpg_8protocol_8protocol_CodecFormat, __pyx_t_7asyncpg_8protocol_8protocol_encode_func, __pyx_t_7asyncpg_8protocol_8protocol_decode_func, PyObject *, PyObject *, struct __pyx_obj_7asyncpg_8protocol_8protocol_Codec *, PyObject *, PyObject *, PyObject *, Py_UCS4); + PyObject *(*encode_scalar)(struct __pyx_obj_7asyncpg_8protocol_8protocol_Codec *, struct __pyx_obj_7asyncpg_8protocol_8protocol_ConnectionSettings *, struct __pyx_obj_7asyncpg_8protocol_8protocol_WriteBuffer *, PyObject *); + PyObject *(*encode_array)(struct __pyx_obj_7asyncpg_8protocol_8protocol_Codec *, struct __pyx_obj_7asyncpg_8protocol_8protocol_ConnectionSettings *, struct __pyx_obj_7asyncpg_8protocol_8protocol_WriteBuffer *, PyObject *); + PyObject *(*encode_range)(struct __pyx_obj_7asyncpg_8protocol_8protocol_Codec *, struct __pyx_obj_7asyncpg_8protocol_8protocol_ConnectionSettings *, struct __pyx_obj_7asyncpg_8protocol_8protocol_WriteBuffer *, PyObject *); + PyObject *(*encode_composite)(struct __pyx_obj_7asyncpg_8protocol_8protocol_Codec *, struct __pyx_obj_7asyncpg_8protocol_8protocol_ConnectionSettings *, struct __pyx_obj_7asyncpg_8protocol_8protocol_WriteBuffer *, PyObject *); + PyObject *(*encode_in_python)(struct __pyx_obj_7asyncpg_8protocol_8protocol_Codec *, struct __pyx_obj_7asyncpg_8protocol_8protocol_ConnectionSettings *, struct __pyx_obj_7asyncpg_8protocol_8protocol_WriteBuffer *, PyObject *); + PyObject *(*decode_scalar)(struct __pyx_obj_7asyncpg_8protocol_8protocol_Codec *, struct __pyx_obj_7asyncpg_8protocol_8protocol_ConnectionSettings *, struct __pyx_obj_7asyncpg_8protocol_8protocol_FastReadBuffer *); + PyObject *(*decode_array)(struct __pyx_obj_7asyncpg_8protocol_8protocol_Codec *, struct __pyx_obj_7asyncpg_8protocol_8protocol_ConnectionSettings *, struct __pyx_obj_7asyncpg_8protocol_8protocol_FastReadBuffer *); + PyObject *(*decode_array_text)(struct __pyx_obj_7asyncpg_8protocol_8protocol_Codec *, struct __pyx_obj_7asyncpg_8protocol_8protocol_ConnectionSettings *, struct __pyx_obj_7asyncpg_8protocol_8protocol_FastReadBuffer *); + PyObject *(*decode_range)(struct __pyx_obj_7asyncpg_8protocol_8protocol_Codec *, struct __pyx_obj_7asyncpg_8protocol_8protocol_ConnectionSettings *, struct __pyx_obj_7asyncpg_8protocol_8protocol_FastReadBuffer *); + PyObject *(*decode_composite)(struct __pyx_obj_7asyncpg_8protocol_8protocol_Codec *, struct __pyx_obj_7asyncpg_8protocol_8protocol_ConnectionSettings *, struct __pyx_obj_7asyncpg_8protocol_8protocol_FastReadBuffer *); + PyObject *(*decode_in_python)(struct __pyx_obj_7asyncpg_8protocol_8protocol_Codec *, struct __pyx_obj_7asyncpg_8protocol_8protocol_ConnectionSettings *, struct __pyx_obj_7asyncpg_8protocol_8protocol_FastReadBuffer *); + PyObject *(*encode)(struct __pyx_obj_7asyncpg_8protocol_8protocol_Codec *, struct __pyx_obj_7asyncpg_8protocol_8protocol_ConnectionSettings *, struct __pyx_obj_7asyncpg_8protocol_8protocol_WriteBuffer *, PyObject *); + PyObject *(*decode)(struct __pyx_obj_7asyncpg_8protocol_8protocol_Codec *, struct __pyx_obj_7asyncpg_8protocol_8protocol_ConnectionSettings *, struct __pyx_obj_7asyncpg_8protocol_8protocol_FastReadBuffer *); + PyObject *(*has_encoder)(struct __pyx_obj_7asyncpg_8protocol_8protocol_Codec *); + PyObject *(*has_decoder)(struct __pyx_obj_7asyncpg_8protocol_8protocol_Codec *); + PyObject *(*is_binary)(struct __pyx_obj_7asyncpg_8protocol_8protocol_Codec *); + struct __pyx_obj_7asyncpg_8protocol_8protocol_Codec *(*copy)(struct __pyx_obj_7asyncpg_8protocol_8protocol_Codec *); + struct __pyx_obj_7asyncpg_8protocol_8protocol_Codec *(*new_array_codec)(uint32_t, PyObject *, PyObject *, struct __pyx_obj_7asyncpg_8protocol_8protocol_Codec *, Py_UCS4); + struct __pyx_obj_7asyncpg_8protocol_8protocol_Codec *(*new_range_codec)(uint32_t, PyObject *, PyObject *, struct __pyx_obj_7asyncpg_8protocol_8protocol_Codec *); + struct __pyx_obj_7asyncpg_8protocol_8protocol_Codec *(*new_composite_codec)(uint32_t, PyObject *, PyObject *, PyObject *, PyObject *, PyObject *); + struct __pyx_obj_7asyncpg_8protocol_8protocol_Codec *(*new_python_codec)(uint32_t, PyObject *, PyObject *, PyObject *, PyObject *, PyObject *, enum __pyx_t_7asyncpg_8protocol_8protocol_CodecFormat); +}; +static struct __pyx_vtabstruct_7asyncpg_8protocol_8protocol_Codec *__pyx_vtabptr_7asyncpg_8protocol_8protocol_Codec; +static PyObject *__pyx_f_7asyncpg_8protocol_8protocol_5Codec_init(struct __pyx_obj_7asyncpg_8protocol_8protocol_Codec *, PyObject *, PyObject *, PyObject *, enum __pyx_t_7asyncpg_8protocol_8protocol_CodecType, enum __pyx_t_7asyncpg_8protocol_8protocol_CodecFormat, __pyx_t_7asyncpg_8protocol_8protocol_encode_func, __pyx_t_7asyncpg_8protocol_8protocol_decode_func, PyObject *, PyObject *, struct __pyx_obj_7asyncpg_8protocol_8protocol_Codec *, PyObject *, PyObject *, PyObject *, Py_UCS4); +static PyObject *__pyx_f_7asyncpg_8protocol_8protocol_5Codec_encode_scalar(struct __pyx_obj_7asyncpg_8protocol_8protocol_Codec *, struct __pyx_obj_7asyncpg_8protocol_8protocol_ConnectionSettings *, struct __pyx_obj_7asyncpg_8protocol_8protocol_WriteBuffer *, PyObject *); +static PyObject *__pyx_f_7asyncpg_8protocol_8protocol_5Codec_encode_array(struct __pyx_obj_7asyncpg_8protocol_8protocol_Codec *, struct __pyx_obj_7asyncpg_8protocol_8protocol_ConnectionSettings *, struct __pyx_obj_7asyncpg_8protocol_8protocol_WriteBuffer *, PyObject *); +static PyObject *__pyx_f_7asyncpg_8protocol_8protocol_5Codec_encode_range(struct __pyx_obj_7asyncpg_8protocol_8protocol_Codec *, struct __pyx_obj_7asyncpg_8protocol_8protocol_ConnectionSettings *, struct __pyx_obj_7asyncpg_8protocol_8protocol_WriteBuffer *, PyObject *); +static PyObject *__pyx_f_7asyncpg_8protocol_8protocol_5Codec_encode_composite(struct __pyx_obj_7asyncpg_8protocol_8protocol_Codec *, struct __pyx_obj_7asyncpg_8protocol_8protocol_ConnectionSettings *, struct __pyx_obj_7asyncpg_8protocol_8protocol_WriteBuffer *, PyObject *); +static PyObject *__pyx_f_7asyncpg_8protocol_8protocol_5Codec_encode_in_python(struct __pyx_obj_7asyncpg_8protocol_8protocol_Codec *, struct __pyx_obj_7asyncpg_8protocol_8protocol_ConnectionSettings *, struct __pyx_obj_7asyncpg_8protocol_8protocol_WriteBuffer *, PyObject *); +static PyObject *__pyx_f_7asyncpg_8protocol_8protocol_5Codec_decode_scalar(struct __pyx_obj_7asyncpg_8protocol_8protocol_Codec *, struct __pyx_obj_7asyncpg_8protocol_8protocol_ConnectionSettings *, struct __pyx_obj_7asyncpg_8protocol_8protocol_FastReadBuffer *); +static PyObject *__pyx_f_7asyncpg_8protocol_8protocol_5Codec_decode_array(struct __pyx_obj_7asyncpg_8protocol_8protocol_Codec *, struct __pyx_obj_7asyncpg_8protocol_8protocol_ConnectionSettings *, struct __pyx_obj_7asyncpg_8protocol_8protocol_FastReadBuffer *); +static PyObject *__pyx_f_7asyncpg_8protocol_8protocol_5Codec_decode_array_text(struct __pyx_obj_7asyncpg_8protocol_8protocol_Codec *, struct __pyx_obj_7asyncpg_8protocol_8protocol_ConnectionSettings *, struct __pyx_obj_7asyncpg_8protocol_8protocol_FastReadBuffer *); +static PyObject *__pyx_f_7asyncpg_8protocol_8protocol_5Codec_decode_range(struct __pyx_obj_7asyncpg_8protocol_8protocol_Codec *, struct __pyx_obj_7asyncpg_8protocol_8protocol_ConnectionSettings *, struct __pyx_obj_7asyncpg_8protocol_8protocol_FastReadBuffer *); +static PyObject *__pyx_f_7asyncpg_8protocol_8protocol_5Codec_decode_composite(struct __pyx_obj_7asyncpg_8protocol_8protocol_Codec *, struct __pyx_obj_7asyncpg_8protocol_8protocol_ConnectionSettings *, struct __pyx_obj_7asyncpg_8protocol_8protocol_FastReadBuffer *); +static PyObject *__pyx_f_7asyncpg_8protocol_8protocol_5Codec_decode_in_python(struct __pyx_obj_7asyncpg_8protocol_8protocol_Codec *, struct __pyx_obj_7asyncpg_8protocol_8protocol_ConnectionSettings *, struct __pyx_obj_7asyncpg_8protocol_8protocol_FastReadBuffer *); +static CYTHON_INLINE PyObject *__pyx_f_7asyncpg_8protocol_8protocol_5Codec_encode(struct __pyx_obj_7asyncpg_8protocol_8protocol_Codec *, struct __pyx_obj_7asyncpg_8protocol_8protocol_ConnectionSettings *, struct __pyx_obj_7asyncpg_8protocol_8protocol_WriteBuffer *, PyObject *); +static CYTHON_INLINE PyObject *__pyx_f_7asyncpg_8protocol_8protocol_5Codec_decode(struct __pyx_obj_7asyncpg_8protocol_8protocol_Codec *, struct __pyx_obj_7asyncpg_8protocol_8protocol_ConnectionSettings *, struct __pyx_obj_7asyncpg_8protocol_8protocol_FastReadBuffer *); +static PyObject *__pyx_f_7asyncpg_8protocol_8protocol_5Codec_has_encoder(struct __pyx_obj_7asyncpg_8protocol_8protocol_Codec *); +static PyObject *__pyx_f_7asyncpg_8protocol_8protocol_5Codec_has_decoder(struct __pyx_obj_7asyncpg_8protocol_8protocol_Codec *); +static PyObject *__pyx_f_7asyncpg_8protocol_8protocol_5Codec_is_binary(struct __pyx_obj_7asyncpg_8protocol_8protocol_Codec *); +static CYTHON_INLINE struct __pyx_obj_7asyncpg_8protocol_8protocol_Codec *__pyx_f_7asyncpg_8protocol_8protocol_5Codec_copy(struct __pyx_obj_7asyncpg_8protocol_8protocol_Codec *); +static struct __pyx_obj_7asyncpg_8protocol_8protocol_Codec *__pyx_f_7asyncpg_8protocol_8protocol_5Codec_new_array_codec(uint32_t, PyObject *, PyObject *, struct __pyx_obj_7asyncpg_8protocol_8protocol_Codec *, Py_UCS4); +static struct __pyx_obj_7asyncpg_8protocol_8protocol_Codec *__pyx_f_7asyncpg_8protocol_8protocol_5Codec_new_range_codec(uint32_t, PyObject *, PyObject *, struct __pyx_obj_7asyncpg_8protocol_8protocol_Codec *); +static struct __pyx_obj_7asyncpg_8protocol_8protocol_Codec *__pyx_f_7asyncpg_8protocol_8protocol_5Codec_new_composite_codec(uint32_t, PyObject *, PyObject *, PyObject *, PyObject *, PyObject *); +static struct __pyx_obj_7asyncpg_8protocol_8protocol_Codec *__pyx_f_7asyncpg_8protocol_8protocol_5Codec_new_python_codec(uint32_t, PyObject *, PyObject *, PyObject *, PyObject *, PyObject *, enum __pyx_t_7asyncpg_8protocol_8protocol_CodecFormat); + + +/* "asyncpg/protocol/codecs/base.pyx":318 + * + * + * cdef class DataCodecConfig: # <<<<<<<<<<<<<< + * def __init__(self, cache_key): + * try: + */ + +struct __pyx_vtabstruct_7asyncpg_8protocol_8protocol_DataCodecConfig { + struct __pyx_obj_7asyncpg_8protocol_8protocol_Codec *(*get_codec)(struct __pyx_obj_7asyncpg_8protocol_8protocol_DataCodecConfig *, uint32_t, enum __pyx_t_7asyncpg_8protocol_8protocol_CodecFormat); +}; +static struct __pyx_vtabstruct_7asyncpg_8protocol_8protocol_DataCodecConfig *__pyx_vtabptr_7asyncpg_8protocol_8protocol_DataCodecConfig; +static CYTHON_INLINE struct __pyx_obj_7asyncpg_8protocol_8protocol_Codec *__pyx_f_7asyncpg_8protocol_8protocol_15DataCodecConfig_get_codec(struct __pyx_obj_7asyncpg_8protocol_8protocol_DataCodecConfig *, uint32_t, enum __pyx_t_7asyncpg_8protocol_8protocol_CodecFormat); + + +/* "asyncpg/protocol/settings.pyx":9 + * + * @cython.final + * cdef class ConnectionSettings: # <<<<<<<<<<<<<< + * + * def __cinit__(self, conn_key): + */ + +struct __pyx_vtabstruct_7asyncpg_8protocol_8protocol_ConnectionSettings { + PyObject *(*add_setting)(struct __pyx_obj_7asyncpg_8protocol_8protocol_ConnectionSettings *, PyObject *, PyObject *); + PyObject *(*is_encoding_utf8)(struct __pyx_obj_7asyncpg_8protocol_8protocol_ConnectionSettings *); + PyObject *(*get_text_codec)(struct __pyx_obj_7asyncpg_8protocol_8protocol_ConnectionSettings *, int __pyx_skip_dispatch); + PyObject *(*register_data_types)(struct __pyx_obj_7asyncpg_8protocol_8protocol_ConnectionSettings *, PyObject *, int __pyx_skip_dispatch); + PyObject *(*add_python_codec)(struct __pyx_obj_7asyncpg_8protocol_8protocol_ConnectionSettings *, PyObject *, PyObject *, PyObject *, PyObject *, PyObject *, PyObject *, PyObject *, int __pyx_skip_dispatch); + PyObject *(*set_builtin_type_codec)(struct __pyx_obj_7asyncpg_8protocol_8protocol_ConnectionSettings *, PyObject *, PyObject *, PyObject *, PyObject *, PyObject *, int __pyx_skip_dispatch); + struct __pyx_obj_7asyncpg_8protocol_8protocol_Codec *(*get_data_codec)(struct __pyx_obj_7asyncpg_8protocol_8protocol_ConnectionSettings *, uint32_t, int __pyx_skip_dispatch, struct __pyx_opt_args_7asyncpg_8protocol_8protocol_18ConnectionSettings_get_data_codec *__pyx_optional_args); +}; +static struct __pyx_vtabstruct_7asyncpg_8protocol_8protocol_ConnectionSettings *__pyx_vtabptr_7asyncpg_8protocol_8protocol_ConnectionSettings; +static PyObject *__pyx_f_7asyncpg_8protocol_8protocol_18ConnectionSettings_add_setting(struct __pyx_obj_7asyncpg_8protocol_8protocol_ConnectionSettings *, PyObject *, PyObject *); +static CYTHON_INLINE PyObject *__pyx_f_7asyncpg_8protocol_8protocol_18ConnectionSettings_is_encoding_utf8(struct __pyx_obj_7asyncpg_8protocol_8protocol_ConnectionSettings *); +static CYTHON_INLINE PyObject *__pyx_f_7asyncpg_8protocol_8protocol_18ConnectionSettings_get_text_codec(struct __pyx_obj_7asyncpg_8protocol_8protocol_ConnectionSettings *, int __pyx_skip_dispatch); +static CYTHON_INLINE PyObject *__pyx_f_7asyncpg_8protocol_8protocol_18ConnectionSettings_register_data_types(struct __pyx_obj_7asyncpg_8protocol_8protocol_ConnectionSettings *, PyObject *, int __pyx_skip_dispatch); +static CYTHON_INLINE PyObject *__pyx_f_7asyncpg_8protocol_8protocol_18ConnectionSettings_add_python_codec(struct __pyx_obj_7asyncpg_8protocol_8protocol_ConnectionSettings *, PyObject *, PyObject *, PyObject *, PyObject *, PyObject *, PyObject *, PyObject *, int __pyx_skip_dispatch); +static CYTHON_INLINE PyObject *__pyx_f_7asyncpg_8protocol_8protocol_18ConnectionSettings_set_builtin_type_codec(struct __pyx_obj_7asyncpg_8protocol_8protocol_ConnectionSettings *, PyObject *, PyObject *, PyObject *, PyObject *, PyObject *, int __pyx_skip_dispatch); +static CYTHON_INLINE struct __pyx_obj_7asyncpg_8protocol_8protocol_Codec *__pyx_f_7asyncpg_8protocol_8protocol_18ConnectionSettings_get_data_codec(struct __pyx_obj_7asyncpg_8protocol_8protocol_ConnectionSettings *, uint32_t, int __pyx_skip_dispatch, struct __pyx_opt_args_7asyncpg_8protocol_8protocol_18ConnectionSettings_get_data_codec *__pyx_optional_args); + + +/* "asyncpg/protocol/coreproto.pyx":11 + * + * + * cdef class CoreProtocol: # <<<<<<<<<<<<<< + * + * def __init__(self, con_args): + */ + +struct __pyx_vtabstruct_7asyncpg_8protocol_8protocol_CoreProtocol { + PyObject *(*_process__auth)(struct __pyx_obj_7asyncpg_8protocol_8protocol_CoreProtocol *, char); + PyObject *(*_process__prepare)(struct __pyx_obj_7asyncpg_8protocol_8protocol_CoreProtocol *, char); + PyObject *(*_process__bind_execute)(struct __pyx_obj_7asyncpg_8protocol_8protocol_CoreProtocol *, char); + PyObject *(*_process__bind_execute_many)(struct __pyx_obj_7asyncpg_8protocol_8protocol_CoreProtocol *, char); + PyObject *(*_process__close_stmt_portal)(struct __pyx_obj_7asyncpg_8protocol_8protocol_CoreProtocol *, char); + PyObject *(*_process__simple_query)(struct __pyx_obj_7asyncpg_8protocol_8protocol_CoreProtocol *, char); + PyObject *(*_process__bind)(struct __pyx_obj_7asyncpg_8protocol_8protocol_CoreProtocol *, char); + PyObject *(*_parse_msg_authentication)(struct __pyx_obj_7asyncpg_8protocol_8protocol_CoreProtocol *); + PyObject *(*_parse_msg_parameter_status)(struct __pyx_obj_7asyncpg_8protocol_8protocol_CoreProtocol *); + PyObject *(*_parse_msg_notification)(struct __pyx_obj_7asyncpg_8protocol_8protocol_CoreProtocol *); + PyObject *(*_parse_msg_backend_key_data)(struct __pyx_obj_7asyncpg_8protocol_8protocol_CoreProtocol *); + PyObject *(*_parse_msg_ready_for_query)(struct __pyx_obj_7asyncpg_8protocol_8protocol_CoreProtocol *); + PyObject *(*_parse_data_msgs)(struct __pyx_obj_7asyncpg_8protocol_8protocol_CoreProtocol *); + PyObject *(*_parse_msg_error_response)(struct __pyx_obj_7asyncpg_8protocol_8protocol_CoreProtocol *, PyObject *); + PyObject *(*_parse_msg_command_complete)(struct __pyx_obj_7asyncpg_8protocol_8protocol_CoreProtocol *); + PyObject *(*_auth_password_message_cleartext)(struct __pyx_obj_7asyncpg_8protocol_8protocol_CoreProtocol *); + PyObject *(*_auth_password_message_md5)(struct __pyx_obj_7asyncpg_8protocol_8protocol_CoreProtocol *, PyObject *); + PyObject *(*_write)(struct __pyx_obj_7asyncpg_8protocol_8protocol_CoreProtocol *, PyObject *); + PyObject *(*_write_sync_message)(struct __pyx_obj_7asyncpg_8protocol_8protocol_CoreProtocol *); + PyObject *(*_read_server_messages)(struct __pyx_obj_7asyncpg_8protocol_8protocol_CoreProtocol *); + PyObject *(*_push_result)(struct __pyx_obj_7asyncpg_8protocol_8protocol_CoreProtocol *); + PyObject *(*_reset_result)(struct __pyx_obj_7asyncpg_8protocol_8protocol_CoreProtocol *); + PyObject *(*_set_state)(struct __pyx_obj_7asyncpg_8protocol_8protocol_CoreProtocol *, enum __pyx_t_7asyncpg_8protocol_8protocol_ProtocolState); + PyObject *(*_ensure_connected)(struct __pyx_obj_7asyncpg_8protocol_8protocol_CoreProtocol *); + struct __pyx_obj_7asyncpg_8protocol_8protocol_WriteBuffer *(*_build_bind_message)(struct __pyx_obj_7asyncpg_8protocol_8protocol_CoreProtocol *, PyObject *, PyObject *, struct __pyx_obj_7asyncpg_8protocol_8protocol_WriteBuffer *); + PyObject *(*_connect)(struct __pyx_obj_7asyncpg_8protocol_8protocol_CoreProtocol *); + PyObject *(*_prepare)(struct __pyx_obj_7asyncpg_8protocol_8protocol_CoreProtocol *, PyObject *, PyObject *); + PyObject *(*_send_bind_message)(struct __pyx_obj_7asyncpg_8protocol_8protocol_CoreProtocol *, PyObject *, PyObject *, struct __pyx_obj_7asyncpg_8protocol_8protocol_WriteBuffer *, int32_t); + PyObject *(*_bind_execute)(struct __pyx_obj_7asyncpg_8protocol_8protocol_CoreProtocol *, PyObject *, PyObject *, struct __pyx_obj_7asyncpg_8protocol_8protocol_WriteBuffer *, int32_t); + PyObject *(*_bind_execute_many)(struct __pyx_obj_7asyncpg_8protocol_8protocol_CoreProtocol *, PyObject *, PyObject *, PyObject *); + PyObject *(*_bind)(struct __pyx_obj_7asyncpg_8protocol_8protocol_CoreProtocol *, PyObject *, PyObject *, struct __pyx_obj_7asyncpg_8protocol_8protocol_WriteBuffer *); + PyObject *(*_execute)(struct __pyx_obj_7asyncpg_8protocol_8protocol_CoreProtocol *, PyObject *, int32_t); + PyObject *(*_close)(struct __pyx_obj_7asyncpg_8protocol_8protocol_CoreProtocol *, PyObject *, int); + PyObject *(*_simple_query)(struct __pyx_obj_7asyncpg_8protocol_8protocol_CoreProtocol *, PyObject *); + PyObject *(*_terminate)(struct __pyx_obj_7asyncpg_8protocol_8protocol_CoreProtocol *); + PyObject *(*_decode_row)(struct __pyx_obj_7asyncpg_8protocol_8protocol_CoreProtocol *, char const *, Py_ssize_t); + PyObject *(*_on_result)(struct __pyx_obj_7asyncpg_8protocol_8protocol_CoreProtocol *); + PyObject *(*_on_notification)(struct __pyx_obj_7asyncpg_8protocol_8protocol_CoreProtocol *, PyObject *, PyObject *, PyObject *); + PyObject *(*_set_server_parameter)(struct __pyx_obj_7asyncpg_8protocol_8protocol_CoreProtocol *, PyObject *, PyObject *); + PyObject *(*_on_connection_lost)(struct __pyx_obj_7asyncpg_8protocol_8protocol_CoreProtocol *, PyObject *); +}; +static struct __pyx_vtabstruct_7asyncpg_8protocol_8protocol_CoreProtocol *__pyx_vtabptr_7asyncpg_8protocol_8protocol_CoreProtocol; +static CYTHON_INLINE PyObject *__pyx_f_7asyncpg_8protocol_8protocol_12CoreProtocol__write_sync_message(struct __pyx_obj_7asyncpg_8protocol_8protocol_CoreProtocol *); + + +/* "asyncpg/protocol/prepared_stmt.pyx":9 + * + * @cython.final + * cdef class PreparedStatementState: # <<<<<<<<<<<<<< + * + * def __cinit__(self, str name, str query, BaseProtocol protocol): + */ + +struct __pyx_vtabstruct_7asyncpg_8protocol_8protocol_PreparedStatementState { + PyObject *(*_encode_bind_msg)(struct __pyx_obj_7asyncpg_8protocol_8protocol_PreparedStatementState *, PyObject *); + PyObject *(*_ensure_rows_decoder)(struct __pyx_obj_7asyncpg_8protocol_8protocol_PreparedStatementState *); + PyObject *(*_ensure_args_encoder)(struct __pyx_obj_7asyncpg_8protocol_8protocol_PreparedStatementState *); + PyObject *(*_set_row_desc)(struct __pyx_obj_7asyncpg_8protocol_8protocol_PreparedStatementState *, PyObject *); + PyObject *(*_set_args_desc)(struct __pyx_obj_7asyncpg_8protocol_8protocol_PreparedStatementState *, PyObject *); + PyObject *(*_decode_row)(struct __pyx_obj_7asyncpg_8protocol_8protocol_PreparedStatementState *, char const *, Py_ssize_t); +}; +static struct __pyx_vtabstruct_7asyncpg_8protocol_8protocol_PreparedStatementState *__pyx_vtabptr_7asyncpg_8protocol_8protocol_PreparedStatementState; +static PyObject *__pyx_f_7asyncpg_8protocol_8protocol_22PreparedStatementState__encode_bind_msg(struct __pyx_obj_7asyncpg_8protocol_8protocol_PreparedStatementState *, PyObject *); +static PyObject *__pyx_f_7asyncpg_8protocol_8protocol_22PreparedStatementState__ensure_rows_decoder(struct __pyx_obj_7asyncpg_8protocol_8protocol_PreparedStatementState *); +static PyObject *__pyx_f_7asyncpg_8protocol_8protocol_22PreparedStatementState__ensure_args_encoder(struct __pyx_obj_7asyncpg_8protocol_8protocol_PreparedStatementState *); +static PyObject *__pyx_f_7asyncpg_8protocol_8protocol_22PreparedStatementState__set_row_desc(struct __pyx_obj_7asyncpg_8protocol_8protocol_PreparedStatementState *, PyObject *); +static PyObject *__pyx_f_7asyncpg_8protocol_8protocol_22PreparedStatementState__set_args_desc(struct __pyx_obj_7asyncpg_8protocol_8protocol_PreparedStatementState *, PyObject *); +static PyObject *__pyx_f_7asyncpg_8protocol_8protocol_22PreparedStatementState__decode_row(struct __pyx_obj_7asyncpg_8protocol_8protocol_PreparedStatementState *, char const *, Py_ssize_t); + + +/* "asyncpg/protocol/protocol.pyx":82 + * + * + * cdef class BaseProtocol(CoreProtocol): # <<<<<<<<<<<<<< + * def __init__(self, addr, connected_fut, con_args, loop): + * CoreProtocol.__init__(self, con_args) + */ + +struct __pyx_vtabstruct_7asyncpg_8protocol_8protocol_BaseProtocol { + struct __pyx_vtabstruct_7asyncpg_8protocol_8protocol_CoreProtocol __pyx_base; + PyObject *(*_ensure_clear_state)(struct __pyx_obj_7asyncpg_8protocol_8protocol_BaseProtocol *); + PyObject *(*_new_waiter)(struct __pyx_obj_7asyncpg_8protocol_8protocol_BaseProtocol *, PyObject *); + PyObject *(*_on_result__connect)(struct __pyx_obj_7asyncpg_8protocol_8protocol_BaseProtocol *, PyObject *); + PyObject *(*_on_result__prepare)(struct __pyx_obj_7asyncpg_8protocol_8protocol_BaseProtocol *, PyObject *); + PyObject *(*_on_result__bind_and_exec)(struct __pyx_obj_7asyncpg_8protocol_8protocol_BaseProtocol *, PyObject *); + PyObject *(*_on_result__close_stmt_or_portal)(struct __pyx_obj_7asyncpg_8protocol_8protocol_BaseProtocol *, PyObject *); + PyObject *(*_on_result__simple_query)(struct __pyx_obj_7asyncpg_8protocol_8protocol_BaseProtocol *, PyObject *); + PyObject *(*_on_result__bind)(struct __pyx_obj_7asyncpg_8protocol_8protocol_BaseProtocol *, PyObject *); + PyObject *(*_handle_waiter_on_connection_lost)(struct __pyx_obj_7asyncpg_8protocol_8protocol_BaseProtocol *, PyObject *); + PyObject *(*_dispatch_result)(struct __pyx_obj_7asyncpg_8protocol_8protocol_BaseProtocol *); +}; +static struct __pyx_vtabstruct_7asyncpg_8protocol_8protocol_BaseProtocol *__pyx_vtabptr_7asyncpg_8protocol_8protocol_BaseProtocol; + +/* --- Runtime support code (head) --- */ +/* Refnanny.proto */ +#ifndef CYTHON_REFNANNY + #define CYTHON_REFNANNY 0 +#endif +#if CYTHON_REFNANNY + typedef struct { + void (*INCREF)(void*, PyObject*, int); + void (*DECREF)(void*, PyObject*, int); + void (*GOTREF)(void*, PyObject*, int); + void (*GIVEREF)(void*, PyObject*, int); + void* (*SetupContext)(const char*, int, const char*); + void (*FinishContext)(void**); + } __Pyx_RefNannyAPIStruct; + static __Pyx_RefNannyAPIStruct *__Pyx_RefNanny = NULL; + static __Pyx_RefNannyAPIStruct *__Pyx_RefNannyImportAPI(const char *modname); + #define __Pyx_RefNannyDeclarations void *__pyx_refnanny = NULL; +#ifdef WITH_THREAD + #define __Pyx_RefNannySetupContext(name, acquire_gil)\ + if (acquire_gil) {\ + PyGILState_STATE __pyx_gilstate_save = PyGILState_Ensure();\ + __pyx_refnanny = __Pyx_RefNanny->SetupContext((name), __LINE__, __FILE__);\ + PyGILState_Release(__pyx_gilstate_save);\ + } else {\ + __pyx_refnanny = __Pyx_RefNanny->SetupContext((name), __LINE__, __FILE__);\ + } +#else + #define __Pyx_RefNannySetupContext(name, acquire_gil)\ + __pyx_refnanny = __Pyx_RefNanny->SetupContext((name), __LINE__, __FILE__) +#endif + #define __Pyx_RefNannyFinishContext()\ + __Pyx_RefNanny->FinishContext(&__pyx_refnanny) + #define __Pyx_INCREF(r) __Pyx_RefNanny->INCREF(__pyx_refnanny, (PyObject *)(r), __LINE__) + #define __Pyx_DECREF(r) __Pyx_RefNanny->DECREF(__pyx_refnanny, (PyObject *)(r), __LINE__) + #define __Pyx_GOTREF(r) __Pyx_RefNanny->GOTREF(__pyx_refnanny, (PyObject *)(r), __LINE__) + #define __Pyx_GIVEREF(r) __Pyx_RefNanny->GIVEREF(__pyx_refnanny, (PyObject *)(r), __LINE__) + #define __Pyx_XINCREF(r) do { if((r) != NULL) {__Pyx_INCREF(r); }} while(0) + #define __Pyx_XDECREF(r) do { if((r) != NULL) {__Pyx_DECREF(r); }} while(0) + #define __Pyx_XGOTREF(r) do { if((r) != NULL) {__Pyx_GOTREF(r); }} while(0) + #define __Pyx_XGIVEREF(r) do { if((r) != NULL) {__Pyx_GIVEREF(r);}} while(0) +#else + #define __Pyx_RefNannyDeclarations + #define __Pyx_RefNannySetupContext(name, acquire_gil) + #define __Pyx_RefNannyFinishContext() + #define __Pyx_INCREF(r) Py_INCREF(r) + #define __Pyx_DECREF(r) Py_DECREF(r) + #define __Pyx_GOTREF(r) + #define __Pyx_GIVEREF(r) + #define __Pyx_XINCREF(r) Py_XINCREF(r) + #define __Pyx_XDECREF(r) Py_XDECREF(r) + #define __Pyx_XGOTREF(r) + #define __Pyx_XGIVEREF(r) +#endif +#define __Pyx_XDECREF_SET(r, v) do {\ + PyObject *tmp = (PyObject *) r;\ + r = v; __Pyx_XDECREF(tmp);\ + } while (0) +#define __Pyx_DECREF_SET(r, v) do {\ + PyObject *tmp = (PyObject *) r;\ + r = v; __Pyx_DECREF(tmp);\ + } while (0) +#define __Pyx_CLEAR(r) do { PyObject* tmp = ((PyObject*)(r)); r = NULL; __Pyx_DECREF(tmp);} while(0) +#define __Pyx_XCLEAR(r) do { if((r) != NULL) {PyObject* tmp = ((PyObject*)(r)); r = NULL; __Pyx_DECREF(tmp);}} while(0) + +/* PyObjectGetAttrStr.proto */ +#if CYTHON_USE_TYPE_SLOTS +static CYTHON_INLINE PyObject* __Pyx_PyObject_GetAttrStr(PyObject* obj, PyObject* attr_name) { + PyTypeObject* tp = Py_TYPE(obj); + if (likely(tp->tp_getattro)) + return tp->tp_getattro(obj, attr_name); +#if PY_MAJOR_VERSION < 3 + if (likely(tp->tp_getattr)) + return tp->tp_getattr(obj, PyString_AS_STRING(attr_name)); +#endif + return PyObject_GetAttr(obj, attr_name); +} +#else +#define __Pyx_PyObject_GetAttrStr(o,n) PyObject_GetAttr(o,n) +#endif + +/* GetBuiltinName.proto */ +static PyObject *__Pyx_GetBuiltinName(PyObject *name); + +/* dict_getitem_default.proto */ +static PyObject* __Pyx_PyDict_GetItemDefault(PyObject* d, PyObject* key, PyObject* default_value); + +/* PyCFunctionFastCall.proto */ +#if CYTHON_FAST_PYCCALL +static CYTHON_INLINE PyObject *__Pyx_PyCFunction_FastCall(PyObject *func, PyObject **args, Py_ssize_t nargs); +#else +#define __Pyx_PyCFunction_FastCall(func, args, nargs) (assert(0), NULL) +#endif + +/* PyFunctionFastCall.proto */ +#if CYTHON_FAST_PYCALL +#define __Pyx_PyFunction_FastCall(func, args, nargs)\ + __Pyx_PyFunction_FastCallDict((func), (args), (nargs), NULL) +#if 1 || PY_VERSION_HEX < 0x030600B1 +static PyObject *__Pyx_PyFunction_FastCallDict(PyObject *func, PyObject **args, int nargs, PyObject *kwargs); +#else +#define __Pyx_PyFunction_FastCallDict(func, args, nargs, kwargs) _PyFunction_FastCallDict(func, args, nargs, kwargs) +#endif +#endif + +/* PyObjectCall.proto */ +#if CYTHON_COMPILING_IN_CPYTHON +static CYTHON_INLINE PyObject* __Pyx_PyObject_Call(PyObject *func, PyObject *arg, PyObject *kw); +#else +#define __Pyx_PyObject_Call(func, arg, kw) PyObject_Call(func, arg, kw) +#endif + +/* PyObjectCallMethO.proto */ +#if CYTHON_COMPILING_IN_CPYTHON +static CYTHON_INLINE PyObject* __Pyx_PyObject_CallMethO(PyObject *func, PyObject *arg); +#endif + +/* PyObjectCallOneArg.proto */ +static CYTHON_INLINE PyObject* __Pyx_PyObject_CallOneArg(PyObject *func, PyObject *arg); + +/* PyObjectCallNoArg.proto */ +#if CYTHON_COMPILING_IN_CPYTHON +static CYTHON_INLINE PyObject* __Pyx_PyObject_CallNoArg(PyObject *func); +#else +#define __Pyx_PyObject_CallNoArg(func) __Pyx_PyObject_Call(func, __pyx_empty_tuple, NULL) +#endif + +/* RaiseDoubleKeywords.proto */ +static void __Pyx_RaiseDoubleKeywordsError(const char* func_name, PyObject* kw_name); + +/* ParseKeywords.proto */ +static int __Pyx_ParseOptionalKeywords(PyObject *kwds, PyObject **argnames[],\ + PyObject *kwds2, PyObject *values[], Py_ssize_t num_pos_args,\ + const char* function_name); + +/* RaiseArgTupleInvalid.proto */ +static void __Pyx_RaiseArgtupleInvalid(const char* func_name, int exact, + Py_ssize_t num_min, Py_ssize_t num_max, Py_ssize_t num_found); + +/* GetModuleGlobalName.proto */ +static CYTHON_INLINE PyObject *__Pyx_GetModuleGlobalName(PyObject *name); + +/* IncludeStringH.proto */ +#include + +/* BytesEquals.proto */ +static CYTHON_INLINE int __Pyx_PyBytes_Equals(PyObject* s1, PyObject* s2, int equals); + +/* UnicodeEquals.proto */ +static CYTHON_INLINE int __Pyx_PyUnicode_Equals(PyObject* s1, PyObject* s2, int equals); + +/* DictGetItem.proto */ +#if PY_MAJOR_VERSION >= 3 && !CYTHON_COMPILING_IN_PYPY +static PyObject *__Pyx_PyDict_GetItem(PyObject *d, PyObject* key) { + PyObject *value; + value = PyDict_GetItemWithError(d, key); + if (unlikely(!value)) { + if (!PyErr_Occurred()) { + PyObject* args = PyTuple_Pack(1, key); + if (likely(args)) + PyErr_SetObject(PyExc_KeyError, args); + Py_XDECREF(args); + } + return NULL; + } + Py_INCREF(value); + return value; +} +#else + #define __Pyx_PyDict_GetItem(d, key) PyObject_GetItem(d, key) +#endif + +/* PyThreadStateGet.proto */ +#if CYTHON_FAST_THREAD_STATE +#define __Pyx_PyThreadState_declare PyThreadState *__pyx_tstate; +#define __Pyx_PyThreadState_assign __pyx_tstate = PyThreadState_GET(); +#else +#define __Pyx_PyThreadState_declare +#define __Pyx_PyThreadState_assign +#endif + +/* SaveResetException.proto */ +#if CYTHON_FAST_THREAD_STATE +#define __Pyx_ExceptionSave(type, value, tb) __Pyx__ExceptionSave(__pyx_tstate, type, value, tb) +static CYTHON_INLINE void __Pyx__ExceptionSave(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb); +#define __Pyx_ExceptionReset(type, value, tb) __Pyx__ExceptionReset(__pyx_tstate, type, value, tb) +static CYTHON_INLINE void __Pyx__ExceptionReset(PyThreadState *tstate, PyObject *type, PyObject *value, PyObject *tb); +#else +#define __Pyx_ExceptionSave(type, value, tb) PyErr_GetExcInfo(type, value, tb) +#define __Pyx_ExceptionReset(type, value, tb) PyErr_SetExcInfo(type, value, tb) +#endif + +/* PyErrExceptionMatches.proto */ +#if CYTHON_FAST_THREAD_STATE +#define __Pyx_PyErr_ExceptionMatches(err) __Pyx_PyErr_ExceptionMatchesInState(__pyx_tstate, err) +static CYTHON_INLINE int __Pyx_PyErr_ExceptionMatchesInState(PyThreadState* tstate, PyObject* err); +#else +#define __Pyx_PyErr_ExceptionMatches(err) PyErr_ExceptionMatches(err) +#endif + +/* GetException.proto */ +#if CYTHON_FAST_THREAD_STATE +#define __Pyx_GetException(type, value, tb) __Pyx__GetException(__pyx_tstate, type, value, tb) +static int __Pyx__GetException(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb); +#else +static int __Pyx_GetException(PyObject **type, PyObject **value, PyObject **tb); +#endif + +/* PyErrFetchRestore.proto */ +#if CYTHON_FAST_THREAD_STATE +#define __Pyx_ErrRestoreWithState(type, value, tb) __Pyx_ErrRestoreInState(PyThreadState_GET(), type, value, tb) +#define __Pyx_ErrFetchWithState(type, value, tb) __Pyx_ErrFetchInState(PyThreadState_GET(), type, value, tb) +#define __Pyx_ErrRestore(type, value, tb) __Pyx_ErrRestoreInState(__pyx_tstate, type, value, tb) +#define __Pyx_ErrFetch(type, value, tb) __Pyx_ErrFetchInState(__pyx_tstate, type, value, tb) +static CYTHON_INLINE void __Pyx_ErrRestoreInState(PyThreadState *tstate, PyObject *type, PyObject *value, PyObject *tb); +static CYTHON_INLINE void __Pyx_ErrFetchInState(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb); +#else +#define __Pyx_ErrRestoreWithState(type, value, tb) PyErr_Restore(type, value, tb) +#define __Pyx_ErrFetchWithState(type, value, tb) PyErr_Fetch(type, value, tb) +#define __Pyx_ErrRestore(type, value, tb) PyErr_Restore(type, value, tb) +#define __Pyx_ErrFetch(type, value, tb) PyErr_Fetch(type, value, tb) +#endif + +/* RaiseException.proto */ +static void __Pyx_Raise(PyObject *type, PyObject *value, PyObject *tb, PyObject *cause); + +/* ExtTypeTest.proto */ +static CYTHON_INLINE int __Pyx_TypeTest(PyObject *obj, PyTypeObject *type); + +/* KeywordStringCheck.proto */ +static CYTHON_INLINE int __Pyx_CheckKeywordStrings(PyObject *kwdict, const char* function_name, int kw_allowed); + +/* WriteUnraisableException.proto */ +static void __Pyx_WriteUnraisable(const char *name, int clineno, + int lineno, const char *filename, + int full_traceback, int nogil); + +/* GetItemInt.proto */ +#define __Pyx_GetItemInt(o, i, type, is_signed, to_py_func, is_list, wraparound, boundscheck)\ + (__Pyx_fits_Py_ssize_t(i, type, is_signed) ?\ + __Pyx_GetItemInt_Fast(o, (Py_ssize_t)i, is_list, wraparound, boundscheck) :\ + (is_list ? (PyErr_SetString(PyExc_IndexError, "list index out of range"), (PyObject*)NULL) :\ + __Pyx_GetItemInt_Generic(o, to_py_func(i)))) +#define __Pyx_GetItemInt_List(o, i, type, is_signed, to_py_func, is_list, wraparound, boundscheck)\ + (__Pyx_fits_Py_ssize_t(i, type, is_signed) ?\ + __Pyx_GetItemInt_List_Fast(o, (Py_ssize_t)i, wraparound, boundscheck) :\ + (PyErr_SetString(PyExc_IndexError, "list index out of range"), (PyObject*)NULL)) +static CYTHON_INLINE PyObject *__Pyx_GetItemInt_List_Fast(PyObject *o, Py_ssize_t i, + int wraparound, int boundscheck); +#define __Pyx_GetItemInt_Tuple(o, i, type, is_signed, to_py_func, is_list, wraparound, boundscheck)\ + (__Pyx_fits_Py_ssize_t(i, type, is_signed) ?\ + __Pyx_GetItemInt_Tuple_Fast(o, (Py_ssize_t)i, wraparound, boundscheck) :\ + (PyErr_SetString(PyExc_IndexError, "tuple index out of range"), (PyObject*)NULL)) +static CYTHON_INLINE PyObject *__Pyx_GetItemInt_Tuple_Fast(PyObject *o, Py_ssize_t i, + int wraparound, int boundscheck); +static CYTHON_INLINE PyObject *__Pyx_GetItemInt_Generic(PyObject *o, PyObject* j); +static CYTHON_INLINE PyObject *__Pyx_GetItemInt_Fast(PyObject *o, Py_ssize_t i, + int is_list, int wraparound, int boundscheck); + +/* None.proto */ +static CYTHON_INLINE void __Pyx_RaiseUnboundLocalError(const char *varname); + +/* SliceObject.proto */ +static CYTHON_INLINE PyObject* __Pyx_PyObject_GetSlice( + PyObject* obj, Py_ssize_t cstart, Py_ssize_t cstop, + PyObject** py_start, PyObject** py_stop, PyObject** py_slice, + int has_cstart, int has_cstop, int wraparound); + +/* ListAppend.proto */ +#if CYTHON_USE_PYLIST_INTERNALS && CYTHON_ASSUME_SAFE_MACROS +static CYTHON_INLINE int __Pyx_PyList_Append(PyObject* list, PyObject* x) { + PyListObject* L = (PyListObject*) list; + Py_ssize_t len = Py_SIZE(list); + if (likely(L->allocated > len) & likely(len > (L->allocated >> 1))) { + Py_INCREF(x); + PyList_SET_ITEM(list, len, x); + Py_SIZE(list) = len+1; + return 0; + } + return PyList_Append(list, x); +} +#else +#define __Pyx_PyList_Append(L,x) PyList_Append(L,x) +#endif + +/* PyIntBinop.proto */ +#if !CYTHON_COMPILING_IN_PYPY +static PyObject* __Pyx_PyInt_AddObjC(PyObject *op1, PyObject *op2, long intval, int inplace); +#else +#define __Pyx_PyInt_AddObjC(op1, op2, intval, inplace)\ + (inplace ? PyNumber_InPlaceAdd(op1, op2) : PyNumber_Add(op1, op2)) +#endif + +/* PyDictContains.proto */ +static CYTHON_INLINE int __Pyx_PyDict_ContainsTF(PyObject* item, PyObject* dict, int eq) { + int result = PyDict_Contains(dict, item); + return unlikely(result < 0) ? result : (result == (eq == Py_EQ)); +} + +/* py_dict_clear.proto */ +#define __Pyx_PyDict_Clear(d) (PyDict_Clear(d), 0) + +/* PySequenceContains.proto */ +static CYTHON_INLINE int __Pyx_PySequence_ContainsTF(PyObject* item, PyObject* seq, int eq) { + int result = PySequence_Contains(seq, item); + return unlikely(result < 0) ? result : (result == (eq == Py_EQ)); +} + +/* SwapException.proto */ +#if CYTHON_FAST_THREAD_STATE +#define __Pyx_ExceptionSwap(type, value, tb) __Pyx__ExceptionSwap(__pyx_tstate, type, value, tb) +static CYTHON_INLINE void __Pyx__ExceptionSwap(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb); +#else +static CYTHON_INLINE void __Pyx_ExceptionSwap(PyObject **type, PyObject **value, PyObject **tb); +#endif + +/* None.proto */ +static CYTHON_INLINE int64_t __Pyx_mod_int64_t(int64_t, int64_t); + +/* PyIntBinop.proto */ +#if !CYTHON_COMPILING_IN_PYPY +static PyObject* __Pyx_PyInt_AddCObj(PyObject *op1, PyObject *op2, long intval, int inplace); +#else +#define __Pyx_PyInt_AddCObj(op1, op2, intval, inplace)\ + (inplace ? PyNumber_InPlaceAdd(op1, op2) : PyNumber_Add(op1, op2)) +#endif + +/* RaiseTooManyValuesToUnpack.proto */ +static CYTHON_INLINE void __Pyx_RaiseTooManyValuesError(Py_ssize_t expected); + +/* RaiseNeedMoreValuesToUnpack.proto */ +static CYTHON_INLINE void __Pyx_RaiseNeedMoreValuesError(Py_ssize_t index); + +/* IterFinish.proto */ +static CYTHON_INLINE int __Pyx_IterFinish(void); + +/* UnpackItemEndCheck.proto */ +static int __Pyx_IternextUnpackEndCheck(PyObject *retval, Py_ssize_t expected); + +/* PyObjectSetAttrStr.proto */ +#if CYTHON_USE_TYPE_SLOTS +#define __Pyx_PyObject_DelAttrStr(o,n) __Pyx_PyObject_SetAttrStr(o,n,NULL) +static CYTHON_INLINE int __Pyx_PyObject_SetAttrStr(PyObject* obj, PyObject* attr_name, PyObject* value) { + PyTypeObject* tp = Py_TYPE(obj); + if (likely(tp->tp_setattro)) + return tp->tp_setattro(obj, attr_name, value); +#if PY_MAJOR_VERSION < 3 + if (likely(tp->tp_setattr)) + return tp->tp_setattr(obj, PyString_AS_STRING(attr_name), value); +#endif + return PyObject_SetAttr(obj, attr_name, value); +} +#else +#define __Pyx_PyObject_DelAttrStr(o,n) PyObject_DelAttr(o,n) +#define __Pyx_PyObject_SetAttrStr(o,n,v) PyObject_SetAttr(o,n,v) +#endif + +/* IterNext.proto */ +#define __Pyx_PyIter_Next(obj) __Pyx_PyIter_Next2(obj, NULL) +static CYTHON_INLINE PyObject *__Pyx_PyIter_Next2(PyObject *, PyObject *); + +/* decode_c_bytes.proto */ +static CYTHON_INLINE PyObject* __Pyx_decode_c_bytes( + const char* cstring, Py_ssize_t length, Py_ssize_t start, Py_ssize_t stop, + const char* encoding, const char* errors, + PyObject* (*decode_func)(const char *s, Py_ssize_t size, const char *errors)); + +/* decode_bytes.proto */ +static CYTHON_INLINE PyObject* __Pyx_decode_bytes( + PyObject* string, Py_ssize_t start, Py_ssize_t stop, + const char* encoding, const char* errors, + PyObject* (*decode_func)(const char *s, Py_ssize_t size, const char *errors)) { + return __Pyx_decode_c_bytes( + PyBytes_AS_STRING(string), PyBytes_GET_SIZE(string), + start, stop, encoding, errors, decode_func); +} + +/* PyObjectCallMethod0.proto */ +static PyObject* __Pyx_PyObject_CallMethod0(PyObject* obj, PyObject* method_name); + +/* RaiseNoneIterError.proto */ +static CYTHON_INLINE void __Pyx_RaiseNoneNotIterableError(void); + +/* UnpackTupleError.proto */ +static void __Pyx_UnpackTupleError(PyObject *, Py_ssize_t index); + +/* UnpackTuple2.proto */ +static CYTHON_INLINE int __Pyx_unpack_tuple2(PyObject* tuple, PyObject** value1, PyObject** value2, + int is_tuple, int has_known_size, int decref_tuple); + +/* dict_iter.proto */ +static CYTHON_INLINE PyObject* __Pyx_dict_iterator(PyObject* dict, int is_dict, PyObject* method_name, + Py_ssize_t* p_orig_length, int* p_is_dict); +static CYTHON_INLINE int __Pyx_dict_iter_next(PyObject* dict_or_iter, Py_ssize_t orig_length, Py_ssize_t* ppos, + PyObject** pkey, PyObject** pvalue, PyObject** pitem, int is_dict); + +/* ArgTypeTest.proto */ +static CYTHON_INLINE int __Pyx_ArgTypeTest(PyObject *obj, PyTypeObject *type, int none_allowed, + const char *name, int exact); + +/* FetchCommonType.proto */ +static PyTypeObject* __Pyx_FetchCommonType(PyTypeObject* type); + +/* PyObjectCallMethod1.proto */ +static PyObject* __Pyx_PyObject_CallMethod1(PyObject* obj, PyObject* method_name, PyObject* arg); + +/* CoroutineBase.proto */ +typedef PyObject *(*__pyx_coroutine_body_t)(PyObject *, PyObject *); +typedef struct { + PyObject_HEAD + __pyx_coroutine_body_t body; + PyObject *closure; + PyObject *exc_type; + PyObject *exc_value; + PyObject *exc_traceback; + PyObject *gi_weakreflist; + PyObject *classobj; + PyObject *yieldfrom; + PyObject *gi_name; + PyObject *gi_qualname; + PyObject *gi_modulename; + int resume_label; + char is_running; +} __pyx_CoroutineObject; +static __pyx_CoroutineObject *__Pyx__Coroutine_New( + PyTypeObject *type, __pyx_coroutine_body_t body, PyObject *closure, + PyObject *name, PyObject *qualname, PyObject *module_name); +static int __Pyx_Coroutine_clear(PyObject *self); +#if 1 || PY_VERSION_HEX < 0x030300B0 +static int __Pyx_PyGen_FetchStopIterationValue(PyObject **pvalue); +#else +#define __Pyx_PyGen_FetchStopIterationValue(pvalue) PyGen_FetchStopIterationValue(pvalue) +#endif + +/* PatchModuleWithCoroutine.proto */ +static PyObject* __Pyx_Coroutine_patch_module(PyObject* module, const char* py_code); + +/* PatchGeneratorABC.proto */ +static int __Pyx_patch_abc(void); + +/* Coroutine.proto */ +#define __Pyx_Coroutine_USED +static PyTypeObject *__pyx_CoroutineType = 0; +static PyTypeObject *__pyx_CoroutineAwaitType = 0; +#define __Pyx_Coroutine_CheckExact(obj) (Py_TYPE(obj) == __pyx_CoroutineType) +#define __Pyx_Coroutine_New(body, closure, name, qualname, module_name)\ + __Pyx__Coroutine_New(__pyx_CoroutineType, body, closure, name, qualname, module_name) +static int __pyx_Coroutine_init(void); +static PyObject *__Pyx__Coroutine_await(PyObject *coroutine); + +/* GetAwaitIter.proto */ +static CYTHON_INLINE PyObject *__Pyx_Coroutine_GetAwaitableIter(PyObject *o); +static PyObject *__Pyx__Coroutine_GetAwaitableIter(PyObject *o); + +/* CoroutineYieldFrom.proto */ +#define __Pyx_Coroutine_Yield_From(gen, source) __Pyx__Coroutine_Yield_From(gen, source, 0) +static CYTHON_INLINE PyObject* __Pyx__Coroutine_Yield_From(__pyx_CoroutineObject *gen, PyObject *source, int warn); + +/* ReturnWithStopIteration.proto */ +#define __Pyx_ReturnWithStopIteration(value)\ + if (value == Py_None) PyErr_SetNone(PyExc_StopIteration); else __Pyx__ReturnWithStopIteration(value) +static void __Pyx__ReturnWithStopIteration(PyObject* value); + +/* None.proto */ +static CYTHON_INLINE void __Pyx_RaiseClosureNameError(const char *varname); + +/* SetVTable.proto */ +static int __Pyx_SetVtable(PyObject *dict, void *vtable); + +/* Import.proto */ +static PyObject *__Pyx_Import(PyObject *name, PyObject *from_list, int level); + +/* PatchInspect.proto */ +static PyObject* __Pyx_patch_inspect(PyObject* module); + +/* PatchAsyncIO.proto */ +static PyObject* __Pyx_patch_asyncio(PyObject* module); + +/* ImportFrom.proto */ +static PyObject* __Pyx_ImportFrom(PyObject* module, PyObject* name); + +/* CalculateMetaclass.proto */ +static PyObject *__Pyx_CalculateMetaclass(PyTypeObject *metaclass, PyObject *bases); + +/* Py3ClassCreate.proto */ +static PyObject *__Pyx_Py3MetaclassPrepare(PyObject *metaclass, PyObject *bases, PyObject *name, PyObject *qualname, + PyObject *mkw, PyObject *modname, PyObject *doc); +static PyObject *__Pyx_Py3ClassCreate(PyObject *metaclass, PyObject *name, PyObject *bases, PyObject *dict, + PyObject *mkw, int calculate_metaclass, int allow_py2_metaclass); + +/* CodeObjectCache.proto */ +typedef struct { + PyCodeObject* code_object; + int code_line; +} __Pyx_CodeObjectCacheEntry; +struct __Pyx_CodeObjectCache { + int count; + int max_count; + __Pyx_CodeObjectCacheEntry* entries; +}; +static struct __Pyx_CodeObjectCache __pyx_code_cache = {0,0,NULL}; +static int __pyx_bisect_code_objects(__Pyx_CodeObjectCacheEntry* entries, int count, int code_line); +static PyCodeObject *__pyx_find_code_object(int code_line); +static void __pyx_insert_code_object(int code_line, PyCodeObject* code_object); + +/* AddTraceback.proto */ +static void __Pyx_AddTraceback(const char *funcname, int c_line, + int py_line, const char *filename); + +/* CIntToPy.proto */ +static CYTHON_INLINE PyObject* __Pyx_PyInt_From_enum____pyx_t_7asyncpg_8protocol_8protocol_AuthenticationMessage(enum __pyx_t_7asyncpg_8protocol_8protocol_AuthenticationMessage value); + +/* CIntToPy.proto */ +static CYTHON_INLINE PyObject* __Pyx_PyInt_From_long(long value); + +/* CIntToPy.proto */ +static CYTHON_INLINE PyObject* __Pyx_PyInt_From_char(char value); + +/* CIntToPy.proto */ +static CYTHON_INLINE PyObject* __Pyx_PyInt_From_int32_t(int32_t value); + +/* CIntToPy.proto */ +static CYTHON_INLINE PyObject* __Pyx_PyInt_From_int16_t(int16_t value); + +/* CIntToPy.proto */ +static CYTHON_INLINE PyObject* __Pyx_PyInt_From_enum____pyx_t_7asyncpg_8protocol_8protocol_CodecType(enum __pyx_t_7asyncpg_8protocol_8protocol_CodecType value); + +/* CIntToPy.proto */ +static CYTHON_INLINE PyObject* __Pyx_PyInt_From_uint32_t(uint32_t value); + +/* CIntToPy.proto */ +static CYTHON_INLINE PyObject* __Pyx_PyInt_From_int(int value); + +/* UnicodeAsUCS4.proto */ +static CYTHON_INLINE Py_UCS4 __Pyx_PyUnicode_AsPy_UCS4(PyObject*); + +/* CIntToPy.proto */ +static CYTHON_INLINE PyObject* __Pyx_PyInt_From_enum____pyx_t_7asyncpg_8protocol_8protocol_CodecFormat(enum __pyx_t_7asyncpg_8protocol_8protocol_CodecFormat value); + +/* CIntToPy.proto */ +static CYTHON_INLINE PyObject* __Pyx_PyInt_From_int64_t(int64_t value); + +/* CIntToPy.proto */ +static CYTHON_INLINE PyObject* __Pyx_PyInt_From_uint8_t(uint8_t value); + +/* CIntToPy.proto */ +static CYTHON_INLINE PyObject* __Pyx_PyInt_From_ptrdiff_t(ptrdiff_t value); + +/* CIntToPy.proto */ +static CYTHON_INLINE PyObject* __Pyx_PyInt_From_enum____pyx_t_7asyncpg_8protocol_8protocol_ProtocolState(enum __pyx_t_7asyncpg_8protocol_8protocol_ProtocolState value); + +/* CIntToPy.proto */ +static CYTHON_INLINE PyObject* __Pyx_PyInt_From_uint64_t(uint64_t value); + +/* CIntFromPy.proto */ +static CYTHON_INLINE uint32_t __Pyx_PyInt_As_uint32_t(PyObject *); + +/* CIntFromPy.proto */ +static CYTHON_INLINE enum __pyx_t_7asyncpg_8protocol_8protocol_CodecFormat __Pyx_PyInt_As_enum____pyx_t_7asyncpg_8protocol_8protocol_CodecFormat(PyObject *); + +/* CIntFromPy.proto */ +static CYTHON_INLINE int __Pyx_PyInt_As_int(PyObject *); + +/* CIntFromPy.proto */ +static CYTHON_INLINE int64_t __Pyx_PyInt_As_int64_t(PyObject *); + +/* CIntFromPy.proto */ +static CYTHON_INLINE int32_t __Pyx_PyInt_As_int32_t(PyObject *); + +/* CIntFromPy.proto */ +static CYTHON_INLINE int8_t __Pyx_PyInt_As_int8_t(PyObject *); + +/* CIntFromPy.proto */ +static CYTHON_INLINE uint8_t __Pyx_PyInt_As_uint8_t(PyObject *); + +/* CIntFromPy.proto */ +static CYTHON_INLINE char __Pyx_PyInt_As_char(PyObject *); + +/* CIntFromPy.proto */ +static CYTHON_INLINE int16_t __Pyx_PyInt_As_int16_t(PyObject *); + +/* ObjectAsUCS4.proto */ +#define __Pyx_PyObject_AsPy_UCS4(x)\ + (likely(PyUnicode_Check(x)) ? __Pyx_PyUnicode_AsPy_UCS4(x) : __Pyx__PyObject_AsPy_UCS4(x)) +static Py_UCS4 __Pyx__PyObject_AsPy_UCS4(PyObject*); + +/* CIntFromPy.proto */ +static CYTHON_INLINE long __Pyx_PyInt_As_long(PyObject *); + +/* Generator.proto */ +#define __Pyx_Generator_USED +static PyTypeObject *__pyx_GeneratorType = 0; +#define __Pyx_Generator_CheckExact(obj) (Py_TYPE(obj) == __pyx_GeneratorType) +#define __Pyx_Generator_New(body, closure, name, qualname, module_name)\ + __Pyx__Coroutine_New(__pyx_GeneratorType, body, closure, name, qualname, module_name) +static PyObject *__Pyx_Generator_Next(PyObject *self); +static int __pyx_Generator_init(void); + +/* CheckBinaryVersion.proto */ +static int __Pyx_check_binary_version(void); + +/* VoidPtrExport.proto */ +static int __Pyx_ExportVoidPtr(PyObject *name, void *p, const char *sig); + +/* PyIdentifierFromString.proto */ +#if !defined(__Pyx_PyIdentifier_FromString) +#if PY_MAJOR_VERSION < 3 + #define __Pyx_PyIdentifier_FromString(s) PyString_FromString(s) +#else + #define __Pyx_PyIdentifier_FromString(s) PyUnicode_FromString(s) +#endif +#endif + +/* ModuleImport.proto */ +static PyObject *__Pyx_ImportModule(const char *name); + +/* TypeImport.proto */ +static PyTypeObject *__Pyx_ImportType(const char *module_name, const char *class_name, size_t size, int strict); + +/* InitStrings.proto */ +static int __Pyx_InitStrings(__Pyx_StringTabEntry *t); + +static PyObject *__pyx_f_7asyncpg_8protocol_8protocol_18ConnectionSettings_add_setting(struct __pyx_obj_7asyncpg_8protocol_8protocol_ConnectionSettings *__pyx_v_self, PyObject *__pyx_v_name, PyObject *__pyx_v_val); /* proto*/ +static CYTHON_INLINE PyObject *__pyx_f_7asyncpg_8protocol_8protocol_18ConnectionSettings_is_encoding_utf8(struct __pyx_obj_7asyncpg_8protocol_8protocol_ConnectionSettings *__pyx_v_self); /* proto*/ +static CYTHON_INLINE PyObject *__pyx_f_7asyncpg_8protocol_8protocol_18ConnectionSettings_get_text_codec(struct __pyx_obj_7asyncpg_8protocol_8protocol_ConnectionSettings *__pyx_v_self, CYTHON_UNUSED int __pyx_skip_dispatch); /* proto*/ +static CYTHON_INLINE PyObject *__pyx_f_7asyncpg_8protocol_8protocol_18ConnectionSettings_register_data_types(struct __pyx_obj_7asyncpg_8protocol_8protocol_ConnectionSettings *__pyx_v_self, PyObject *__pyx_v_types, CYTHON_UNUSED int __pyx_skip_dispatch); /* proto*/ +static CYTHON_INLINE PyObject *__pyx_f_7asyncpg_8protocol_8protocol_18ConnectionSettings_add_python_codec(struct __pyx_obj_7asyncpg_8protocol_8protocol_ConnectionSettings *__pyx_v_self, PyObject *__pyx_v_typeoid, PyObject *__pyx_v_typename, PyObject *__pyx_v_typeschema, PyObject *__pyx_v_typekind, PyObject *__pyx_v_encoder, PyObject *__pyx_v_decoder, PyObject *__pyx_v_binary, CYTHON_UNUSED int __pyx_skip_dispatch); /* proto*/ +static CYTHON_INLINE PyObject *__pyx_f_7asyncpg_8protocol_8protocol_18ConnectionSettings_set_builtin_type_codec(struct __pyx_obj_7asyncpg_8protocol_8protocol_ConnectionSettings *__pyx_v_self, PyObject *__pyx_v_typeoid, PyObject *__pyx_v_typename, PyObject *__pyx_v_typeschema, PyObject *__pyx_v_typekind, PyObject *__pyx_v_alias_to, CYTHON_UNUSED int __pyx_skip_dispatch); /* proto*/ +static CYTHON_INLINE struct __pyx_obj_7asyncpg_8protocol_8protocol_Codec *__pyx_f_7asyncpg_8protocol_8protocol_18ConnectionSettings_get_data_codec(struct __pyx_obj_7asyncpg_8protocol_8protocol_ConnectionSettings *__pyx_v_self, uint32_t __pyx_v_oid, CYTHON_UNUSED int __pyx_skip_dispatch, struct __pyx_opt_args_7asyncpg_8protocol_8protocol_18ConnectionSettings_get_data_codec *__pyx_optional_args); /* proto*/ +static PyObject *__pyx_f_7asyncpg_8protocol_8protocol_6Memory_as_bytes(struct __pyx_obj_7asyncpg_8protocol_8protocol_Memory *__pyx_v_self); /* proto*/ +static CYTHON_INLINE struct __pyx_obj_7asyncpg_8protocol_8protocol_Memory *__pyx_f_7asyncpg_8protocol_8protocol_6Memory_new(char *__pyx_v_buf, PyObject *__pyx_v_owner, Py_ssize_t __pyx_v_length); /* proto*/ +static CYTHON_INLINE PyObject *__pyx_f_7asyncpg_8protocol_8protocol_11WriteBuffer__check_readonly(struct __pyx_obj_7asyncpg_8protocol_8protocol_WriteBuffer *__pyx_v_self); /* proto*/ +static CYTHON_INLINE PyObject *__pyx_f_7asyncpg_8protocol_8protocol_11WriteBuffer_len(struct __pyx_obj_7asyncpg_8protocol_8protocol_WriteBuffer *__pyx_v_self); /* proto*/ +static CYTHON_INLINE PyObject *__pyx_f_7asyncpg_8protocol_8protocol_11WriteBuffer__ensure_alloced(struct __pyx_obj_7asyncpg_8protocol_8protocol_WriteBuffer *__pyx_v_self, Py_ssize_t __pyx_v_extra_length); /* proto*/ +static PyObject *__pyx_f_7asyncpg_8protocol_8protocol_11WriteBuffer__reallocate(struct __pyx_obj_7asyncpg_8protocol_8protocol_WriteBuffer *__pyx_v_self, Py_ssize_t __pyx_v_new_size); /* proto*/ +static CYTHON_INLINE PyObject *__pyx_f_7asyncpg_8protocol_8protocol_11WriteBuffer_start_message(struct __pyx_obj_7asyncpg_8protocol_8protocol_WriteBuffer *__pyx_v_self, char __pyx_v_type); /* proto*/ +static CYTHON_INLINE PyObject *__pyx_f_7asyncpg_8protocol_8protocol_11WriteBuffer_end_message(struct __pyx_obj_7asyncpg_8protocol_8protocol_WriteBuffer *__pyx_v_self); /* proto*/ +static PyObject *__pyx_f_7asyncpg_8protocol_8protocol_11WriteBuffer_write_buffer(struct __pyx_obj_7asyncpg_8protocol_8protocol_WriteBuffer *__pyx_v_self, struct __pyx_obj_7asyncpg_8protocol_8protocol_WriteBuffer *__pyx_v_buf); /* proto*/ +static PyObject *__pyx_f_7asyncpg_8protocol_8protocol_11WriteBuffer_write_byte(struct __pyx_obj_7asyncpg_8protocol_8protocol_WriteBuffer *__pyx_v_self, char __pyx_v_b); /* proto*/ +static PyObject *__pyx_f_7asyncpg_8protocol_8protocol_11WriteBuffer_write_bytes(struct __pyx_obj_7asyncpg_8protocol_8protocol_WriteBuffer *__pyx_v_self, PyObject *__pyx_v_data); /* proto*/ +static PyObject *__pyx_f_7asyncpg_8protocol_8protocol_11WriteBuffer_write_bytestring(struct __pyx_obj_7asyncpg_8protocol_8protocol_WriteBuffer *__pyx_v_self, PyObject *__pyx_v_string); /* proto*/ +static PyObject *__pyx_f_7asyncpg_8protocol_8protocol_11WriteBuffer_write_str(struct __pyx_obj_7asyncpg_8protocol_8protocol_WriteBuffer *__pyx_v_self, PyObject *__pyx_v_string, PyObject *__pyx_v_encoding); /* proto*/ +static PyObject *__pyx_f_7asyncpg_8protocol_8protocol_11WriteBuffer_write_cstr(struct __pyx_obj_7asyncpg_8protocol_8protocol_WriteBuffer *__pyx_v_self, char *__pyx_v_data, Py_ssize_t __pyx_v_len); /* proto*/ +static PyObject *__pyx_f_7asyncpg_8protocol_8protocol_11WriteBuffer_write_int16(struct __pyx_obj_7asyncpg_8protocol_8protocol_WriteBuffer *__pyx_v_self, int16_t __pyx_v_i); /* proto*/ +static PyObject *__pyx_f_7asyncpg_8protocol_8protocol_11WriteBuffer_write_int32(struct __pyx_obj_7asyncpg_8protocol_8protocol_WriteBuffer *__pyx_v_self, int32_t __pyx_v_i); /* proto*/ +static PyObject *__pyx_f_7asyncpg_8protocol_8protocol_11WriteBuffer_write_int64(struct __pyx_obj_7asyncpg_8protocol_8protocol_WriteBuffer *__pyx_v_self, int64_t __pyx_v_i); /* proto*/ +static PyObject *__pyx_f_7asyncpg_8protocol_8protocol_11WriteBuffer_write_float(struct __pyx_obj_7asyncpg_8protocol_8protocol_WriteBuffer *__pyx_v_self, float __pyx_v_f); /* proto*/ +static PyObject *__pyx_f_7asyncpg_8protocol_8protocol_11WriteBuffer_write_double(struct __pyx_obj_7asyncpg_8protocol_8protocol_WriteBuffer *__pyx_v_self, double __pyx_v_d); /* proto*/ +static struct __pyx_obj_7asyncpg_8protocol_8protocol_WriteBuffer *__pyx_f_7asyncpg_8protocol_8protocol_11WriteBuffer_new_message(char __pyx_v_type); /* proto*/ +static struct __pyx_obj_7asyncpg_8protocol_8protocol_WriteBuffer *__pyx_f_7asyncpg_8protocol_8protocol_11WriteBuffer_new(void); /* proto*/ +static PyObject *__pyx_f_7asyncpg_8protocol_8protocol_10ReadBuffer_feed_data(struct __pyx_obj_7asyncpg_8protocol_8protocol_ReadBuffer *__pyx_v_self, PyObject *__pyx_v_data); /* proto*/ +static CYTHON_INLINE PyObject *__pyx_f_7asyncpg_8protocol_8protocol_10ReadBuffer__ensure_first_buf(struct __pyx_obj_7asyncpg_8protocol_8protocol_ReadBuffer *__pyx_v_self); /* proto*/ +static PyObject *__pyx_f_7asyncpg_8protocol_8protocol_10ReadBuffer__switch_to_next_buf(struct __pyx_obj_7asyncpg_8protocol_8protocol_ReadBuffer *__pyx_v_self); /* proto*/ +static CYTHON_INLINE char *__pyx_f_7asyncpg_8protocol_8protocol_10ReadBuffer__try_read_bytes(struct __pyx_obj_7asyncpg_8protocol_8protocol_ReadBuffer *__pyx_v_self, Py_ssize_t __pyx_v_nbytes); /* proto*/ +static CYTHON_INLINE PyObject *__pyx_f_7asyncpg_8protocol_8protocol_10ReadBuffer_read(struct __pyx_obj_7asyncpg_8protocol_8protocol_ReadBuffer *__pyx_v_self, Py_ssize_t __pyx_v_nbytes); /* proto*/ +static CYTHON_INLINE PyObject *__pyx_f_7asyncpg_8protocol_8protocol_10ReadBuffer_read_byte(struct __pyx_obj_7asyncpg_8protocol_8protocol_ReadBuffer *__pyx_v_self); /* proto*/ +static CYTHON_INLINE PyObject *__pyx_f_7asyncpg_8protocol_8protocol_10ReadBuffer_read_bytes(struct __pyx_obj_7asyncpg_8protocol_8protocol_ReadBuffer *__pyx_v_self, Py_ssize_t __pyx_v_n); /* proto*/ +static CYTHON_INLINE PyObject *__pyx_f_7asyncpg_8protocol_8protocol_10ReadBuffer_read_int32(struct __pyx_obj_7asyncpg_8protocol_8protocol_ReadBuffer *__pyx_v_self); /* proto*/ +static CYTHON_INLINE PyObject *__pyx_f_7asyncpg_8protocol_8protocol_10ReadBuffer_read_int16(struct __pyx_obj_7asyncpg_8protocol_8protocol_ReadBuffer *__pyx_v_self); /* proto*/ +static CYTHON_INLINE PyObject *__pyx_f_7asyncpg_8protocol_8protocol_10ReadBuffer_read_cstr(struct __pyx_obj_7asyncpg_8protocol_8protocol_ReadBuffer *__pyx_v_self); /* proto*/ +static int32_t __pyx_f_7asyncpg_8protocol_8protocol_10ReadBuffer_has_message(struct __pyx_obj_7asyncpg_8protocol_8protocol_ReadBuffer *__pyx_v_self); /* proto*/ +static CYTHON_INLINE char *__pyx_f_7asyncpg_8protocol_8protocol_10ReadBuffer_try_consume_message(struct __pyx_obj_7asyncpg_8protocol_8protocol_ReadBuffer *__pyx_v_self, Py_ssize_t *__pyx_v_len); /* proto*/ +static struct __pyx_obj_7asyncpg_8protocol_8protocol_Memory *__pyx_f_7asyncpg_8protocol_8protocol_10ReadBuffer_consume_message(struct __pyx_obj_7asyncpg_8protocol_8protocol_ReadBuffer *__pyx_v_self); /* proto*/ +static PyObject *__pyx_f_7asyncpg_8protocol_8protocol_10ReadBuffer_discard_message(struct __pyx_obj_7asyncpg_8protocol_8protocol_ReadBuffer *__pyx_v_self); /* proto*/ +static CYTHON_INLINE PyObject *__pyx_f_7asyncpg_8protocol_8protocol_10ReadBuffer__discard_message(struct __pyx_obj_7asyncpg_8protocol_8protocol_ReadBuffer *__pyx_v_self); /* proto*/ +static CYTHON_INLINE char __pyx_f_7asyncpg_8protocol_8protocol_10ReadBuffer_get_message_type(struct __pyx_obj_7asyncpg_8protocol_8protocol_ReadBuffer *__pyx_v_self); /* proto*/ +static CYTHON_INLINE int32_t __pyx_f_7asyncpg_8protocol_8protocol_10ReadBuffer_get_message_length(struct __pyx_obj_7asyncpg_8protocol_8protocol_ReadBuffer *__pyx_v_self); /* proto*/ +static struct __pyx_obj_7asyncpg_8protocol_8protocol_ReadBuffer *__pyx_f_7asyncpg_8protocol_8protocol_10ReadBuffer_new_message_parser(PyObject *__pyx_v_data); /* proto*/ +static CYTHON_INLINE char const *__pyx_f_7asyncpg_8protocol_8protocol_14FastReadBuffer_read(struct __pyx_obj_7asyncpg_8protocol_8protocol_FastReadBuffer *__pyx_v_self, Py_ssize_t __pyx_v_n); /* proto*/ +static CYTHON_INLINE char const *__pyx_f_7asyncpg_8protocol_8protocol_14FastReadBuffer_read_all(struct __pyx_obj_7asyncpg_8protocol_8protocol_FastReadBuffer *__pyx_v_self); /* proto*/ +static CYTHON_INLINE struct __pyx_obj_7asyncpg_8protocol_8protocol_FastReadBuffer *__pyx_f_7asyncpg_8protocol_8protocol_14FastReadBuffer_slice_from(struct __pyx_obj_7asyncpg_8protocol_8protocol_FastReadBuffer *__pyx_v_self, struct __pyx_obj_7asyncpg_8protocol_8protocol_FastReadBuffer *__pyx_v_source, Py_ssize_t __pyx_v_len); /* proto*/ +static PyObject *__pyx_f_7asyncpg_8protocol_8protocol_14FastReadBuffer__raise_ins_err(struct __pyx_obj_7asyncpg_8protocol_8protocol_FastReadBuffer *__pyx_v_self, Py_ssize_t __pyx_v_n, CYTHON_UNUSED Py_ssize_t __pyx_v_len); /* proto*/ +static struct __pyx_obj_7asyncpg_8protocol_8protocol_FastReadBuffer *__pyx_f_7asyncpg_8protocol_8protocol_14FastReadBuffer_new(void); /* proto*/ +static PyObject *__pyx_f_7asyncpg_8protocol_8protocol_5Codec_init(struct __pyx_obj_7asyncpg_8protocol_8protocol_Codec *__pyx_v_self, PyObject *__pyx_v_name, PyObject *__pyx_v_schema, PyObject *__pyx_v_kind, enum __pyx_t_7asyncpg_8protocol_8protocol_CodecType __pyx_v_type, enum __pyx_t_7asyncpg_8protocol_8protocol_CodecFormat __pyx_v_format, __pyx_t_7asyncpg_8protocol_8protocol_encode_func __pyx_v_c_encoder, __pyx_t_7asyncpg_8protocol_8protocol_decode_func __pyx_v_c_decoder, PyObject *__pyx_v_py_encoder, PyObject *__pyx_v_py_decoder, struct __pyx_obj_7asyncpg_8protocol_8protocol_Codec *__pyx_v_element_codec, PyObject *__pyx_v_element_type_oids, PyObject *__pyx_v_element_names, PyObject *__pyx_v_element_codecs, Py_UCS4 __pyx_v_element_delimiter); /* proto*/ +static CYTHON_INLINE struct __pyx_obj_7asyncpg_8protocol_8protocol_Codec *__pyx_f_7asyncpg_8protocol_8protocol_5Codec_copy(struct __pyx_obj_7asyncpg_8protocol_8protocol_Codec *__pyx_v_self); /* proto*/ +static PyObject *__pyx_f_7asyncpg_8protocol_8protocol_5Codec_encode_scalar(struct __pyx_obj_7asyncpg_8protocol_8protocol_Codec *__pyx_v_self, struct __pyx_obj_7asyncpg_8protocol_8protocol_ConnectionSettings *__pyx_v_settings, struct __pyx_obj_7asyncpg_8protocol_8protocol_WriteBuffer *__pyx_v_buf, PyObject *__pyx_v_obj); /* proto*/ +static PyObject *__pyx_f_7asyncpg_8protocol_8protocol_5Codec_encode_array(struct __pyx_obj_7asyncpg_8protocol_8protocol_Codec *__pyx_v_self, struct __pyx_obj_7asyncpg_8protocol_8protocol_ConnectionSettings *__pyx_v_settings, struct __pyx_obj_7asyncpg_8protocol_8protocol_WriteBuffer *__pyx_v_buf, PyObject *__pyx_v_obj); /* proto*/ +static PyObject *__pyx_f_7asyncpg_8protocol_8protocol_5Codec_encode_range(struct __pyx_obj_7asyncpg_8protocol_8protocol_Codec *__pyx_v_self, struct __pyx_obj_7asyncpg_8protocol_8protocol_ConnectionSettings *__pyx_v_settings, struct __pyx_obj_7asyncpg_8protocol_8protocol_WriteBuffer *__pyx_v_buf, PyObject *__pyx_v_obj); /* proto*/ +static PyObject *__pyx_f_7asyncpg_8protocol_8protocol_5Codec_encode_composite(struct __pyx_obj_7asyncpg_8protocol_8protocol_Codec *__pyx_v_self, struct __pyx_obj_7asyncpg_8protocol_8protocol_ConnectionSettings *__pyx_v_settings, struct __pyx_obj_7asyncpg_8protocol_8protocol_WriteBuffer *__pyx_v_buf, PyObject *__pyx_v_obj); /* proto*/ +static PyObject *__pyx_f_7asyncpg_8protocol_8protocol_5Codec_encode_in_python(struct __pyx_obj_7asyncpg_8protocol_8protocol_Codec *__pyx_v_self, struct __pyx_obj_7asyncpg_8protocol_8protocol_ConnectionSettings *__pyx_v_settings, struct __pyx_obj_7asyncpg_8protocol_8protocol_WriteBuffer *__pyx_v_buf, PyObject *__pyx_v_obj); /* proto*/ +static CYTHON_INLINE PyObject *__pyx_f_7asyncpg_8protocol_8protocol_5Codec_encode(struct __pyx_obj_7asyncpg_8protocol_8protocol_Codec *__pyx_v_self, struct __pyx_obj_7asyncpg_8protocol_8protocol_ConnectionSettings *__pyx_v_settings, struct __pyx_obj_7asyncpg_8protocol_8protocol_WriteBuffer *__pyx_v_buf, PyObject *__pyx_v_obj); /* proto*/ +static PyObject *__pyx_f_7asyncpg_8protocol_8protocol_5Codec_decode_scalar(struct __pyx_obj_7asyncpg_8protocol_8protocol_Codec *__pyx_v_self, struct __pyx_obj_7asyncpg_8protocol_8protocol_ConnectionSettings *__pyx_v_settings, struct __pyx_obj_7asyncpg_8protocol_8protocol_FastReadBuffer *__pyx_v_buf); /* proto*/ +static PyObject *__pyx_f_7asyncpg_8protocol_8protocol_5Codec_decode_array(struct __pyx_obj_7asyncpg_8protocol_8protocol_Codec *__pyx_v_self, struct __pyx_obj_7asyncpg_8protocol_8protocol_ConnectionSettings *__pyx_v_settings, struct __pyx_obj_7asyncpg_8protocol_8protocol_FastReadBuffer *__pyx_v_buf); /* proto*/ +static PyObject *__pyx_f_7asyncpg_8protocol_8protocol_5Codec_decode_array_text(struct __pyx_obj_7asyncpg_8protocol_8protocol_Codec *__pyx_v_self, struct __pyx_obj_7asyncpg_8protocol_8protocol_ConnectionSettings *__pyx_v_settings, struct __pyx_obj_7asyncpg_8protocol_8protocol_FastReadBuffer *__pyx_v_buf); /* proto*/ +static PyObject *__pyx_f_7asyncpg_8protocol_8protocol_5Codec_decode_range(struct __pyx_obj_7asyncpg_8protocol_8protocol_Codec *__pyx_v_self, struct __pyx_obj_7asyncpg_8protocol_8protocol_ConnectionSettings *__pyx_v_settings, struct __pyx_obj_7asyncpg_8protocol_8protocol_FastReadBuffer *__pyx_v_buf); /* proto*/ +static PyObject *__pyx_f_7asyncpg_8protocol_8protocol_5Codec_decode_composite(struct __pyx_obj_7asyncpg_8protocol_8protocol_Codec *__pyx_v_self, struct __pyx_obj_7asyncpg_8protocol_8protocol_ConnectionSettings *__pyx_v_settings, struct __pyx_obj_7asyncpg_8protocol_8protocol_FastReadBuffer *__pyx_v_buf); /* proto*/ +static PyObject *__pyx_f_7asyncpg_8protocol_8protocol_5Codec_decode_in_python(struct __pyx_obj_7asyncpg_8protocol_8protocol_Codec *__pyx_v_self, struct __pyx_obj_7asyncpg_8protocol_8protocol_ConnectionSettings *__pyx_v_settings, struct __pyx_obj_7asyncpg_8protocol_8protocol_FastReadBuffer *__pyx_v_buf); /* proto*/ +static CYTHON_INLINE PyObject *__pyx_f_7asyncpg_8protocol_8protocol_5Codec_decode(struct __pyx_obj_7asyncpg_8protocol_8protocol_Codec *__pyx_v_self, struct __pyx_obj_7asyncpg_8protocol_8protocol_ConnectionSettings *__pyx_v_settings, struct __pyx_obj_7asyncpg_8protocol_8protocol_FastReadBuffer *__pyx_v_buf); /* proto*/ +static PyObject *__pyx_f_7asyncpg_8protocol_8protocol_5Codec_has_encoder(struct __pyx_obj_7asyncpg_8protocol_8protocol_Codec *__pyx_v_self); /* proto*/ +static PyObject *__pyx_f_7asyncpg_8protocol_8protocol_5Codec_has_decoder(struct __pyx_obj_7asyncpg_8protocol_8protocol_Codec *__pyx_v_self); /* proto*/ +static PyObject *__pyx_f_7asyncpg_8protocol_8protocol_5Codec_is_binary(struct __pyx_obj_7asyncpg_8protocol_8protocol_Codec *__pyx_v_self); /* proto*/ +static struct __pyx_obj_7asyncpg_8protocol_8protocol_Codec *__pyx_f_7asyncpg_8protocol_8protocol_5Codec_new_array_codec(uint32_t __pyx_v_oid, PyObject *__pyx_v_name, PyObject *__pyx_v_schema, struct __pyx_obj_7asyncpg_8protocol_8protocol_Codec *__pyx_v_element_codec, Py_UCS4 __pyx_v_element_delimiter); /* proto*/ +static struct __pyx_obj_7asyncpg_8protocol_8protocol_Codec *__pyx_f_7asyncpg_8protocol_8protocol_5Codec_new_range_codec(uint32_t __pyx_v_oid, PyObject *__pyx_v_name, PyObject *__pyx_v_schema, struct __pyx_obj_7asyncpg_8protocol_8protocol_Codec *__pyx_v_element_codec); /* proto*/ +static struct __pyx_obj_7asyncpg_8protocol_8protocol_Codec *__pyx_f_7asyncpg_8protocol_8protocol_5Codec_new_composite_codec(uint32_t __pyx_v_oid, PyObject *__pyx_v_name, PyObject *__pyx_v_schema, PyObject *__pyx_v_element_codecs, PyObject *__pyx_v_element_type_oids, PyObject *__pyx_v_element_names); /* proto*/ +static struct __pyx_obj_7asyncpg_8protocol_8protocol_Codec *__pyx_f_7asyncpg_8protocol_8protocol_5Codec_new_python_codec(uint32_t __pyx_v_oid, PyObject *__pyx_v_name, PyObject *__pyx_v_schema, PyObject *__pyx_v_kind, PyObject *__pyx_v_encoder, PyObject *__pyx_v_decoder, enum __pyx_t_7asyncpg_8protocol_8protocol_CodecFormat __pyx_v_format); /* proto*/ +static CYTHON_INLINE struct __pyx_obj_7asyncpg_8protocol_8protocol_Codec *__pyx_f_7asyncpg_8protocol_8protocol_15DataCodecConfig_get_codec(struct __pyx_obj_7asyncpg_8protocol_8protocol_DataCodecConfig *__pyx_v_self, uint32_t __pyx_v_oid, enum __pyx_t_7asyncpg_8protocol_8protocol_CodecFormat __pyx_v_format); /* proto*/ +static PyObject *__pyx_f_7asyncpg_8protocol_8protocol_12CoreProtocol__write(struct __pyx_obj_7asyncpg_8protocol_8protocol_CoreProtocol *__pyx_v_self, PyObject *__pyx_v_buf); /* proto*/ +static CYTHON_INLINE PyObject *__pyx_f_7asyncpg_8protocol_8protocol_12CoreProtocol__write_sync_message(struct __pyx_obj_7asyncpg_8protocol_8protocol_CoreProtocol *__pyx_v_self); /* proto*/ +static PyObject *__pyx_f_7asyncpg_8protocol_8protocol_12CoreProtocol__read_server_messages(struct __pyx_obj_7asyncpg_8protocol_8protocol_CoreProtocol *__pyx_v_self); /* proto*/ +static PyObject *__pyx_f_7asyncpg_8protocol_8protocol_12CoreProtocol__process__auth(struct __pyx_obj_7asyncpg_8protocol_8protocol_CoreProtocol *__pyx_v_self, char __pyx_v_mtype); /* proto*/ +static PyObject *__pyx_f_7asyncpg_8protocol_8protocol_12CoreProtocol__process__prepare(struct __pyx_obj_7asyncpg_8protocol_8protocol_CoreProtocol *__pyx_v_self, char __pyx_v_mtype); /* proto*/ +static PyObject *__pyx_f_7asyncpg_8protocol_8protocol_12CoreProtocol__process__bind_execute(struct __pyx_obj_7asyncpg_8protocol_8protocol_CoreProtocol *__pyx_v_self, char __pyx_v_mtype); /* proto*/ +static PyObject *__pyx_f_7asyncpg_8protocol_8protocol_12CoreProtocol__process__bind_execute_many(struct __pyx_obj_7asyncpg_8protocol_8protocol_CoreProtocol *__pyx_v_self, char __pyx_v_mtype); /* proto*/ +static PyObject *__pyx_f_7asyncpg_8protocol_8protocol_12CoreProtocol__process__bind(struct __pyx_obj_7asyncpg_8protocol_8protocol_CoreProtocol *__pyx_v_self, char __pyx_v_mtype); /* proto*/ +static PyObject *__pyx_f_7asyncpg_8protocol_8protocol_12CoreProtocol__process__close_stmt_portal(struct __pyx_obj_7asyncpg_8protocol_8protocol_CoreProtocol *__pyx_v_self, char __pyx_v_mtype); /* proto*/ +static PyObject *__pyx_f_7asyncpg_8protocol_8protocol_12CoreProtocol__process__simple_query(struct __pyx_obj_7asyncpg_8protocol_8protocol_CoreProtocol *__pyx_v_self, char __pyx_v_mtype); /* proto*/ +static PyObject *__pyx_f_7asyncpg_8protocol_8protocol_12CoreProtocol__parse_msg_command_complete(struct __pyx_obj_7asyncpg_8protocol_8protocol_CoreProtocol *__pyx_v_self); /* proto*/ +static PyObject *__pyx_f_7asyncpg_8protocol_8protocol_12CoreProtocol__parse_data_msgs(struct __pyx_obj_7asyncpg_8protocol_8protocol_CoreProtocol *__pyx_v_self); /* proto*/ +static PyObject *__pyx_f_7asyncpg_8protocol_8protocol_12CoreProtocol__parse_msg_backend_key_data(struct __pyx_obj_7asyncpg_8protocol_8protocol_CoreProtocol *__pyx_v_self); /* proto*/ +static PyObject *__pyx_f_7asyncpg_8protocol_8protocol_12CoreProtocol__parse_msg_parameter_status(struct __pyx_obj_7asyncpg_8protocol_8protocol_CoreProtocol *__pyx_v_self); /* proto*/ +static PyObject *__pyx_f_7asyncpg_8protocol_8protocol_12CoreProtocol__parse_msg_notification(struct __pyx_obj_7asyncpg_8protocol_8protocol_CoreProtocol *__pyx_v_self); /* proto*/ +static PyObject *__pyx_f_7asyncpg_8protocol_8protocol_12CoreProtocol__parse_msg_authentication(struct __pyx_obj_7asyncpg_8protocol_8protocol_CoreProtocol *__pyx_v_self); /* proto*/ +static PyObject *__pyx_f_7asyncpg_8protocol_8protocol_12CoreProtocol__auth_password_message_cleartext(struct __pyx_obj_7asyncpg_8protocol_8protocol_CoreProtocol *__pyx_v_self); /* proto*/ +static PyObject *__pyx_f_7asyncpg_8protocol_8protocol_12CoreProtocol__auth_password_message_md5(struct __pyx_obj_7asyncpg_8protocol_8protocol_CoreProtocol *__pyx_v_self, PyObject *__pyx_v_salt); /* proto*/ +static PyObject *__pyx_f_7asyncpg_8protocol_8protocol_12CoreProtocol__parse_msg_ready_for_query(struct __pyx_obj_7asyncpg_8protocol_8protocol_CoreProtocol *__pyx_v_self); /* proto*/ +static PyObject *__pyx_f_7asyncpg_8protocol_8protocol_12CoreProtocol__parse_msg_error_response(struct __pyx_obj_7asyncpg_8protocol_8protocol_CoreProtocol *__pyx_v_self, PyObject *__pyx_v_is_error); /* proto*/ +static PyObject *__pyx_f_7asyncpg_8protocol_8protocol_12CoreProtocol__push_result(struct __pyx_obj_7asyncpg_8protocol_8protocol_CoreProtocol *__pyx_v_self); /* proto*/ +static PyObject *__pyx_f_7asyncpg_8protocol_8protocol_12CoreProtocol__reset_result(struct __pyx_obj_7asyncpg_8protocol_8protocol_CoreProtocol *__pyx_v_self); /* proto*/ +static PyObject *__pyx_f_7asyncpg_8protocol_8protocol_12CoreProtocol__set_state(struct __pyx_obj_7asyncpg_8protocol_8protocol_CoreProtocol *__pyx_v_self, enum __pyx_t_7asyncpg_8protocol_8protocol_ProtocolState __pyx_v_new_state); /* proto*/ +static PyObject *__pyx_f_7asyncpg_8protocol_8protocol_12CoreProtocol__ensure_connected(struct __pyx_obj_7asyncpg_8protocol_8protocol_CoreProtocol *__pyx_v_self); /* proto*/ +static struct __pyx_obj_7asyncpg_8protocol_8protocol_WriteBuffer *__pyx_f_7asyncpg_8protocol_8protocol_12CoreProtocol__build_bind_message(struct __pyx_obj_7asyncpg_8protocol_8protocol_CoreProtocol *__pyx_v_self, PyObject *__pyx_v_portal_name, PyObject *__pyx_v_stmt_name, struct __pyx_obj_7asyncpg_8protocol_8protocol_WriteBuffer *__pyx_v_bind_data); /* proto*/ +static PyObject *__pyx_f_7asyncpg_8protocol_8protocol_12CoreProtocol__connect(struct __pyx_obj_7asyncpg_8protocol_8protocol_CoreProtocol *__pyx_v_self); /* proto*/ +static PyObject *__pyx_f_7asyncpg_8protocol_8protocol_12CoreProtocol__prepare(struct __pyx_obj_7asyncpg_8protocol_8protocol_CoreProtocol *__pyx_v_self, PyObject *__pyx_v_stmt_name, PyObject *__pyx_v_query); /* proto*/ +static PyObject *__pyx_f_7asyncpg_8protocol_8protocol_12CoreProtocol__send_bind_message(struct __pyx_obj_7asyncpg_8protocol_8protocol_CoreProtocol *__pyx_v_self, PyObject *__pyx_v_portal_name, PyObject *__pyx_v_stmt_name, struct __pyx_obj_7asyncpg_8protocol_8protocol_WriteBuffer *__pyx_v_bind_data, int32_t __pyx_v_limit); /* proto*/ +static PyObject *__pyx_f_7asyncpg_8protocol_8protocol_12CoreProtocol__bind_execute(struct __pyx_obj_7asyncpg_8protocol_8protocol_CoreProtocol *__pyx_v_self, PyObject *__pyx_v_portal_name, PyObject *__pyx_v_stmt_name, struct __pyx_obj_7asyncpg_8protocol_8protocol_WriteBuffer *__pyx_v_bind_data, int32_t __pyx_v_limit); /* proto*/ +static PyObject *__pyx_f_7asyncpg_8protocol_8protocol_12CoreProtocol__bind_execute_many(struct __pyx_obj_7asyncpg_8protocol_8protocol_CoreProtocol *__pyx_v_self, PyObject *__pyx_v_portal_name, PyObject *__pyx_v_stmt_name, PyObject *__pyx_v_bind_data); /* proto*/ +static PyObject *__pyx_f_7asyncpg_8protocol_8protocol_12CoreProtocol__execute(struct __pyx_obj_7asyncpg_8protocol_8protocol_CoreProtocol *__pyx_v_self, PyObject *__pyx_v_portal_name, int32_t __pyx_v_limit); /* proto*/ +static PyObject *__pyx_f_7asyncpg_8protocol_8protocol_12CoreProtocol__bind(struct __pyx_obj_7asyncpg_8protocol_8protocol_CoreProtocol *__pyx_v_self, PyObject *__pyx_v_portal_name, PyObject *__pyx_v_stmt_name, struct __pyx_obj_7asyncpg_8protocol_8protocol_WriteBuffer *__pyx_v_bind_data); /* proto*/ +static PyObject *__pyx_f_7asyncpg_8protocol_8protocol_12CoreProtocol__close(struct __pyx_obj_7asyncpg_8protocol_8protocol_CoreProtocol *__pyx_v_self, PyObject *__pyx_v_name, int __pyx_v_is_portal); /* proto*/ +static PyObject *__pyx_f_7asyncpg_8protocol_8protocol_12CoreProtocol__simple_query(struct __pyx_obj_7asyncpg_8protocol_8protocol_CoreProtocol *__pyx_v_self, PyObject *__pyx_v_query); /* proto*/ +static PyObject *__pyx_f_7asyncpg_8protocol_8protocol_12CoreProtocol__terminate(struct __pyx_obj_7asyncpg_8protocol_8protocol_CoreProtocol *__pyx_v_self); /* proto*/ +static PyObject *__pyx_f_7asyncpg_8protocol_8protocol_12CoreProtocol__decode_row(CYTHON_UNUSED struct __pyx_obj_7asyncpg_8protocol_8protocol_CoreProtocol *__pyx_v_self, CYTHON_UNUSED char const *__pyx_v_buf, CYTHON_UNUSED Py_ssize_t __pyx_v_buf_len); /* proto*/ +static PyObject *__pyx_f_7asyncpg_8protocol_8protocol_12CoreProtocol__set_server_parameter(CYTHON_UNUSED struct __pyx_obj_7asyncpg_8protocol_8protocol_CoreProtocol *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v_name, CYTHON_UNUSED PyObject *__pyx_v_val); /* proto*/ +static PyObject *__pyx_f_7asyncpg_8protocol_8protocol_12CoreProtocol__on_result(CYTHON_UNUSED struct __pyx_obj_7asyncpg_8protocol_8protocol_CoreProtocol *__pyx_v_self); /* proto*/ +static PyObject *__pyx_f_7asyncpg_8protocol_8protocol_12CoreProtocol__on_notification(CYTHON_UNUSED struct __pyx_obj_7asyncpg_8protocol_8protocol_CoreProtocol *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v_pid, CYTHON_UNUSED PyObject *__pyx_v_channel, CYTHON_UNUSED PyObject *__pyx_v_payload); /* proto*/ +static PyObject *__pyx_f_7asyncpg_8protocol_8protocol_12CoreProtocol__on_connection_lost(CYTHON_UNUSED struct __pyx_obj_7asyncpg_8protocol_8protocol_CoreProtocol *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v_exc); /* proto*/ +static PyObject *__pyx_f_7asyncpg_8protocol_8protocol_22PreparedStatementState__encode_bind_msg(struct __pyx_obj_7asyncpg_8protocol_8protocol_PreparedStatementState *__pyx_v_self, PyObject *__pyx_v_args); /* proto*/ +static PyObject *__pyx_f_7asyncpg_8protocol_8protocol_22PreparedStatementState__ensure_rows_decoder(struct __pyx_obj_7asyncpg_8protocol_8protocol_PreparedStatementState *__pyx_v_self); /* proto*/ +static PyObject *__pyx_f_7asyncpg_8protocol_8protocol_22PreparedStatementState__ensure_args_encoder(struct __pyx_obj_7asyncpg_8protocol_8protocol_PreparedStatementState *__pyx_v_self); /* proto*/ +static PyObject *__pyx_f_7asyncpg_8protocol_8protocol_22PreparedStatementState__set_row_desc(struct __pyx_obj_7asyncpg_8protocol_8protocol_PreparedStatementState *__pyx_v_self, PyObject *__pyx_v_desc); /* proto*/ +static PyObject *__pyx_f_7asyncpg_8protocol_8protocol_22PreparedStatementState__set_args_desc(struct __pyx_obj_7asyncpg_8protocol_8protocol_PreparedStatementState *__pyx_v_self, PyObject *__pyx_v_desc); /* proto*/ +static PyObject *__pyx_f_7asyncpg_8protocol_8protocol_22PreparedStatementState__decode_row(struct __pyx_obj_7asyncpg_8protocol_8protocol_PreparedStatementState *__pyx_v_self, char const *__pyx_v_cbuf, Py_ssize_t __pyx_v_buf_len); /* proto*/ +static PyObject *__pyx_f_7asyncpg_8protocol_8protocol_12BaseProtocol__handle_waiter_on_connection_lost(struct __pyx_obj_7asyncpg_8protocol_8protocol_BaseProtocol *__pyx_v_self, PyObject *__pyx_v_cause); /* proto*/ +static PyObject *__pyx_f_7asyncpg_8protocol_8protocol_12BaseProtocol__set_server_parameter(struct __pyx_obj_7asyncpg_8protocol_8protocol_BaseProtocol *__pyx_v_self, PyObject *__pyx_v_name, PyObject *__pyx_v_val); /* proto*/ +static PyObject *__pyx_f_7asyncpg_8protocol_8protocol_12BaseProtocol__ensure_clear_state(struct __pyx_obj_7asyncpg_8protocol_8protocol_BaseProtocol *__pyx_v_self); /* proto*/ +static PyObject *__pyx_f_7asyncpg_8protocol_8protocol_12BaseProtocol__new_waiter(struct __pyx_obj_7asyncpg_8protocol_8protocol_BaseProtocol *__pyx_v_self, PyObject *__pyx_v_timeout); /* proto*/ +static PyObject *__pyx_f_7asyncpg_8protocol_8protocol_12BaseProtocol__on_result__connect(CYTHON_UNUSED struct __pyx_obj_7asyncpg_8protocol_8protocol_BaseProtocol *__pyx_v_self, PyObject *__pyx_v_waiter); /* proto*/ +static PyObject *__pyx_f_7asyncpg_8protocol_8protocol_12BaseProtocol__on_result__prepare(struct __pyx_obj_7asyncpg_8protocol_8protocol_BaseProtocol *__pyx_v_self, PyObject *__pyx_v_waiter); /* proto*/ +static PyObject *__pyx_f_7asyncpg_8protocol_8protocol_12BaseProtocol__on_result__bind_and_exec(struct __pyx_obj_7asyncpg_8protocol_8protocol_BaseProtocol *__pyx_v_self, PyObject *__pyx_v_waiter); /* proto*/ +static PyObject *__pyx_f_7asyncpg_8protocol_8protocol_12BaseProtocol__on_result__bind(struct __pyx_obj_7asyncpg_8protocol_8protocol_BaseProtocol *__pyx_v_self, PyObject *__pyx_v_waiter); /* proto*/ +static PyObject *__pyx_f_7asyncpg_8protocol_8protocol_12BaseProtocol__on_result__close_stmt_or_portal(struct __pyx_obj_7asyncpg_8protocol_8protocol_BaseProtocol *__pyx_v_self, PyObject *__pyx_v_waiter); /* proto*/ +static PyObject *__pyx_f_7asyncpg_8protocol_8protocol_12BaseProtocol__on_result__simple_query(struct __pyx_obj_7asyncpg_8protocol_8protocol_BaseProtocol *__pyx_v_self, PyObject *__pyx_v_waiter); /* proto*/ +static PyObject *__pyx_f_7asyncpg_8protocol_8protocol_12BaseProtocol__decode_row(struct __pyx_obj_7asyncpg_8protocol_8protocol_BaseProtocol *__pyx_v_self, char const *__pyx_v_buf, Py_ssize_t __pyx_v_buf_len); /* proto*/ +static PyObject *__pyx_f_7asyncpg_8protocol_8protocol_12BaseProtocol__dispatch_result(struct __pyx_obj_7asyncpg_8protocol_8protocol_BaseProtocol *__pyx_v_self); /* proto*/ +static PyObject *__pyx_f_7asyncpg_8protocol_8protocol_12BaseProtocol__on_result(struct __pyx_obj_7asyncpg_8protocol_8protocol_BaseProtocol *__pyx_v_self); /* proto*/ +static PyObject *__pyx_f_7asyncpg_8protocol_8protocol_12BaseProtocol__on_notification(struct __pyx_obj_7asyncpg_8protocol_8protocol_BaseProtocol *__pyx_v_self, PyObject *__pyx_v_pid, PyObject *__pyx_v_channel, PyObject *__pyx_v_payload); /* proto*/ +static PyObject *__pyx_f_7asyncpg_8protocol_8protocol_12BaseProtocol__on_connection_lost(struct __pyx_obj_7asyncpg_8protocol_8protocol_BaseProtocol *__pyx_v_self, PyObject *__pyx_v_exc); /* proto*/ + +/* Module declarations from 'libc.stdint' */ + +/* Module declarations from 'asyncpg.protocol.debug' */ + +/* Module declarations from 'cython' */ + +/* Module declarations from 'cpython.version' */ + +/* Module declarations from '__builtin__' */ + +/* Module declarations from 'cpython.type' */ +static PyTypeObject *__pyx_ptype_7cpython_4type_type = 0; + +/* Module declarations from 'libc.string' */ + +/* Module declarations from 'libc.stdio' */ + +/* Module declarations from 'cpython.object' */ + +/* Module declarations from 'cpython.ref' */ + +/* Module declarations from 'cpython.exc' */ + +/* Module declarations from 'cpython.module' */ + +/* Module declarations from 'cpython.mem' */ + +/* Module declarations from 'cpython.tuple' */ + +/* Module declarations from 'cpython.list' */ + +/* Module declarations from 'cpython.sequence' */ + +/* Module declarations from 'cpython.mapping' */ + +/* Module declarations from 'cpython.iterator' */ + +/* Module declarations from 'cpython.number' */ + +/* Module declarations from 'cpython.int' */ + +/* Module declarations from '__builtin__' */ + +/* Module declarations from 'cpython.bool' */ +static PyTypeObject *__pyx_ptype_7cpython_4bool_bool = 0; + +/* Module declarations from 'cpython.long' */ + +/* Module declarations from 'cpython.float' */ + +/* Module declarations from '__builtin__' */ + +/* Module declarations from 'cpython.complex' */ +static PyTypeObject *__pyx_ptype_7cpython_7complex_complex = 0; + +/* Module declarations from 'cpython.string' */ + +/* Module declarations from 'cpython.unicode' */ + +/* Module declarations from 'cpython.dict' */ + +/* Module declarations from 'cpython.instance' */ + +/* Module declarations from 'cpython.function' */ + +/* Module declarations from 'cpython.method' */ + +/* Module declarations from 'cpython.weakref' */ + +/* Module declarations from 'cpython.getargs' */ + +/* Module declarations from 'cpython.pythread' */ + +/* Module declarations from 'cpython.pystate' */ + +/* Module declarations from 'cpython.cobject' */ + +/* Module declarations from 'cpython.oldbuffer' */ + +/* Module declarations from 'cpython.set' */ + +/* Module declarations from 'cpython.buffer' */ + +/* Module declarations from 'cpython.bytes' */ + +/* Module declarations from 'cpython.pycapsule' */ + +/* Module declarations from 'cpython' */ + +/* Module declarations from 'asyncpg.protocol' */ + +/* Module declarations from 'asyncpg.protocol.record' */ + +/* Module declarations from 'asyncpg.protocol.python' */ + +/* Module declarations from 'asyncpg.protocol.hton' */ +static CYTHON_INLINE void __pyx_f_7asyncpg_8protocol_4hton_pack_int16(char *, int16_t); /*proto*/ +static CYTHON_INLINE int16_t __pyx_f_7asyncpg_8protocol_4hton_unpack_int16(char const *); /*proto*/ +static CYTHON_INLINE void __pyx_f_7asyncpg_8protocol_4hton_pack_int32(char *, int32_t); /*proto*/ +static CYTHON_INLINE int32_t __pyx_f_7asyncpg_8protocol_4hton_unpack_int32(char const *); /*proto*/ +static CYTHON_INLINE void __pyx_f_7asyncpg_8protocol_4hton_pack_int64(char *, int64_t); /*proto*/ +static CYTHON_INLINE int64_t __pyx_f_7asyncpg_8protocol_4hton_unpack_int64(char const *); /*proto*/ +static CYTHON_INLINE int32_t __pyx_f_7asyncpg_8protocol_4hton_pack_float(char *, float); /*proto*/ +static CYTHON_INLINE float __pyx_f_7asyncpg_8protocol_4hton_unpack_float(char const *); /*proto*/ +static CYTHON_INLINE int64_t __pyx_f_7asyncpg_8protocol_4hton_pack_double(char *, double); /*proto*/ +static CYTHON_INLINE double __pyx_f_7asyncpg_8protocol_4hton_unpack_double(char const *); /*proto*/ + +/* Module declarations from 'libc' */ + +/* Module declarations from 'libc.math' */ + +/* Module declarations from 'asyncpg.protocol.protocol' */ +static PyTypeObject *__pyx_ptype_7asyncpg_8protocol_8protocol_Memory = 0; +static PyTypeObject *__pyx_ptype_7asyncpg_8protocol_8protocol_WriteBuffer = 0; +static PyTypeObject *__pyx_ptype_7asyncpg_8protocol_8protocol_ReadBuffer = 0; +static PyTypeObject *__pyx_ptype_7asyncpg_8protocol_8protocol_FastReadBuffer = 0; +static PyTypeObject *__pyx_ptype_7asyncpg_8protocol_8protocol_Codec = 0; +static PyTypeObject *__pyx_ptype_7asyncpg_8protocol_8protocol_DataCodecConfig = 0; +static PyTypeObject *__pyx_ptype_7asyncpg_8protocol_8protocol_ConnectionSettings = 0; +static PyTypeObject *__pyx_ptype_7asyncpg_8protocol_8protocol_CoreProtocol = 0; +static PyTypeObject *__pyx_ptype_7asyncpg_8protocol_8protocol_PreparedStatementState = 0; +static PyTypeObject *__pyx_ptype_7asyncpg_8protocol_8protocol_BaseProtocol = 0; +static PyTypeObject *__pyx_ptype_7asyncpg_8protocol_8protocol___pyx_scope_struct__prepare = 0; +static PyTypeObject *__pyx_ptype_7asyncpg_8protocol_8protocol___pyx_scope_struct_1_bind_execute = 0; +static PyTypeObject *__pyx_ptype_7asyncpg_8protocol_8protocol___pyx_scope_struct_2_bind_execute_many = 0; +static PyTypeObject *__pyx_ptype_7asyncpg_8protocol_8protocol___pyx_scope_struct_3_genexpr = 0; +static PyTypeObject *__pyx_ptype_7asyncpg_8protocol_8protocol___pyx_scope_struct_4_bind = 0; +static PyTypeObject *__pyx_ptype_7asyncpg_8protocol_8protocol___pyx_scope_struct_5_execute = 0; +static PyTypeObject *__pyx_ptype_7asyncpg_8protocol_8protocol___pyx_scope_struct_6_query = 0; +static PyTypeObject *__pyx_ptype_7asyncpg_8protocol_8protocol___pyx_scope_struct_7_close_statement = 0; +static PyTypeObject *__pyx_ptype_7asyncpg_8protocol_8protocol___pyx_scope_struct_8_close = 0; +static PyObject *__pyx_v_7asyncpg_8protocol_8protocol_ARRAY_TYPES = 0; +static PyObject *__pyx_v_7asyncpg_8protocol_8protocol_ENCODINGS_MAP = 0; +static void *__pyx_v_7asyncpg_8protocol_8protocol_binary_codec_map[(0x1000 + 1)]; +static void *__pyx_v_7asyncpg_8protocol_8protocol_text_codec_map[(0x1000 + 1)]; +static PyObject *__pyx_v_7asyncpg_8protocol_8protocol_TYPE_CODECS_CACHE = 0; +static PyObject *__pyx_v_7asyncpg_8protocol_8protocol_EXTRA_CODECS = 0; +static int32_t __pyx_v_7asyncpg_8protocol_8protocol_pg_epoch_datetime_ts; +static int32_t __pyx_v_7asyncpg_8protocol_8protocol_pg_epoch_datetime_utc_ts; +static int32_t __pyx_v_7asyncpg_8protocol_8protocol_pg_date_offset_ord; +static int64_t __pyx_v_7asyncpg_8protocol_8protocol_pg_time64_infinity; +static int64_t __pyx_v_7asyncpg_8protocol_8protocol_pg_time64_negative_infinity; +static int32_t __pyx_v_7asyncpg_8protocol_8protocol_pg_date_infinity; +static int32_t __pyx_v_7asyncpg_8protocol_8protocol_pg_date_negative_infinity; +static int32_t __pyx_v_7asyncpg_8protocol_8protocol_infinity_datetime_ord; +static int64_t __pyx_v_7asyncpg_8protocol_8protocol_infinity_datetime_ts; +static int32_t __pyx_v_7asyncpg_8protocol_8protocol_negative_infinity_datetime_ord; +static int64_t __pyx_v_7asyncpg_8protocol_8protocol_negative_infinity_datetime_ts; +static int32_t __pyx_v_7asyncpg_8protocol_8protocol_infinity_date_ord; +static int32_t __pyx_v_7asyncpg_8protocol_8protocol_negative_infinity_date_ord; +static Py_UCS4 *__pyx_v_7asyncpg_8protocol_8protocol_APG_NULL; +static PyObject *__pyx_v_7asyncpg_8protocol_8protocol_SYNC_MESSAGE = 0; +static PyObject *__pyx_f_7asyncpg_8protocol_8protocol_get_python_encoding(PyObject *); /*proto*/ +static PyObject *__pyx_f_7asyncpg_8protocol_8protocol_codec_encode_func_ex(struct __pyx_obj_7asyncpg_8protocol_8protocol_ConnectionSettings *, struct __pyx_obj_7asyncpg_8protocol_8protocol_WriteBuffer *, PyObject *, void const *); /*proto*/ +static PyObject *__pyx_f_7asyncpg_8protocol_8protocol_codec_decode_func_ex(struct __pyx_obj_7asyncpg_8protocol_8protocol_ConnectionSettings *, struct __pyx_obj_7asyncpg_8protocol_8protocol_FastReadBuffer *, void const *); /*proto*/ +static CYTHON_INLINE struct __pyx_obj_7asyncpg_8protocol_8protocol_Codec *__pyx_f_7asyncpg_8protocol_8protocol_get_core_codec(uint32_t, enum __pyx_t_7asyncpg_8protocol_8protocol_CodecFormat); /*proto*/ +static CYTHON_INLINE int __pyx_f_7asyncpg_8protocol_8protocol_has_core_codec(uint32_t); /*proto*/ +static PyObject *__pyx_f_7asyncpg_8protocol_8protocol_register_core_codec(uint32_t, __pyx_t_7asyncpg_8protocol_8protocol_encode_func, __pyx_t_7asyncpg_8protocol_8protocol_decode_func, enum __pyx_t_7asyncpg_8protocol_8protocol_CodecFormat); /*proto*/ +static PyObject *__pyx_f_7asyncpg_8protocol_8protocol_register_extra_codec(PyObject *, __pyx_t_7asyncpg_8protocol_8protocol_encode_func, __pyx_t_7asyncpg_8protocol_8protocol_decode_func, enum __pyx_t_7asyncpg_8protocol_8protocol_CodecFormat); /*proto*/ +static CYTHON_INLINE struct __pyx_obj_7asyncpg_8protocol_8protocol_Codec *__pyx_f_7asyncpg_8protocol_8protocol_get_extra_codec(PyObject *, enum __pyx_t_7asyncpg_8protocol_8protocol_CodecFormat); /*proto*/ +static int __pyx_f_7asyncpg_8protocol_8protocol_apg_strcasecmp(Py_UCS4 const *, Py_UCS4 const *); /*proto*/ +static CYTHON_INLINE int __pyx_f_7asyncpg_8protocol_8protocol_apg_ascii_isspace(Py_UCS4); /*proto*/ +static Py_UCS4 *__pyx_f_7asyncpg_8protocol_8protocol_apg_parse_int32(Py_UCS4 *, int32_t *); /*proto*/ +static PyObject *__pyx_f_7asyncpg_8protocol_8protocol_bytea_encode(struct __pyx_obj_7asyncpg_8protocol_8protocol_ConnectionSettings *, struct __pyx_obj_7asyncpg_8protocol_8protocol_WriteBuffer *, PyObject *); /*proto*/ +static PyObject *__pyx_f_7asyncpg_8protocol_8protocol_bytea_decode(struct __pyx_obj_7asyncpg_8protocol_8protocol_ConnectionSettings *, struct __pyx_obj_7asyncpg_8protocol_8protocol_FastReadBuffer *); /*proto*/ +static PyObject *__pyx_f_7asyncpg_8protocol_8protocol_init_bytea_codecs(void); /*proto*/ +static CYTHON_INLINE PyObject *__pyx_f_7asyncpg_8protocol_8protocol_as_pg_string_and_size(struct __pyx_obj_7asyncpg_8protocol_8protocol_ConnectionSettings *, PyObject *, char **, Py_ssize_t *); /*proto*/ +static PyObject *__pyx_f_7asyncpg_8protocol_8protocol_text_encode(struct __pyx_obj_7asyncpg_8protocol_8protocol_ConnectionSettings *, struct __pyx_obj_7asyncpg_8protocol_8protocol_WriteBuffer *, PyObject *); /*proto*/ +static CYTHON_INLINE PyObject *__pyx_f_7asyncpg_8protocol_8protocol_decode_pg_string(struct __pyx_obj_7asyncpg_8protocol_8protocol_ConnectionSettings *, char const *, Py_ssize_t); /*proto*/ +static PyObject *__pyx_f_7asyncpg_8protocol_8protocol_text_decode(struct __pyx_obj_7asyncpg_8protocol_8protocol_ConnectionSettings *, struct __pyx_obj_7asyncpg_8protocol_8protocol_FastReadBuffer *); /*proto*/ +static PyObject *__pyx_f_7asyncpg_8protocol_8protocol_init_text_codecs(void); /*proto*/ +static PyObject *__pyx_f_7asyncpg_8protocol_8protocol_bits_encode(struct __pyx_obj_7asyncpg_8protocol_8protocol_ConnectionSettings *, struct __pyx_obj_7asyncpg_8protocol_8protocol_WriteBuffer *, PyObject *); /*proto*/ +static PyObject *__pyx_f_7asyncpg_8protocol_8protocol_bits_decode(struct __pyx_obj_7asyncpg_8protocol_8protocol_ConnectionSettings *, struct __pyx_obj_7asyncpg_8protocol_8protocol_FastReadBuffer *); /*proto*/ +static PyObject *__pyx_f_7asyncpg_8protocol_8protocol_init_bits_codecs(void); /*proto*/ +static CYTHON_INLINE PyObject *__pyx_f_7asyncpg_8protocol_8protocol__encode_time(struct __pyx_obj_7asyncpg_8protocol_8protocol_WriteBuffer *, int64_t, int32_t); /*proto*/ +static CYTHON_INLINE int32_t __pyx_f_7asyncpg_8protocol_8protocol__decode_time(struct __pyx_obj_7asyncpg_8protocol_8protocol_FastReadBuffer *, int64_t *, uint32_t *); /*proto*/ +static PyObject *__pyx_f_7asyncpg_8protocol_8protocol_date_encode(struct __pyx_obj_7asyncpg_8protocol_8protocol_ConnectionSettings *, struct __pyx_obj_7asyncpg_8protocol_8protocol_WriteBuffer *, PyObject *); /*proto*/ +static PyObject *__pyx_f_7asyncpg_8protocol_8protocol_date_decode(struct __pyx_obj_7asyncpg_8protocol_8protocol_ConnectionSettings *, struct __pyx_obj_7asyncpg_8protocol_8protocol_FastReadBuffer *); /*proto*/ +static PyObject *__pyx_f_7asyncpg_8protocol_8protocol_timestamp_encode(struct __pyx_obj_7asyncpg_8protocol_8protocol_ConnectionSettings *, struct __pyx_obj_7asyncpg_8protocol_8protocol_WriteBuffer *, PyObject *); /*proto*/ +static PyObject *__pyx_f_7asyncpg_8protocol_8protocol_timestamp_decode(struct __pyx_obj_7asyncpg_8protocol_8protocol_ConnectionSettings *, struct __pyx_obj_7asyncpg_8protocol_8protocol_FastReadBuffer *); /*proto*/ +static PyObject *__pyx_f_7asyncpg_8protocol_8protocol_timestamptz_encode(struct __pyx_obj_7asyncpg_8protocol_8protocol_ConnectionSettings *, struct __pyx_obj_7asyncpg_8protocol_8protocol_WriteBuffer *, PyObject *); /*proto*/ +static PyObject *__pyx_f_7asyncpg_8protocol_8protocol_timestamptz_decode(struct __pyx_obj_7asyncpg_8protocol_8protocol_ConnectionSettings *, struct __pyx_obj_7asyncpg_8protocol_8protocol_FastReadBuffer *); /*proto*/ +static PyObject *__pyx_f_7asyncpg_8protocol_8protocol_time_encode(struct __pyx_obj_7asyncpg_8protocol_8protocol_ConnectionSettings *, struct __pyx_obj_7asyncpg_8protocol_8protocol_WriteBuffer *, PyObject *); /*proto*/ +static PyObject *__pyx_f_7asyncpg_8protocol_8protocol_time_decode(struct __pyx_obj_7asyncpg_8protocol_8protocol_ConnectionSettings *, struct __pyx_obj_7asyncpg_8protocol_8protocol_FastReadBuffer *); /*proto*/ +static PyObject *__pyx_f_7asyncpg_8protocol_8protocol_timetz_encode(struct __pyx_obj_7asyncpg_8protocol_8protocol_ConnectionSettings *, struct __pyx_obj_7asyncpg_8protocol_8protocol_WriteBuffer *, PyObject *); /*proto*/ +static PyObject *__pyx_f_7asyncpg_8protocol_8protocol_timetz_decode(struct __pyx_obj_7asyncpg_8protocol_8protocol_ConnectionSettings *, struct __pyx_obj_7asyncpg_8protocol_8protocol_FastReadBuffer *); /*proto*/ +static PyObject *__pyx_f_7asyncpg_8protocol_8protocol_interval_encode(struct __pyx_obj_7asyncpg_8protocol_8protocol_ConnectionSettings *, struct __pyx_obj_7asyncpg_8protocol_8protocol_WriteBuffer *, PyObject *); /*proto*/ +static PyObject *__pyx_f_7asyncpg_8protocol_8protocol_interval_decode(struct __pyx_obj_7asyncpg_8protocol_8protocol_ConnectionSettings *, struct __pyx_obj_7asyncpg_8protocol_8protocol_FastReadBuffer *); /*proto*/ +static PyObject *__pyx_f_7asyncpg_8protocol_8protocol_init_datetime_codecs(void); /*proto*/ +static PyObject *__pyx_f_7asyncpg_8protocol_8protocol_float4_encode(struct __pyx_obj_7asyncpg_8protocol_8protocol_ConnectionSettings *, struct __pyx_obj_7asyncpg_8protocol_8protocol_WriteBuffer *, PyObject *); /*proto*/ +static PyObject *__pyx_f_7asyncpg_8protocol_8protocol_float4_decode(struct __pyx_obj_7asyncpg_8protocol_8protocol_ConnectionSettings *, struct __pyx_obj_7asyncpg_8protocol_8protocol_FastReadBuffer *); /*proto*/ +static PyObject *__pyx_f_7asyncpg_8protocol_8protocol_float8_encode(struct __pyx_obj_7asyncpg_8protocol_8protocol_ConnectionSettings *, struct __pyx_obj_7asyncpg_8protocol_8protocol_WriteBuffer *, PyObject *); /*proto*/ +static PyObject *__pyx_f_7asyncpg_8protocol_8protocol_float8_decode(struct __pyx_obj_7asyncpg_8protocol_8protocol_ConnectionSettings *, struct __pyx_obj_7asyncpg_8protocol_8protocol_FastReadBuffer *); /*proto*/ +static PyObject *__pyx_f_7asyncpg_8protocol_8protocol_init_float_codecs(void); /*proto*/ +static CYTHON_INLINE PyObject *__pyx_f_7asyncpg_8protocol_8protocol__encode_points(struct __pyx_obj_7asyncpg_8protocol_8protocol_WriteBuffer *, PyObject *); /*proto*/ +static CYTHON_INLINE PyObject *__pyx_f_7asyncpg_8protocol_8protocol__decode_points(struct __pyx_obj_7asyncpg_8protocol_8protocol_FastReadBuffer *); /*proto*/ +static PyObject *__pyx_f_7asyncpg_8protocol_8protocol_box_encode(struct __pyx_obj_7asyncpg_8protocol_8protocol_ConnectionSettings *, struct __pyx_obj_7asyncpg_8protocol_8protocol_WriteBuffer *, PyObject *); /*proto*/ +static PyObject *__pyx_f_7asyncpg_8protocol_8protocol_box_decode(struct __pyx_obj_7asyncpg_8protocol_8protocol_ConnectionSettings *, struct __pyx_obj_7asyncpg_8protocol_8protocol_FastReadBuffer *); /*proto*/ +static PyObject *__pyx_f_7asyncpg_8protocol_8protocol_line_encode(struct __pyx_obj_7asyncpg_8protocol_8protocol_ConnectionSettings *, struct __pyx_obj_7asyncpg_8protocol_8protocol_WriteBuffer *, PyObject *); /*proto*/ +static PyObject *__pyx_f_7asyncpg_8protocol_8protocol_line_decode(struct __pyx_obj_7asyncpg_8protocol_8protocol_ConnectionSettings *, struct __pyx_obj_7asyncpg_8protocol_8protocol_FastReadBuffer *); /*proto*/ +static PyObject *__pyx_f_7asyncpg_8protocol_8protocol_lseg_encode(struct __pyx_obj_7asyncpg_8protocol_8protocol_ConnectionSettings *, struct __pyx_obj_7asyncpg_8protocol_8protocol_WriteBuffer *, PyObject *); /*proto*/ +static PyObject *__pyx_f_7asyncpg_8protocol_8protocol_lseg_decode(struct __pyx_obj_7asyncpg_8protocol_8protocol_ConnectionSettings *, struct __pyx_obj_7asyncpg_8protocol_8protocol_FastReadBuffer *); /*proto*/ +static PyObject *__pyx_f_7asyncpg_8protocol_8protocol_point_encode(struct __pyx_obj_7asyncpg_8protocol_8protocol_ConnectionSettings *, struct __pyx_obj_7asyncpg_8protocol_8protocol_WriteBuffer *, PyObject *); /*proto*/ +static PyObject *__pyx_f_7asyncpg_8protocol_8protocol_point_decode(struct __pyx_obj_7asyncpg_8protocol_8protocol_ConnectionSettings *, struct __pyx_obj_7asyncpg_8protocol_8protocol_FastReadBuffer *); /*proto*/ +static PyObject *__pyx_f_7asyncpg_8protocol_8protocol_path_encode(struct __pyx_obj_7asyncpg_8protocol_8protocol_ConnectionSettings *, struct __pyx_obj_7asyncpg_8protocol_8protocol_WriteBuffer *, PyObject *); /*proto*/ +static PyObject *__pyx_f_7asyncpg_8protocol_8protocol_path_decode(struct __pyx_obj_7asyncpg_8protocol_8protocol_ConnectionSettings *, struct __pyx_obj_7asyncpg_8protocol_8protocol_FastReadBuffer *); /*proto*/ +static PyObject *__pyx_f_7asyncpg_8protocol_8protocol_poly_encode(struct __pyx_obj_7asyncpg_8protocol_8protocol_ConnectionSettings *, struct __pyx_obj_7asyncpg_8protocol_8protocol_WriteBuffer *, PyObject *); /*proto*/ +static PyObject *__pyx_f_7asyncpg_8protocol_8protocol_poly_decode(struct __pyx_obj_7asyncpg_8protocol_8protocol_ConnectionSettings *, struct __pyx_obj_7asyncpg_8protocol_8protocol_FastReadBuffer *); /*proto*/ +static PyObject *__pyx_f_7asyncpg_8protocol_8protocol_circle_encode(struct __pyx_obj_7asyncpg_8protocol_8protocol_ConnectionSettings *, struct __pyx_obj_7asyncpg_8protocol_8protocol_WriteBuffer *, PyObject *); /*proto*/ +static PyObject *__pyx_f_7asyncpg_8protocol_8protocol_circle_decode(struct __pyx_obj_7asyncpg_8protocol_8protocol_ConnectionSettings *, struct __pyx_obj_7asyncpg_8protocol_8protocol_FastReadBuffer *); /*proto*/ +static PyObject *__pyx_f_7asyncpg_8protocol_8protocol_init_geometry_codecs(void); /*proto*/ +static PyObject *__pyx_f_7asyncpg_8protocol_8protocol_bool_encode(struct __pyx_obj_7asyncpg_8protocol_8protocol_ConnectionSettings *, struct __pyx_obj_7asyncpg_8protocol_8protocol_WriteBuffer *, PyObject *); /*proto*/ +static PyObject *__pyx_f_7asyncpg_8protocol_8protocol_bool_decode(struct __pyx_obj_7asyncpg_8protocol_8protocol_ConnectionSettings *, struct __pyx_obj_7asyncpg_8protocol_8protocol_FastReadBuffer *); /*proto*/ +static PyObject *__pyx_f_7asyncpg_8protocol_8protocol_int2_encode(struct __pyx_obj_7asyncpg_8protocol_8protocol_ConnectionSettings *, struct __pyx_obj_7asyncpg_8protocol_8protocol_WriteBuffer *, PyObject *); /*proto*/ +static PyObject *__pyx_f_7asyncpg_8protocol_8protocol_int2_decode(struct __pyx_obj_7asyncpg_8protocol_8protocol_ConnectionSettings *, struct __pyx_obj_7asyncpg_8protocol_8protocol_FastReadBuffer *); /*proto*/ +static PyObject *__pyx_f_7asyncpg_8protocol_8protocol_int4_encode(struct __pyx_obj_7asyncpg_8protocol_8protocol_ConnectionSettings *, struct __pyx_obj_7asyncpg_8protocol_8protocol_WriteBuffer *, PyObject *); /*proto*/ +static PyObject *__pyx_f_7asyncpg_8protocol_8protocol_int4_decode(struct __pyx_obj_7asyncpg_8protocol_8protocol_ConnectionSettings *, struct __pyx_obj_7asyncpg_8protocol_8protocol_FastReadBuffer *); /*proto*/ +static PyObject *__pyx_f_7asyncpg_8protocol_8protocol_int8_encode(struct __pyx_obj_7asyncpg_8protocol_8protocol_ConnectionSettings *, struct __pyx_obj_7asyncpg_8protocol_8protocol_WriteBuffer *, PyObject *); /*proto*/ +static PyObject *__pyx_f_7asyncpg_8protocol_8protocol_int8_decode(struct __pyx_obj_7asyncpg_8protocol_8protocol_ConnectionSettings *, struct __pyx_obj_7asyncpg_8protocol_8protocol_FastReadBuffer *); /*proto*/ +static PyObject *__pyx_f_7asyncpg_8protocol_8protocol_init_int_codecs(void); /*proto*/ +static PyObject *__pyx_f_7asyncpg_8protocol_8protocol_jsonb_encode(struct __pyx_obj_7asyncpg_8protocol_8protocol_ConnectionSettings *, struct __pyx_obj_7asyncpg_8protocol_8protocol_WriteBuffer *, PyObject *); /*proto*/ +static PyObject *__pyx_f_7asyncpg_8protocol_8protocol_jsonb_decode(struct __pyx_obj_7asyncpg_8protocol_8protocol_ConnectionSettings *, struct __pyx_obj_7asyncpg_8protocol_8protocol_FastReadBuffer *); /*proto*/ +static PyObject *__pyx_f_7asyncpg_8protocol_8protocol_init_json_codecs(void); /*proto*/ +static PyObject *__pyx_f_7asyncpg_8protocol_8protocol_init_monetary_codecs(void); /*proto*/ +static CYTHON_INLINE PyObject *__pyx_f_7asyncpg_8protocol_8protocol__net_encode(struct __pyx_obj_7asyncpg_8protocol_8protocol_WriteBuffer *, int32_t, uint8_t, int8_t, PyObject *); /*proto*/ +static PyObject *__pyx_f_7asyncpg_8protocol_8protocol_net_decode(struct __pyx_obj_7asyncpg_8protocol_8protocol_ConnectionSettings *, struct __pyx_obj_7asyncpg_8protocol_8protocol_FastReadBuffer *); /*proto*/ +static PyObject *__pyx_f_7asyncpg_8protocol_8protocol_cidr_encode(struct __pyx_obj_7asyncpg_8protocol_8protocol_ConnectionSettings *, struct __pyx_obj_7asyncpg_8protocol_8protocol_WriteBuffer *, PyObject *); /*proto*/ +static PyObject *__pyx_f_7asyncpg_8protocol_8protocol_inet_encode(struct __pyx_obj_7asyncpg_8protocol_8protocol_ConnectionSettings *, struct __pyx_obj_7asyncpg_8protocol_8protocol_WriteBuffer *, PyObject *); /*proto*/ +static PyObject *__pyx_f_7asyncpg_8protocol_8protocol_init_network_codecs(void); /*proto*/ +static PyObject *__pyx_f_7asyncpg_8protocol_8protocol_numeric_encode(struct __pyx_obj_7asyncpg_8protocol_8protocol_ConnectionSettings *, struct __pyx_obj_7asyncpg_8protocol_8protocol_WriteBuffer *, PyObject *); /*proto*/ +static PyObject *__pyx_f_7asyncpg_8protocol_8protocol_numeric_decode(struct __pyx_obj_7asyncpg_8protocol_8protocol_ConnectionSettings *, struct __pyx_obj_7asyncpg_8protocol_8protocol_FastReadBuffer *); /*proto*/ +static PyObject *__pyx_f_7asyncpg_8protocol_8protocol_init_numeric_codecs(void); /*proto*/ +static PyObject *__pyx_f_7asyncpg_8protocol_8protocol_init_tsearch_codecs(void); /*proto*/ +static PyObject *__pyx_f_7asyncpg_8protocol_8protocol_txid_snapshot_encode(struct __pyx_obj_7asyncpg_8protocol_8protocol_ConnectionSettings *, struct __pyx_obj_7asyncpg_8protocol_8protocol_WriteBuffer *, PyObject *); /*proto*/ +static PyObject *__pyx_f_7asyncpg_8protocol_8protocol_txid_snapshot_decode(struct __pyx_obj_7asyncpg_8protocol_8protocol_ConnectionSettings *, struct __pyx_obj_7asyncpg_8protocol_8protocol_FastReadBuffer *); /*proto*/ +static PyObject *__pyx_f_7asyncpg_8protocol_8protocol_init_txid_codecs(void); /*proto*/ +static PyObject *__pyx_f_7asyncpg_8protocol_8protocol_uuid_encode(struct __pyx_obj_7asyncpg_8protocol_8protocol_ConnectionSettings *, struct __pyx_obj_7asyncpg_8protocol_8protocol_WriteBuffer *, PyObject *); /*proto*/ +static PyObject *__pyx_f_7asyncpg_8protocol_8protocol_uuid_decode(struct __pyx_obj_7asyncpg_8protocol_8protocol_ConnectionSettings *, struct __pyx_obj_7asyncpg_8protocol_8protocol_FastReadBuffer *); /*proto*/ +static PyObject *__pyx_f_7asyncpg_8protocol_8protocol_init_uuid_codecs(void); /*proto*/ +static PyObject *__pyx_f_7asyncpg_8protocol_8protocol_void_encode(struct __pyx_obj_7asyncpg_8protocol_8protocol_ConnectionSettings *, struct __pyx_obj_7asyncpg_8protocol_8protocol_WriteBuffer *, PyObject *); /*proto*/ +static PyObject *__pyx_f_7asyncpg_8protocol_8protocol_void_decode(struct __pyx_obj_7asyncpg_8protocol_8protocol_ConnectionSettings *, struct __pyx_obj_7asyncpg_8protocol_8protocol_FastReadBuffer *); /*proto*/ +static PyObject *__pyx_f_7asyncpg_8protocol_8protocol_init_pseudo_codecs(void); /*proto*/ +static CYTHON_INLINE int __pyx_f_7asyncpg_8protocol_8protocol__is_trivial_container(PyObject *); /*proto*/ +static CYTHON_INLINE PyObject *__pyx_f_7asyncpg_8protocol_8protocol__is_container(PyObject *); /*proto*/ +static CYTHON_INLINE PyObject *__pyx_f_7asyncpg_8protocol_8protocol__is_sub_array(PyObject *); /*proto*/ +static PyObject *__pyx_f_7asyncpg_8protocol_8protocol__get_array_shape(PyObject *, int32_t *, int32_t *); /*proto*/ +static PyObject *__pyx_f_7asyncpg_8protocol_8protocol__write_array_data(struct __pyx_obj_7asyncpg_8protocol_8protocol_ConnectionSettings *, PyObject *, int32_t, int32_t, struct __pyx_obj_7asyncpg_8protocol_8protocol_WriteBuffer *, __pyx_t_7asyncpg_8protocol_8protocol_encode_func_ex, void const *); /*proto*/ +static CYTHON_INLINE PyObject *__pyx_f_7asyncpg_8protocol_8protocol_array_encode(struct __pyx_obj_7asyncpg_8protocol_8protocol_ConnectionSettings *, struct __pyx_obj_7asyncpg_8protocol_8protocol_WriteBuffer *, PyObject *, uint32_t, __pyx_t_7asyncpg_8protocol_8protocol_encode_func_ex, void const *); /*proto*/ +static CYTHON_INLINE PyObject *__pyx_f_7asyncpg_8protocol_8protocol_array_decode(struct __pyx_obj_7asyncpg_8protocol_8protocol_ConnectionSettings *, struct __pyx_obj_7asyncpg_8protocol_8protocol_FastReadBuffer *, __pyx_t_7asyncpg_8protocol_8protocol_decode_func_ex, void const *); /*proto*/ +static CYTHON_INLINE PyObject *__pyx_f_7asyncpg_8protocol_8protocol__nested_array_decode(struct __pyx_obj_7asyncpg_8protocol_8protocol_ConnectionSettings *, struct __pyx_obj_7asyncpg_8protocol_8protocol_FastReadBuffer *, __pyx_t_7asyncpg_8protocol_8protocol_decode_func_ex, void const *, int32_t, int32_t *, struct __pyx_obj_7asyncpg_8protocol_8protocol_FastReadBuffer *); /*proto*/ +static PyObject *__pyx_f_7asyncpg_8protocol_8protocol_textarray_decode(struct __pyx_obj_7asyncpg_8protocol_8protocol_ConnectionSettings *, struct __pyx_obj_7asyncpg_8protocol_8protocol_FastReadBuffer *, __pyx_t_7asyncpg_8protocol_8protocol_decode_func_ex, void const *, Py_UCS4); /*proto*/ +static PyObject *__pyx_f_7asyncpg_8protocol_8protocol__textarray_decode(struct __pyx_obj_7asyncpg_8protocol_8protocol_ConnectionSettings *, Py_UCS4 *, __pyx_t_7asyncpg_8protocol_8protocol_decode_func_ex, void const *, Py_UCS4); /*proto*/ +static PyObject *__pyx_f_7asyncpg_8protocol_8protocol__UnexpectedCharacter(Py_UCS4 const *, Py_UCS4 const *); /*proto*/ +static PyObject *__pyx_f_7asyncpg_8protocol_8protocol__infer_array_dims(Py_UCS4 const *, Py_UCS4, int32_t *, int32_t *); /*proto*/ +static PyObject *__pyx_f_7asyncpg_8protocol_8protocol_int4_encode_ex(struct __pyx_obj_7asyncpg_8protocol_8protocol_ConnectionSettings *, struct __pyx_obj_7asyncpg_8protocol_8protocol_WriteBuffer *, PyObject *, void const *); /*proto*/ +static PyObject *__pyx_f_7asyncpg_8protocol_8protocol_int4_decode_ex(struct __pyx_obj_7asyncpg_8protocol_8protocol_ConnectionSettings *, struct __pyx_obj_7asyncpg_8protocol_8protocol_FastReadBuffer *, void const *); /*proto*/ +static PyObject *__pyx_f_7asyncpg_8protocol_8protocol_arrayoid_encode(struct __pyx_obj_7asyncpg_8protocol_8protocol_ConnectionSettings *, struct __pyx_obj_7asyncpg_8protocol_8protocol_WriteBuffer *, PyObject *); /*proto*/ +static PyObject *__pyx_f_7asyncpg_8protocol_8protocol_arrayoid_decode(struct __pyx_obj_7asyncpg_8protocol_8protocol_ConnectionSettings *, struct __pyx_obj_7asyncpg_8protocol_8protocol_FastReadBuffer *); /*proto*/ +static PyObject *__pyx_f_7asyncpg_8protocol_8protocol_text_encode_ex(struct __pyx_obj_7asyncpg_8protocol_8protocol_ConnectionSettings *, struct __pyx_obj_7asyncpg_8protocol_8protocol_WriteBuffer *, PyObject *, void const *); /*proto*/ +static PyObject *__pyx_f_7asyncpg_8protocol_8protocol_text_decode_ex(struct __pyx_obj_7asyncpg_8protocol_8protocol_ConnectionSettings *, struct __pyx_obj_7asyncpg_8protocol_8protocol_FastReadBuffer *, void const *); /*proto*/ +static PyObject *__pyx_f_7asyncpg_8protocol_8protocol_arraytext_encode(struct __pyx_obj_7asyncpg_8protocol_8protocol_ConnectionSettings *, struct __pyx_obj_7asyncpg_8protocol_8protocol_WriteBuffer *, PyObject *); /*proto*/ +static PyObject *__pyx_f_7asyncpg_8protocol_8protocol_arraytext_decode(struct __pyx_obj_7asyncpg_8protocol_8protocol_ConnectionSettings *, struct __pyx_obj_7asyncpg_8protocol_8protocol_FastReadBuffer *); /*proto*/ +static PyObject *__pyx_f_7asyncpg_8protocol_8protocol_anyarray_decode(struct __pyx_obj_7asyncpg_8protocol_8protocol_ConnectionSettings *, struct __pyx_obj_7asyncpg_8protocol_8protocol_FastReadBuffer *); /*proto*/ +static PyObject *__pyx_f_7asyncpg_8protocol_8protocol_init_array_codecs(void); /*proto*/ +static CYTHON_INLINE int __pyx_f_7asyncpg_8protocol_8protocol__range_has_lbound(uint8_t); /*proto*/ +static CYTHON_INLINE int __pyx_f_7asyncpg_8protocol_8protocol__range_has_ubound(uint8_t); /*proto*/ +static CYTHON_INLINE enum __pyx_t_7asyncpg_8protocol_8protocol__RangeArgumentType __pyx_f_7asyncpg_8protocol_8protocol__range_type(PyObject *); /*proto*/ +static PyObject *__pyx_f_7asyncpg_8protocol_8protocol_range_encode(struct __pyx_obj_7asyncpg_8protocol_8protocol_ConnectionSettings *, struct __pyx_obj_7asyncpg_8protocol_8protocol_WriteBuffer *, PyObject *, uint32_t, __pyx_t_7asyncpg_8protocol_8protocol_encode_func_ex, void const *); /*proto*/ +static PyObject *__pyx_f_7asyncpg_8protocol_8protocol_range_decode(struct __pyx_obj_7asyncpg_8protocol_8protocol_ConnectionSettings *, struct __pyx_obj_7asyncpg_8protocol_8protocol_FastReadBuffer *, __pyx_t_7asyncpg_8protocol_8protocol_decode_func_ex, void const *); /*proto*/ +static PyObject *__pyx_f_7asyncpg_8protocol_8protocol_init_range_codecs(void); /*proto*/ +static CYTHON_INLINE PyObject *__pyx_f_7asyncpg_8protocol_8protocol_record_encode_frame(struct __pyx_obj_7asyncpg_8protocol_8protocol_ConnectionSettings *, struct __pyx_obj_7asyncpg_8protocol_8protocol_WriteBuffer *, struct __pyx_obj_7asyncpg_8protocol_8protocol_WriteBuffer *, int32_t); /*proto*/ +static PyObject *__pyx_f_7asyncpg_8protocol_8protocol_anonymous_record_decode(struct __pyx_obj_7asyncpg_8protocol_8protocol_ConnectionSettings *, struct __pyx_obj_7asyncpg_8protocol_8protocol_FastReadBuffer *); /*proto*/ +static PyObject *__pyx_f_7asyncpg_8protocol_8protocol_init_record_codecs(void); /*proto*/ +static PyObject *__pyx_f_7asyncpg_8protocol_8protocol_hstore_encode(struct __pyx_obj_7asyncpg_8protocol_8protocol_ConnectionSettings *, struct __pyx_obj_7asyncpg_8protocol_8protocol_WriteBuffer *, PyObject *); /*proto*/ +static PyObject *__pyx_f_7asyncpg_8protocol_8protocol_hstore_decode(struct __pyx_obj_7asyncpg_8protocol_8protocol_ConnectionSettings *, struct __pyx_obj_7asyncpg_8protocol_8protocol_FastReadBuffer *); /*proto*/ +static PyObject *__pyx_f_7asyncpg_8protocol_8protocol_init_hstore_codecs(void); /*proto*/ +static PyObject *__pyx_f_7asyncpg_8protocol_8protocol__decode_parameters_desc(PyObject *); /*proto*/ +static PyObject *__pyx_f_7asyncpg_8protocol_8protocol__decode_row_desc(PyObject *); /*proto*/ +#define __Pyx_MODULE_NAME "asyncpg.protocol.protocol" +int __pyx_module_is_main_asyncpg__protocol__protocol = 0; + +/* Implementation of 'asyncpg.protocol.protocol' */ +static PyObject *__pyx_builtin_KeyError; +static PyObject *__pyx_builtin_AttributeError; +static PyObject *__pyx_builtin_object; +static PyObject *__pyx_builtin_RuntimeError; +static PyObject *__pyx_builtin_MemoryError; +static PyObject *__pyx_builtin_chr; +static PyObject *__pyx_builtin_print; +static PyObject *__pyx_builtin_ValueError; +static PyObject *__pyx_builtin_range; +static PyObject *__pyx_builtin_enumerate; +static PyObject *__pyx_builtin_NotImplementedError; +static PyObject *__pyx_builtin_TypeError; +static PyObject *__pyx_builtin_memoryview; +static PyObject *__pyx_builtin_StopIteration; +static const char __pyx_k_c[] = "c"; +static const char __pyx_k_d[] = "d"; +static const char __pyx_k_i[] = "i"; +static const char __pyx_k_r[] = "r"; +static const char __pyx_k_NA[] = "NA"; +static const char __pyx_k__3[] = "_"; +static const char __pyx_k_ns[] = "ns"; +static const char __pyx_k_Box[] = "Box"; +static const char __pyx_k_Dec[] = "_Dec"; +static const char __pyx_k__18[] = ""; +static const char __pyx_k__19[] = "\000"; +static const char __pyx_k__28[] = "{}[]"; +static const char __pyx_k__66[] = "'{}'"; +static const char __pyx_k_abc[] = "abc"; +static const char __pyx_k_add[] = "__add__"; +static const char __pyx_k_alt[] = "alt"; +static const char __pyx_k_any[] = "any"; +static const char __pyx_k_bit[] = "bit"; +static const char __pyx_k_box[] = "box"; +static const char __pyx_k_chr[] = "chr"; +static const char __pyx_k_cid[] = "cid"; +static const char __pyx_k_doc[] = "__doc__"; +static const char __pyx_k_get[] = "get"; +static const char __pyx_k_len[] = "__len__"; +static const char __pyx_k_md5[] = "md5"; +static const char __pyx_k_new[] = "new"; +static const char __pyx_k_oid[] = "oid"; +static const char __pyx_k_rec[] = "rec"; +static const char __pyx_k_tid[] = "tid"; +static const char __pyx_k_utc[] = "utc"; +static const char __pyx_k_win[] = "win"; +static const char __pyx_k_xid[] = "xid"; +static const char __pyx_k_xml[] = "xml"; +static const char __pyx_k_Line[] = "Line"; +static const char __pyx_k_Path[] = "Path"; +static const char __pyx_k_Type[] = "Type"; +static const char __pyx_k_UUID[] = "_UUID"; +static const char __pyx_k_addr[] = "addr"; +static const char __pyx_k_args[] = "args"; +static const char __pyx_k_base[] = "_base"; +static const char __pyx_k_bind[] = "bind"; +static const char __pyx_k_bool[] = "bool"; +static const char __pyx_k_char[] = "char"; +static const char __pyx_k_cidr[] = "cidr"; +static const char __pyx_k_date[] = "date"; +static const char __pyx_k_days[] = "days"; +static const char __pyx_k_desc[] = "desc"; +static const char __pyx_k_done[] = "done"; +static const char __pyx_k_elem[] = "elem"; +static const char __pyx_k_find[] = "find"; +static const char __pyx_k_hour[] = "hour"; +static const char __pyx_k_inet[] = "inet"; +static const char __pyx_k_init[] = "__init__"; +static const char __pyx_k_int2[] = "int2"; +static const char __pyx_k_int4[] = "int4"; +static const char __pyx_k_int8[] = "int8"; +static const char __pyx_k_json[] = "json"; +static const char __pyx_k_kind[] = "kind"; +static const char __pyx_k_line[] = "line"; +static const char __pyx_k_loop[] = "loop"; +static const char __pyx_k_lseg[] = "lseg"; +static const char __pyx_k_main[] = "__main__"; +static const char __pyx_k_name[] = "name"; +static const char __pyx_k_path[] = "path"; +static const char __pyx_k_send[] = "send"; +static const char __pyx_k_sjis[] = "sjis"; +static const char __pyx_k_smgr[] = "smgr"; +static const char __pyx_k_stmt[] = "stmt_{}"; +static const char __pyx_k_tcvn[] = "tcvn"; +static const char __pyx_k_test[] = "__test__"; +static const char __pyx_k_text[] = "text"; +static const char __pyx_k_time[] = "time"; +static const char __pyx_k_user[] = "user"; +static const char __pyx_k_uuid[] = "uuid"; +static const char __pyx_k_void[] = "void"; +static const char __pyx_k_Point[] = "Point"; +static const char __pyx_k_Range[] = "Range"; +static const char __pyx_k_abort[] = "abort"; +static const char __pyx_k_array[] = "array"; +static const char __pyx_k_ascii[] = "ascii"; +static const char __pyx_k_await[] = "__await__"; +static const char __pyx_k_bytea[] = "bytea"; +static const char __pyx_k_bytes[] = "bytes"; +static const char __pyx_k_cause[] = "__cause__"; +static const char __pyx_k_close[] = "close"; +static const char __pyx_k_cp866[] = "cp866"; +static const char __pyx_k_cp874[] = "cp874"; +static const char __pyx_k_cp932[] = "cp932"; +static const char __pyx_k_cp936[] = "cp936"; +static const char __pyx_k_cp949[] = "cp949"; +static const char __pyx_k_cp950[] = "cp950"; +static const char __pyx_k_deque[] = "deque"; +static const char __pyx_k_elems[] = "elems"; +static const char __pyx_k_empty[] = "empty"; +static const char __pyx_k_euccn[] = "euccn"; +static const char __pyx_k_eucjp[] = "eucjp"; +static const char __pyx_k_euckr[] = "euckr"; +static const char __pyx_k_ipnet[] = "_ipnet"; +static const char __pyx_k_items[] = "items"; +static const char __pyx_k_jsonb[] = "jsonb"; +static const char __pyx_k_koi8r[] = "koi8r"; +static const char __pyx_k_koi8u[] = "koi8u"; +static const char __pyx_k_limit[] = "limit"; +static const char __pyx_k_lower[] = "lower"; +static const char __pyx_k_money[] = "money"; +static const char __pyx_k_oid_2[] = "oid[]"; +static const char __pyx_k_point[] = "point"; +static const char __pyx_k_print[] = "print"; +static const char __pyx_k_query[] = "query"; +static const char __pyx_k_range[] = "range"; +static const char __pyx_k_state[] = "state"; +static const char __pyx_k_throw[] = "throw"; +static const char __pyx_k_types[] = "types"; +static const char __pyx_k_upper[] = "upper"; +static const char __pyx_k_utf_8[] = "utf-8"; +static const char __pyx_k_vscii[] = "vscii"; +static const char __pyx_k_write[] = "write"; +static const char __pyx_k_Circle[] = "Circle"; +static const char __pyx_k_Future[] = "Future"; +static const char __pyx_k_UUID_2[] = "UUID"; +static const char __pyx_k_append[] = "append"; +static const char __pyx_k_binary[] = "binary"; +static const char __pyx_k_bpchar[] = "bpchar"; +static const char __pyx_k_cancel[] = "cancel"; +static const char __pyx_k_circle[] = "circle"; +static const char __pyx_k_codecs[] = "codecs"; +static const char __pyx_k_cp1250[] = "cp1250"; +static const char __pyx_k_cp1251[] = "cp1251"; +static const char __pyx_k_cp1252[] = "cp1252"; +static const char __pyx_k_cp1253[] = "cp1253"; +static const char __pyx_k_cp1254[] = "cp1254"; +static const char __pyx_k_cp1255[] = "cp1255"; +static const char __pyx_k_cp1256[] = "cp1256"; +static const char __pyx_k_cp1257[] = "cp1257"; +static const char __pyx_k_cp1258[] = "cp1258"; +static const char __pyx_k_cp1521[] = "cp1521"; +static const char __pyx_k_decode[] = "decode"; +static const char __pyx_k_encode[] = "encode"; +static const char __pyx_k_euc_cn[] = "euc_cn"; +static const char __pyx_k_euc_jp[] = "euc_jp"; +static const char __pyx_k_euc_kr[] = "euc_kr"; +static const char __pyx_k_extend[] = "extend"; +static const char __pyx_k_family[] = "family"; +static const char __pyx_k_float4[] = "float4"; +static const char __pyx_k_float8[] = "float8"; +static const char __pyx_k_format[] = "format"; +static const char __pyx_k_import[] = "__import__"; +static const char __pyx_k_ipaddr[] = "_ipaddr"; +static const char __pyx_k_koi8_r[] = "koi8_r"; +static const char __pyx_k_koi8_u[] = "koi8_u"; +static const char __pyx_k_lookup[] = "lookup"; +static const char __pyx_k_loop_2[] = "_loop"; +static const char __pyx_k_minute[] = "minute"; +static const char __pyx_k_module[] = "__module__"; +static const char __pyx_k_name_2[] = "__name__"; +static const char __pyx_k_notify[] = "_notify"; +static const char __pyx_k_object[] = "object"; +static const char __pyx_k_opaque[] = "opaque"; +static const char __pyx_k_packed[] = "packed"; +static const char __pyx_k_pg_lsn[] = "pg_lsn"; +static const char __pyx_k_record[] = "record"; +static const char __pyx_k_scalar[] = "scalar"; +static const char __pyx_k_second[] = "second"; +static const char __pyx_k_socket[] = "socket"; +static const char __pyx_k_text_2[] = "text[]"; +static const char __pyx_k_timetz[] = "timetz"; +static const char __pyx_k_tzinfo[] = "tzinfo"; +static const char __pyx_k_varbit[] = "varbit"; +static const char __pyx_k_win866[] = "win866"; +static const char __pyx_k_win874[] = "win874"; +static const char __pyx_k_win932[] = "win932"; +static const char __pyx_k_win936[] = "win936"; +static const char __pyx_k_win949[] = "win949"; +static const char __pyx_k_win950[] = "win950"; +static const char __pyx_k_AF_UNIX[] = "AF_UNIX"; +static const char __pyx_k_Decimal[] = "Decimal"; +static const char __pyx_k_MAXYEAR[] = "MAXYEAR"; +static const char __pyx_k_MINYEAR[] = "MINYEAR"; +static const char __pyx_k_Polygon[] = "Polygon"; +static const char __pyx_k_TYPEMAP[] = "TYPEMAP"; +static const char __pyx_k_abstime[] = "abstime"; +static const char __pyx_k_aclitem[] = "aclitem"; +static const char __pyx_k_anyenum[] = "anyenum"; +static const char __pyx_k_apg_exc[] = "apg_exc"; +static const char __pyx_k_asyncio[] = "asyncio"; +static const char __pyx_k_asyncpg[] = "asyncpg"; +static const char __pyx_k_cstring[] = "cstring"; +static const char __pyx_k_decimal[] = "decimal"; +static const char __pyx_k_decoder[] = "decoder"; +static const char __pyx_k_encoder[] = "encoder"; +static const char __pyx_k_execute[] = "execute"; +static const char __pyx_k_genexpr[] = "genexpr"; +static const char __pyx_k_getattr[] = "__getattr__"; +static const char __pyx_k_hashlib[] = "hashlib"; +static const char __pyx_k_inspect[] = "inspect"; +static const char __pyx_k_isempty[] = "isempty"; +static const char __pyx_k_macaddr[] = "macaddr"; +static const char __pyx_k_mapping[] = "mapping"; +static const char __pyx_k_minutes[] = "minutes"; +static const char __pyx_k_numeric[] = "numeric"; +static const char __pyx_k_polygon[] = "polygon"; +static const char __pyx_k_popleft[] = "popleft"; +static const char __pyx_k_prepare[] = "prepare"; +static const char __pyx_k_regoper[] = "regoper"; +static const char __pyx_k_regproc[] = "regproc"; +static const char __pyx_k_regrole[] = "regrole"; +static const char __pyx_k_regtype[] = "regtype"; +static const char __pyx_k_reltime[] = "reltime"; +static const char __pyx_k_replace[] = "replace"; +static const char __pyx_k_seconds[] = "seconds"; +static const char __pyx_k_timeout[] = "timeout"; +static const char __pyx_k_trigger[] = "trigger"; +static const char __pyx_k_tsquery[] = "tsquery"; +static const char __pyx_k_typeoid[] = "typeoid"; +static const char __pyx_k_unicode[] = "unicode"; +static const char __pyx_k_unknown[] = "unknown"; +static const char __pyx_k_utf_8_2[] = "utf_8"; +static const char __pyx_k_varchar[] = "varchar"; +static const char __pyx_k_version[] = "version"; +static const char __pyx_k_win1250[] = "win1250"; +static const char __pyx_k_win1251[] = "win1251"; +static const char __pyx_k_win1252[] = "win1252"; +static const char __pyx_k_win1253[] = "win1253"; +static const char __pyx_k_win1254[] = "win1254"; +static const char __pyx_k_win1255[] = "win1255"; +static const char __pyx_k_win1256[] = "win1256"; +static const char __pyx_k_win1257[] = "win1257"; +static const char __pyx_k_win1258[] = "win1258"; +static const char __pyx_k_KeyError[] = "KeyError"; +static const char __pyx_k_Protocol[] = "Protocol"; +static const char __pyx_k_alias_to[] = "alias_to"; +static const char __pyx_k_anyarray[] = "anyarray"; +static const char __pyx_k_anyrange[] = "anyrange"; +static const char __pyx_k_auth_msg[] = "auth_msg"; +static const char __pyx_k_basetype[] = "basetype"; +static const char __pyx_k_con_args[] = "con_args"; +static const char __pyx_k_conn_key[] = "conn_key"; +static const char __pyx_k_database[] = "database"; +static const char __pyx_k_datetime[] = "datetime"; +static const char __pyx_k_elemtype[] = "elemtype"; +static const char __pyx_k_internal[] = "internal"; +static const char __pyx_k_interval[] = "interval"; +static const char __pyx_k_on_error[] = "_on_error"; +static const char __pyx_k_password[] = "password"; +static const char __pyx_k_protocol[] = "protocol"; +static const char __pyx_k_pyx_capi[] = "__pyx_capi__"; +static const char __pyx_k_qualname[] = "__qualname__"; +static const char __pyx_k_regclass[] = "regclass"; +static const char __pyx_k_supernet[] = "supernet"; +static const char __pyx_k_tcvn5712[] = "tcvn5712"; +static const char __pyx_k_timezone[] = "timezone"; +static const char __pyx_k_tsvector[] = "tsvector"; +static const char __pyx_k_typekind[] = "typekind"; +static const char __pyx_k_typename[] = "typename"; +static const char __pyx_k_Attribute[] = "Attribute"; +static const char __pyx_k_BitString[] = "BitString"; +static const char __pyx_k_Container[] = "Container"; +static const char __pyx_k_TypeError[] = "TypeError"; +static const char __pyx_k_add_types[] = "add_types"; +static const char __pyx_k_apg_types[] = "apg_types"; +static const char __pyx_k_attrnames[] = "attrnames"; +static const char __pyx_k_cache_key[] = "cache_key"; +static const char __pyx_k_cancelled[] = "cancelled"; +static const char __pyx_k_composite[] = "composite"; +static const char __pyx_k_elemdelim[] = "elemdelim"; +static const char __pyx_k_enumerate[] = "enumerate"; +static const char __pyx_k_frombytes[] = "frombytes"; +static const char __pyx_k_gtsvector[] = "gtsvector"; +static const char __pyx_k_hexdigest[] = "hexdigest"; +static const char __pyx_k_ipaddress[] = "ipaddress"; +static const char __pyx_k_is_closed[] = "is_closed"; +static const char __pyx_k_lower_inc[] = "lower_inc"; +static const char __pyx_k_metaclass[] = "__metaclass__"; +static const char __pyx_k_prefixlen[] = "prefixlen"; +static const char __pyx_k_prepare_2[] = "__prepare__"; +static const char __pyx_k_refcursor[] = "refcursor"; +static const char __pyx_k_regconfig[] = "regconfig"; +static const char __pyx_k_shift_jis[] = "shift_jis"; +static const char __pyx_k_sql_ascii[] = "sql_ascii"; +static const char __pyx_k_stmt_name[] = "stmt_name"; +static const char __pyx_k_timedelta[] = "timedelta"; +static const char __pyx_k_timestamp[] = "timestamp"; +static const char __pyx_k_tinterval[] = "tinterval"; +static const char __pyx_k_toordinal[] = "toordinal"; +static const char __pyx_k_upper_inc[] = "upper_inc"; +static const char __pyx_k_utcoffset[] = "utcoffset"; +static const char __pyx_k_ValueError[] = "ValueError"; +static const char __pyx_k_anyelement[] = "anyelement"; +static const char __pyx_k_astimezone[] = "astimezone"; +static const char __pyx_k_call_later[] = "call_later"; +static const char __pyx_k_exceptions[] = "exceptions"; +static const char __pyx_k_has_bin_io[] = "has_bin_io"; +static const char __pyx_k_ip_address[] = "ip_address"; +static const char __pyx_k_ip_network[] = "ip_network"; +static const char __pyx_k_memoryview[] = "memoryview"; +static const char __pyx_k_new_prefix[] = "new_prefix"; +static const char __pyx_k_on_timeout[] = "_on_timeout"; +static const char __pyx_k_pg_catalog[] = "pg_catalog"; +static const char __pyx_k_pyx_vtable[] = "__pyx_vtable__"; +static const char __pyx_k_set_result[] = "set_result"; +static const char __pyx_k_setsockopt[] = "setsockopt"; +static const char __pyx_k_startswith[] = "startswith"; +static const char __pyx_k_typeschema[] = "typeschema"; +static const char __pyx_k_windows866[] = "windows866"; +static const char __pyx_k_windows874[] = "windows874"; +static const char __pyx_k_windows932[] = "windows932"; +static const char __pyx_k_windows936[] = "windows936"; +static const char __pyx_k_windows949[] = "windows949"; +static const char __pyx_k_windows950[] = "windows950"; +static const char __pyx_k_ARRAY_TYPES[] = "ARRAY_TYPES"; +static const char __pyx_k_BufferError[] = "BufferError"; +static const char __pyx_k_IPPROTO_TCP[] = "IPPROTO_TCP"; +static const char __pyx_k_LineSegment[] = "LineSegment"; +static const char __pyx_k_MemoryError[] = "MemoryError"; +static const char __pyx_k_OrderedDict[] = "OrderedDict"; +static const char __pyx_k_TCP_NODELAY[] = "TCP_NODELAY"; +static const char __pyx_k_anynonarray[] = "anynonarray"; +static const char __pyx_k_attrtypoids[] = "attrtypoids"; +static const char __pyx_k_collections[] = "collections"; +static const char __pyx_k_fdw_handler[] = "fdw_handler"; +static const char __pyx_k_fromordinal[] = "fromordinal"; +static const char __pyx_k_hashlib_md5[] = "hashlib_md5"; +static const char __pyx_k_microsecond[] = "microsecond"; +static const char __pyx_k_portal_name[] = "portal_name"; +static const char __pyx_k_regoperator[] = "regoperator"; +static const char __pyx_k_timestamptz[] = "timestamptz"; +static const char __pyx_k_tsm_handler[] = "tsm_handler"; +static const char __pyx_k_windows1250[] = "windows1250"; +static const char __pyx_k_windows1251[] = "windows1251"; +static const char __pyx_k_windows1252[] = "windows1252"; +static const char __pyx_k_windows1253[] = "windows1253"; +static const char __pyx_k_windows1254[] = "windows1254"; +static const char __pyx_k_windows1255[] = "windows1255"; +static const char __pyx_k_windows1256[] = "windows1256"; +static const char __pyx_k_windows1257[] = "windows1257"; +static const char __pyx_k_windows1258[] = "windows1258"; +static const char __pyx_k_ContainerABC[] = "ContainerABC"; +static const char __pyx_k_RuntimeError[] = "RuntimeError"; +static const char __pyx_k_TimeoutError[] = "TimeoutError"; +static const char __pyx_k_apg_exc_base[] = "apg_exc_base"; +static const char __pyx_k_bind_execute[] = "bind_execute"; +static const char __pyx_k_euc_jis_2004[] = "euc_jis_2004"; +static const char __pyx_k_microseconds[] = "microseconds"; +static const char __pyx_k_pg_node_tree[] = "pg_node_tree"; +static const char __pyx_k_regnamespace[] = "regnamespace"; +static const char __pyx_k_regprocedure[] = "regprocedure"; +static const char __pyx_k_return_extra[] = "return_extra"; +static const char __pyx_k_StopIteration[] = "StopIteration"; +static const char __pyx_k_asyncio_tasks[] = "asyncio.tasks"; +static const char __pyx_k_asyncpg_types[] = "asyncpg.types"; +static const char __pyx_k_connected_fut[] = "connected_fut"; +static const char __pyx_k_create_future[] = "create_future"; +static const char __pyx_k_create_record[] = "_create_record"; +static const char __pyx_k_event_trigger[] = "event_trigger"; +static const char __pyx_k_infinity_date[] = "infinity_date"; +static const char __pyx_k_not_connected[] = "not connected"; +static const char __pyx_k_pg_epoch_date[] = "pg_epoch_date"; +static const char __pyx_k_range_subtype[] = "range_subtype"; +static const char __pyx_k_regdictionary[] = "regdictionary"; +static const char __pyx_k_set_exception[] = "set_exception"; +static const char __pyx_k_txid_snapshot[] = "txid_snapshot"; +static const char __pyx_k_AttributeError[] = "AttributeError"; +static const char __pyx_k_InterfaceError[] = "InterfaceError"; +static const char __pyx_k_get_extra_info[] = "get_extra_info"; +static const char __pyx_k_pg_ddl_command[] = "pg_ddl_command"; +static const char __pyx_k_request_cancel[] = "_request_cancel"; +static const char __pyx_k_shift_jis_2004[] = "shift_jis_2004"; +static const char __pyx_k_PostgresMessage[] = "PostgresMessage"; +static const char __pyx_k_buffer_overread[] = "buffer overread"; +static const char __pyx_k_client_encoding[] = "client_encoding"; +static const char __pyx_k_close_statement[] = "close_statement"; +static const char __pyx_k_collections_abc[] = "collections.abc"; +static const char __pyx_k_command_timeout[] = "_command_timeout"; +static const char __pyx_k_elem_has_bin_io[] = "elem_has_bin_io"; +static const char __pyx_k_network_address[] = "network_address"; +static const char __pyx_k_string_too_long[] = "string too long"; +static const char __pyx_k_AUTH_METHOD_NAME[] = "AUTH_METHOD_NAME"; +static const char __pyx_k_add_python_codec[] = "add_python_codec"; +static const char __pyx_k_language_handler[] = "language_handler"; +static const char __pyx_k_BaseProtocol_bind[] = "BaseProtocol.bind"; +static const char __pyx_k_add_done_callback[] = "add_done_callback"; +static const char __pyx_k_already_connected[] = "already connected"; +static const char __pyx_k_bind_execute_many[] = "bind_execute_many"; +static const char __pyx_k_date_from_ordinal[] = "date_from_ordinal"; +static const char __pyx_k_infinity_datetime[] = "infinity_datetime"; +static const char __pyx_k_pg_contrib_hstore[] = "pg_contrib.hstore"; +static const char __pyx_k_pg_epoch_datetime[] = "pg_epoch_datetime"; +static const char __pyx_k_BaseProtocol_close[] = "BaseProtocol.close"; +static const char __pyx_k_BaseProtocol_query[] = "BaseProtocol.query"; +static const char __pyx_k_asyncio_coroutines[] = "asyncio.coroutines"; +static const char __pyx_k_asyncpg_exceptions[] = "asyncpg.exceptions"; +static const char __pyx_k_bit_value_too_long[] = "bit value too long"; +static const char __pyx_k_empty_first_buffer[] = "empty first buffer"; +static const char __pyx_k_no_decoder_for_OID[] = "no decoder for OID {}"; +static const char __pyx_k_no_encoder_for_OID[] = "no encoder for OID {}"; +static const char __pyx_k_NotImplementedError[] = "NotImplementedError"; +static const char __pyx_k_invalid_rows_codecs[] = "invalid rows_codecs"; +static const char __pyx_k_on_waiter_completed[] = "_on_waiter_completed"; +static const char __pyx_k_path_value_too_long[] = "path value too long"; +static const char __pyx_k_BaseProtocol_execute[] = "BaseProtocol.execute"; +static const char __pyx_k_BaseProtocol_prepare[] = "BaseProtocol.prepare"; +static const char __pyx_k_unknown_alias_target[] = "unknown alias target: {}"; +static const char __pyx_k_invalid_array_element[] = "invalid array element: {}"; +static const char __pyx_k_invalid_bits_in_value[] = "invalid bits in \"{}\" value"; +static const char __pyx_k_no_message_to_consume[] = "no message to consume"; +static const char __pyx_k_no_message_to_discard[] = "no message to discard"; +static const char __pyx_k_non_homogeneous_array[] = "non-homogeneous array"; +static const char __pyx_k_pg_epoch_datetime_utc[] = "pg_epoch_datetime_utc"; +static const char __pyx_k_unexpected_codec_type[] = "unexpected codec type: {}"; +static const char __pyx_k_cancel_current_command[] = "_cancel_current_command"; +static const char __pyx_k_create_future_fallback[] = "_create_future_fallback"; +static const char __pyx_k_negative_infinity_date[] = "negative_infinity_date"; +static const char __pyx_k_polygon_value_too_long[] = "polygon value too long"; +static const char __pyx_k_set_builtin_type_codec[] = "set_builtin_type_codec"; +static const char __pyx_k_Codec_oid_elem_oid_core[] = ""; +static const char __pyx_k_invalid_length_in_value[] = "invalid length in \"{}\" value"; +static const char __pyx_k_no_decoder_for_type_OID[] = "no decoder for type OID {}"; +static const char __pyx_k_unexpected_JSONB_format[] = "unexpected JSONB format: {}"; +static const char __pyx_k_on_result_waiter_is_None[] = "_on_result: waiter is None"; +static const char __pyx_k_on_result_waiter_is_done[] = "_on_result: waiter is done"; +static const char __pyx_k_unexpected_end_of_string[] = "unexpected end of string"; +static const char __pyx_k_BaseProtocol_bind_execute[] = "BaseProtocol.bind_execute"; +static const char __pyx_k_asyncpg_protocol_protocol[] = "asyncpg.protocol.protocol"; +static const char __pyx_k_hstore_value_is_too_large[] = "hstore value is too large"; +static const char __pyx_k_malformed_array_literal_r[] = "malformed array literal {!r}: {}"; +static const char __pyx_k_read_cstr_buffer_overread[] = "read_cstr: buffer overread"; +static const char __pyx_k_negative_infinity_datetime[] = "negative_infinity_datetime"; +static const char __pyx_k_ConnectionDoesNotExistError[] = "ConnectionDoesNotExistError"; +static const char __pyx_k_BaseProtocol_close_statement[] = "BaseProtocol.close_statement"; +static const char __pyx_k_decode_row_statement_is_None[] = "_decode_row: statement is None"; +static const char __pyx_k_missing_array_dimension_value[] = "missing array dimension value"; +static const char __pyx_k_no_codec_for_domain_base_type[] = "no codec for domain base type {}"; +static const char __pyx_k_not_enough_data_to_read_bytes[] = "not enough data to read {} bytes"; +static const char __pyx_k_BaseProtocol_bind_execute_many[] = "BaseProtocol.bind_execute_many"; +static const char __pyx_k_a_boolean_is_required_got_type[] = "a boolean is required (got type {})"; +static const char __pyx_k_cannot_override_codec_for_type[] = "cannot override codec for type {}"; +static const char __pyx_k_invalid_array_element_at_index[] = "invalid array element at index {}: {}"; +static const char __pyx_k_missing_after_array_dimensions[] = "missing ']' after array dimensions"; +static const char __pyx_k_a_non_trivial_iterable_expected[] = "a non-trivial iterable expected (got type {!r})"; +static const char __pyx_k_cannot_close_prepared_statement[] = "cannot close prepared statement; refs == {} != 0"; +static const char __pyx_k_cannot_switch_to_state_protocol[] = "cannot switch to state {}; protocol is in the \"failed\" state"; +static const char __pyx_k_discarding_message_r_unread_dat[] = "!!! discarding message {!r} unread data: {!r}"; +static const char __pyx_k_end_message_buffer_is_too_small[] = "end_message: buffer is too small"; +static const char __pyx_k_feed_data_bytes_object_expected[] = "feed_data: bytes object expected"; +static const char __pyx_k_got_result_for_unknown_protocol[] = "got result for unknown protocol state {}"; +static const char __pyx_k_home_travis_build_MagicStack_as[] = "/home/travis/build/MagicStack/asyncpg/asyncpg/protocol/protocol.pyx"; +static const char __pyx_k_integer_too_large_to_be_encoded[] = "integer too large to be encoded as INT2: {!r}"; +static const char __pyx_k_invalid_address_family_in_value[] = "invalid address family in \"{}\" value"; +static const char __pyx_k_list_or_tuple_expected_got_type[] = "list or tuple expected (got type {})"; +static const char __pyx_k_no_codec_for_array_element_type[] = "no codec for array element type {}"; +static const char __pyx_k_no_codec_for_range_element_type[] = "no codec for range element type {}"; +static const char __pyx_k_on_result__prepare_statement_is[] = "_on_result__prepare: statement is None"; +static const char __pyx_k_parse_data_msgs_first_message_i[] = "_parse_data_msgs: first message is not \"D\""; +static const char __pyx_k_parse_data_msgs_result_is_not_a[] = "_parse_data_msgs: result is not a list, but {!r}"; +static const char __pyx_k_protocol_is_already_in_the_idle[] = "protocol is already in the \"idle\" state"; +static const char __pyx_k_protocol_is_in_an_unknown_state[] = "protocol is in an unknown state {}"; +static const char __pyx_k_the_buffer_is_in_read_only_mode[] = "the buffer is in read-only mode"; +static const char __pyx_k_txid_snapshot_value_is_too_long[] = "txid_snapshot value is too long"; +static const char __pyx_k_type_record_missing_field_types[] = "type record missing field types for composite {}"; +static const char __pyx_k_Deallocating_buffer_with_attache[] = "Deallocating buffer with attached memoryviews"; +static const char __pyx_k_bind_execute_many_locals_genexpr[] = "bind_execute_many..genexpr"; +static const char __pyx_k_cannot_perform_operation_another[] = "cannot perform operation: another operation is cancelling"; +static const char __pyx_k_cannot_perform_operation_connect[] = "cannot perform operation: connection is closed"; +static const char __pyx_k_cannot_register_core_codec_for_O[] = "cannot register core codec for OID {}: it is greater than MAXSUPPORTEDOID ({})"; +static const char __pyx_k_cannot_start_message_for_a_non_e[] = "cannot start_message for a non-empty buffer"; +static const char __pyx_k_cannot_switch_to_idle_state_prot[] = "cannot switch to \"idle\" state; protocol is in the \"failed\" state"; +static const char __pyx_k_cannot_switch_to_state_another_o[] = "cannot switch to state {}; another operation ({}) is in progress"; +static const char __pyx_k_connection_was_closed_in_the_mid[] = "connection was closed in the middle of operation"; +static const char __pyx_k_debug_first_buffer_of_ReadBuffer[] = "debug: first buffer of ReadBuffer is empty"; +static const char __pyx_k_debug_second_buffer_of_ReadBuffe[] = "debug: second buffer of ReadBuffer is empty"; +static const char __pyx_k_end_message_can_only_be_called_w[] = "end_message can only be called with start_message"; +static const char __pyx_k_end_message_message_is_too_large[] = "end_message: message is too large"; +static const char __pyx_k_expected_0_1_or_2_elements_in_ra[] = "expected 0, 1 or 2 elements in range (got {})"; +static const char __pyx_k_failed_to_read_one_byte_on_a_non[] = "failed to read one byte on a non-empty buffer"; +static const char __pyx_k_float_value_too_large_to_be_enco[] = "float value too large to be encoded as FLOAT4"; +static const char __pyx_k_inconsistent_sub_array_dimension[] = "inconsistent sub-array dimensions at position {}"; +static const char __pyx_k_insufficient_data_in_buffer_requ[] = "insufficient data in buffer: requested {}, remaining {}"; +static const char __pyx_k_invalid_number_of_elements_in_tx[] = "invalid number of elements in txid_snapshot tuple, expecting 4"; +static const char __pyx_k_invalid_state_after_cancellation[] = "invalid state after cancellation"; +static const char __pyx_k_list_tuple_or_Range_object_expec[] = "list, tuple or Range object expected (got type {})"; +static const char __pyx_k_missing_after_array_dimensions_2[] = "missing '=' after array dimensions"; +static const char __pyx_k_no_codec_for_composite_attribute[] = "no codec for composite attribute type {}"; +static const char __pyx_k_no_decoder_for_composite_type_el[] = "no decoder for composite type element in position {} of type OID {}"; +static const char __pyx_k_not_enough_data_to_read_one_byte[] = "not enough data to read one byte"; +static const char __pyx_k_null_value_not_allowed_in_hstore[] = "null value not allowed in hstore key"; +static const char __pyx_k_number_of_arguments_does_not_mat[] = "number of arguments ({}) does not match number of parameters ({})"; +static const char __pyx_k_number_of_array_dimensions_excee[] = "number of array dimensions ({}) exceed the maximum expected ({})"; +static const char __pyx_k_number_of_columns_in_result_is_d[] = "number of columns in result ({}) is different from what was described ({})"; +static const char __pyx_k_read_cstr_only_works_when_the_me[] = "read_cstr only works when the message guaranteed to be in the buffer"; +static const char __pyx_k_specified_array_dimensions_do_no[] = "specified array dimensions do not match array content"; +static const char __pyx_k_too_many_elements_in_array_value[] = "too many elements in array value"; +static const char __pyx_k_too_many_elements_in_composite_t[] = "too many elements in composite type record"; +static const char __pyx_k_type_record_missing_base_type_fo[] = "type record missing base type for domain {}"; +static const char __pyx_k_unexpected_character_r_at_positi[] = "unexpected character {!r} at position {}"; +static const char __pyx_k_unexpected_data_type_of_composit[] = "unexpected data type of composite type attribute {}: {!r}, expected {!r}"; +static const char __pyx_k_unexpected_trailing_bytes_in_buf[] = "unexpected trailing {} bytes in buffer"; +static const char __pyx_k_unhandled_standard_data_type_r_O[] = "unhandled standard data type {!r} (OID {})"; +static const char __pyx_k_unknown_error_in_protocol_implem[] = "unknown error in protocol implementation"; +static const char __pyx_k_unsupported_authentication_metho[] = "unsupported authentication method requested by the server: {!r}"; +static const char __pyx_k_cannot_perform_operation_another_2[] = "cannot perform operation: another operation is in progress"; +static const char __pyx_k_type_record_missing_base_type_fo_2[] = "type record missing base type for range {}"; +static const char __pyx_k_unsupported_authentication_metho_2[] = "unsupported authentication method requested by the server: {}"; +static PyObject *__pyx_n_s_AF_UNIX; +static PyObject *__pyx_n_u_AF_UNIX; +static PyObject *__pyx_n_s_ARRAY_TYPES; +static PyObject *__pyx_n_s_AUTH_METHOD_NAME; +static PyObject *__pyx_n_s_Attribute; +static PyObject *__pyx_n_s_AttributeError; +static PyObject *__pyx_n_s_BaseProtocol_bind; +static PyObject *__pyx_n_s_BaseProtocol_bind_execute; +static PyObject *__pyx_n_s_BaseProtocol_bind_execute_many; +static PyObject *__pyx_n_s_BaseProtocol_close; +static PyObject *__pyx_n_s_BaseProtocol_close_statement; +static PyObject *__pyx_n_s_BaseProtocol_execute; +static PyObject *__pyx_n_s_BaseProtocol_prepare; +static PyObject *__pyx_n_s_BaseProtocol_query; +static PyObject *__pyx_n_s_BitString; +static PyObject *__pyx_n_s_Box; +static PyObject *__pyx_n_s_BufferError; +static PyObject *__pyx_n_s_Circle; +static PyObject *__pyx_kp_u_Codec_oid_elem_oid_core; +static PyObject *__pyx_n_s_ConnectionDoesNotExistError; +static PyObject *__pyx_n_s_Container; +static PyObject *__pyx_n_s_ContainerABC; +static PyObject *__pyx_kp_u_Deallocating_buffer_with_attache; +static PyObject *__pyx_n_s_Dec; +static PyObject *__pyx_n_s_Decimal; +static PyObject *__pyx_n_s_Future; +static PyObject *__pyx_n_s_IPPROTO_TCP; +static PyObject *__pyx_n_s_InterfaceError; +static PyObject *__pyx_n_s_KeyError; +static PyObject *__pyx_n_s_Line; +static PyObject *__pyx_n_s_LineSegment; +static PyObject *__pyx_n_s_MAXYEAR; +static PyObject *__pyx_n_s_MINYEAR; +static PyObject *__pyx_n_s_MemoryError; +static PyObject *__pyx_n_u_NA; +static PyObject *__pyx_n_s_NotImplementedError; +static PyObject *__pyx_n_s_OrderedDict; +static PyObject *__pyx_n_s_Path; +static PyObject *__pyx_n_s_Point; +static PyObject *__pyx_n_s_Polygon; +static PyObject *__pyx_n_s_PostgresMessage; +static PyObject *__pyx_n_s_Protocol; +static PyObject *__pyx_n_s_Range; +static PyObject *__pyx_n_s_RuntimeError; +static PyObject *__pyx_n_s_StopIteration; +static PyObject *__pyx_n_s_TCP_NODELAY; +static PyObject *__pyx_n_s_TYPEMAP; +static PyObject *__pyx_n_s_TimeoutError; +static PyObject *__pyx_n_s_Type; +static PyObject *__pyx_n_s_TypeError; +static PyObject *__pyx_n_s_UUID; +static PyObject *__pyx_n_s_UUID_2; +static PyObject *__pyx_n_s_ValueError; +static PyObject *__pyx_kp_b__18; +static PyObject *__pyx_kp_u__18; +static PyObject *__pyx_kp_b__19; +static PyObject *__pyx_kp_u__28; +static PyObject *__pyx_n_u__3; +static PyObject *__pyx_kp_u__66; +static PyObject *__pyx_kp_u_a_boolean_is_required_got_type; +static PyObject *__pyx_kp_u_a_non_trivial_iterable_expected; +static PyObject *__pyx_n_u_abc; +static PyObject *__pyx_n_s_abort; +static PyObject *__pyx_n_u_abstime; +static PyObject *__pyx_n_u_aclitem; +static PyObject *__pyx_n_s_add; +static PyObject *__pyx_n_s_add_done_callback; +static PyObject *__pyx_n_s_add_python_codec; +static PyObject *__pyx_n_s_add_types; +static PyObject *__pyx_n_s_addr; +static PyObject *__pyx_n_s_alias_to; +static PyObject *__pyx_kp_u_already_connected; +static PyObject *__pyx_n_u_alt; +static PyObject *__pyx_n_u_any; +static PyObject *__pyx_n_u_anyarray; +static PyObject *__pyx_n_u_anyelement; +static PyObject *__pyx_n_u_anyenum; +static PyObject *__pyx_n_u_anynonarray; +static PyObject *__pyx_n_u_anyrange; +static PyObject *__pyx_n_s_apg_exc; +static PyObject *__pyx_n_s_apg_exc_base; +static PyObject *__pyx_n_s_apg_types; +static PyObject *__pyx_n_s_append; +static PyObject *__pyx_n_s_args; +static PyObject *__pyx_n_u_array; +static PyObject *__pyx_n_u_ascii; +static PyObject *__pyx_n_s_astimezone; +static PyObject *__pyx_n_s_asyncio; +static PyObject *__pyx_n_s_asyncio_coroutines; +static PyObject *__pyx_n_s_asyncio_tasks; +static PyObject *__pyx_n_s_asyncpg; +static PyObject *__pyx_n_s_asyncpg_exceptions; +static PyObject *__pyx_n_s_asyncpg_protocol_protocol; +static PyObject *__pyx_n_s_asyncpg_types; +static PyObject *__pyx_n_u_attrnames; +static PyObject *__pyx_n_u_attrtypoids; +static PyObject *__pyx_n_s_auth_msg; +static PyObject *__pyx_n_s_await; +static PyObject *__pyx_n_s_base; +static PyObject *__pyx_n_u_basetype; +static PyObject *__pyx_n_s_binary; +static PyObject *__pyx_n_s_bind; +static PyObject *__pyx_n_s_bind_execute; +static PyObject *__pyx_n_s_bind_execute_many; +static PyObject *__pyx_n_s_bind_execute_many_locals_genexpr; +static PyObject *__pyx_n_u_bit; +static PyObject *__pyx_kp_u_bit_value_too_long; +static PyObject *__pyx_n_u_bool; +static PyObject *__pyx_n_u_box; +static PyObject *__pyx_n_u_bpchar; +static PyObject *__pyx_kp_u_buffer_overread; +static PyObject *__pyx_n_u_bytea; +static PyObject *__pyx_n_s_bytes; +static PyObject *__pyx_n_b_c; +static PyObject *__pyx_n_s_cache_key; +static PyObject *__pyx_n_s_call_later; +static PyObject *__pyx_n_s_cancel; +static PyObject *__pyx_n_s_cancel_current_command; +static PyObject *__pyx_n_s_cancelled; +static PyObject *__pyx_kp_u_cannot_close_prepared_statement; +static PyObject *__pyx_kp_u_cannot_override_codec_for_type; +static PyObject *__pyx_kp_u_cannot_perform_operation_another; +static PyObject *__pyx_kp_u_cannot_perform_operation_another_2; +static PyObject *__pyx_kp_u_cannot_perform_operation_connect; +static PyObject *__pyx_kp_u_cannot_register_core_codec_for_O; +static PyObject *__pyx_kp_u_cannot_start_message_for_a_non_e; +static PyObject *__pyx_kp_u_cannot_switch_to_idle_state_prot; +static PyObject *__pyx_kp_u_cannot_switch_to_state_another_o; +static PyObject *__pyx_kp_u_cannot_switch_to_state_protocol; +static PyObject *__pyx_n_s_cause; +static PyObject *__pyx_n_u_char; +static PyObject *__pyx_n_s_chr; +static PyObject *__pyx_n_u_cid; +static PyObject *__pyx_n_u_cidr; +static PyObject *__pyx_n_u_circle; +static PyObject *__pyx_n_b_client_encoding; +static PyObject *__pyx_n_u_client_encoding; +static PyObject *__pyx_n_s_close; +static PyObject *__pyx_n_s_close_statement; +static PyObject *__pyx_n_s_codecs; +static PyObject *__pyx_n_s_collections; +static PyObject *__pyx_n_s_collections_abc; +static PyObject *__pyx_n_s_command_timeout; +static PyObject *__pyx_n_u_composite; +static PyObject *__pyx_n_s_con_args; +static PyObject *__pyx_n_s_conn_key; +static PyObject *__pyx_n_s_connected_fut; +static PyObject *__pyx_kp_u_connection_was_closed_in_the_mid; +static PyObject *__pyx_n_u_cp1250; +static PyObject *__pyx_n_u_cp1251; +static PyObject *__pyx_n_u_cp1252; +static PyObject *__pyx_n_u_cp1253; +static PyObject *__pyx_n_u_cp1254; +static PyObject *__pyx_n_u_cp1255; +static PyObject *__pyx_n_u_cp1256; +static PyObject *__pyx_n_u_cp1257; +static PyObject *__pyx_n_u_cp1258; +static PyObject *__pyx_n_u_cp1521; +static PyObject *__pyx_n_u_cp866; +static PyObject *__pyx_n_u_cp874; +static PyObject *__pyx_n_u_cp932; +static PyObject *__pyx_n_u_cp936; +static PyObject *__pyx_n_u_cp949; +static PyObject *__pyx_n_u_cp950; +static PyObject *__pyx_n_s_create_future; +static PyObject *__pyx_n_s_create_future_fallback; +static PyObject *__pyx_n_s_create_record; +static PyObject *__pyx_n_u_cstring; +static PyObject *__pyx_n_b_d; +static PyObject *__pyx_n_u_database; +static PyObject *__pyx_n_s_date; +static PyObject *__pyx_n_u_date; +static PyObject *__pyx_n_s_date_from_ordinal; +static PyObject *__pyx_n_s_datetime; +static PyObject *__pyx_n_s_days; +static PyObject *__pyx_kp_u_debug_first_buffer_of_ReadBuffer; +static PyObject *__pyx_kp_u_debug_second_buffer_of_ReadBuffe; +static PyObject *__pyx_n_s_decimal; +static PyObject *__pyx_n_s_decode; +static PyObject *__pyx_kp_u_decode_row_statement_is_None; +static PyObject *__pyx_n_s_decoder; +static PyObject *__pyx_n_s_deque; +static PyObject *__pyx_n_s_desc; +static PyObject *__pyx_kp_u_discarding_message_r_unread_dat; +static PyObject *__pyx_n_s_doc; +static PyObject *__pyx_n_s_done; +static PyObject *__pyx_n_s_elem; +static PyObject *__pyx_n_u_elem_has_bin_io; +static PyObject *__pyx_n_u_elemdelim; +static PyObject *__pyx_n_s_elems; +static PyObject *__pyx_n_u_elemtype; +static PyObject *__pyx_n_s_empty; +static PyObject *__pyx_kp_u_empty_first_buffer; +static PyObject *__pyx_n_s_encode; +static PyObject *__pyx_n_s_encoder; +static PyObject *__pyx_kp_u_end_message_buffer_is_too_small; +static PyObject *__pyx_kp_u_end_message_can_only_be_called_w; +static PyObject *__pyx_kp_u_end_message_message_is_too_large; +static PyObject *__pyx_n_s_enumerate; +static PyObject *__pyx_n_u_euc_cn; +static PyObject *__pyx_n_u_euc_jis_2004; +static PyObject *__pyx_n_u_euc_jp; +static PyObject *__pyx_n_u_euc_kr; +static PyObject *__pyx_n_u_euccn; +static PyObject *__pyx_n_u_eucjp; +static PyObject *__pyx_n_u_euckr; +static PyObject *__pyx_n_u_event_trigger; +static PyObject *__pyx_n_s_exceptions; +static PyObject *__pyx_n_s_execute; +static PyObject *__pyx_kp_u_expected_0_1_or_2_elements_in_ra; +static PyObject *__pyx_n_s_extend; +static PyObject *__pyx_kp_u_failed_to_read_one_byte_on_a_non; +static PyObject *__pyx_n_s_family; +static PyObject *__pyx_n_u_fdw_handler; +static PyObject *__pyx_kp_u_feed_data_bytes_object_expected; +static PyObject *__pyx_n_s_find; +static PyObject *__pyx_n_u_float4; +static PyObject *__pyx_n_u_float8; +static PyObject *__pyx_kp_u_float_value_too_large_to_be_enco; +static PyObject *__pyx_n_s_format; +static PyObject *__pyx_n_s_frombytes; +static PyObject *__pyx_n_s_fromordinal; +static PyObject *__pyx_n_s_genexpr; +static PyObject *__pyx_n_s_get; +static PyObject *__pyx_n_s_get_extra_info; +static PyObject *__pyx_n_s_getattr; +static PyObject *__pyx_kp_u_got_result_for_unknown_protocol; +static PyObject *__pyx_n_u_gtsvector; +static PyObject *__pyx_n_u_has_bin_io; +static PyObject *__pyx_n_s_hashlib; +static PyObject *__pyx_n_s_hashlib_md5; +static PyObject *__pyx_n_s_hexdigest; +static PyObject *__pyx_kp_s_home_travis_build_MagicStack_as; +static PyObject *__pyx_n_s_hour; +static PyObject *__pyx_kp_u_hstore_value_is_too_large; +static PyObject *__pyx_n_s_i; +static PyObject *__pyx_n_s_import; +static PyObject *__pyx_kp_u_inconsistent_sub_array_dimension; +static PyObject *__pyx_n_u_inet; +static PyObject *__pyx_n_s_infinity_date; +static PyObject *__pyx_n_s_infinity_datetime; +static PyObject *__pyx_n_s_init; +static PyObject *__pyx_n_s_inspect; +static PyObject *__pyx_kp_u_insufficient_data_in_buffer_requ; +static PyObject *__pyx_n_u_int2; +static PyObject *__pyx_n_u_int4; +static PyObject *__pyx_n_u_int8; +static PyObject *__pyx_kp_u_integer_too_large_to_be_encoded; +static PyObject *__pyx_n_u_internal; +static PyObject *__pyx_n_u_interval; +static PyObject *__pyx_kp_u_invalid_address_family_in_value; +static PyObject *__pyx_kp_u_invalid_array_element; +static PyObject *__pyx_kp_u_invalid_array_element_at_index; +static PyObject *__pyx_kp_u_invalid_bits_in_value; +static PyObject *__pyx_kp_u_invalid_length_in_value; +static PyObject *__pyx_kp_u_invalid_number_of_elements_in_tx; +static PyObject *__pyx_kp_u_invalid_rows_codecs; +static PyObject *__pyx_kp_u_invalid_state_after_cancellation; +static PyObject *__pyx_n_s_ip_address; +static PyObject *__pyx_n_s_ip_network; +static PyObject *__pyx_n_s_ipaddr; +static PyObject *__pyx_n_s_ipaddress; +static PyObject *__pyx_n_s_ipnet; +static PyObject *__pyx_n_s_is_closed; +static PyObject *__pyx_n_s_isempty; +static PyObject *__pyx_n_s_items; +static PyObject *__pyx_n_u_items; +static PyObject *__pyx_n_u_json; +static PyObject *__pyx_n_u_jsonb; +static PyObject *__pyx_n_u_kind; +static PyObject *__pyx_n_u_koi8_r; +static PyObject *__pyx_n_u_koi8_u; +static PyObject *__pyx_n_u_koi8r; +static PyObject *__pyx_n_u_koi8u; +static PyObject *__pyx_n_u_language_handler; +static PyObject *__pyx_n_s_len; +static PyObject *__pyx_n_s_limit; +static PyObject *__pyx_n_u_line; +static PyObject *__pyx_kp_u_list_or_tuple_expected_got_type; +static PyObject *__pyx_kp_u_list_tuple_or_Range_object_expec; +static PyObject *__pyx_n_s_lookup; +static PyObject *__pyx_n_s_loop; +static PyObject *__pyx_n_s_loop_2; +static PyObject *__pyx_n_s_lower; +static PyObject *__pyx_n_s_lower_inc; +static PyObject *__pyx_n_u_lseg; +static PyObject *__pyx_n_u_macaddr; +static PyObject *__pyx_n_s_main; +static PyObject *__pyx_kp_u_malformed_array_literal_r; +static PyObject *__pyx_n_s_mapping; +static PyObject *__pyx_n_b_md5; +static PyObject *__pyx_n_s_md5; +static PyObject *__pyx_n_s_memoryview; +static PyObject *__pyx_n_s_metaclass; +static PyObject *__pyx_n_s_microsecond; +static PyObject *__pyx_n_s_microseconds; +static PyObject *__pyx_n_s_minute; +static PyObject *__pyx_n_s_minutes; +static PyObject *__pyx_kp_u_missing_after_array_dimensions; +static PyObject *__pyx_kp_u_missing_after_array_dimensions_2; +static PyObject *__pyx_kp_u_missing_array_dimension_value; +static PyObject *__pyx_n_s_module; +static PyObject *__pyx_n_u_money; +static PyObject *__pyx_n_s_name; +static PyObject *__pyx_n_u_name; +static PyObject *__pyx_n_s_name_2; +static PyObject *__pyx_n_s_negative_infinity_date; +static PyObject *__pyx_n_s_negative_infinity_datetime; +static PyObject *__pyx_n_s_network_address; +static PyObject *__pyx_n_s_new; +static PyObject *__pyx_n_s_new_prefix; +static PyObject *__pyx_kp_u_no_codec_for_array_element_type; +static PyObject *__pyx_kp_u_no_codec_for_composite_attribute; +static PyObject *__pyx_kp_u_no_codec_for_domain_base_type; +static PyObject *__pyx_kp_u_no_codec_for_range_element_type; +static PyObject *__pyx_kp_u_no_decoder_for_OID; +static PyObject *__pyx_kp_u_no_decoder_for_composite_type_el; +static PyObject *__pyx_kp_u_no_decoder_for_type_OID; +static PyObject *__pyx_kp_u_no_encoder_for_OID; +static PyObject *__pyx_kp_u_no_message_to_consume; +static PyObject *__pyx_kp_u_no_message_to_discard; +static PyObject *__pyx_kp_u_non_homogeneous_array; +static PyObject *__pyx_kp_u_not_connected; +static PyObject *__pyx_kp_u_not_enough_data_to_read_bytes; +static PyObject *__pyx_kp_u_not_enough_data_to_read_one_byte; +static PyObject *__pyx_n_s_notify; +static PyObject *__pyx_n_u_ns; +static PyObject *__pyx_kp_u_null_value_not_allowed_in_hstore; +static PyObject *__pyx_kp_u_number_of_arguments_does_not_mat; +static PyObject *__pyx_kp_u_number_of_array_dimensions_excee; +static PyObject *__pyx_kp_u_number_of_columns_in_result_is_d; +static PyObject *__pyx_n_u_numeric; +static PyObject *__pyx_n_s_object; +static PyObject *__pyx_n_s_oid; +static PyObject *__pyx_n_u_oid; +static PyObject *__pyx_kp_u_oid_2; +static PyObject *__pyx_n_s_on_error; +static PyObject *__pyx_kp_u_on_result__prepare_statement_is; +static PyObject *__pyx_kp_u_on_result_waiter_is_None; +static PyObject *__pyx_kp_u_on_result_waiter_is_done; +static PyObject *__pyx_n_s_on_timeout; +static PyObject *__pyx_n_s_on_waiter_completed; +static PyObject *__pyx_n_u_opaque; +static PyObject *__pyx_n_s_packed; +static PyObject *__pyx_kp_u_parse_data_msgs_first_message_i; +static PyObject *__pyx_kp_u_parse_data_msgs_result_is_not_a; +static PyObject *__pyx_n_s_password; +static PyObject *__pyx_n_u_password; +static PyObject *__pyx_n_u_path; +static PyObject *__pyx_kp_u_path_value_too_long; +static PyObject *__pyx_n_u_pg_catalog; +static PyObject *__pyx_kp_u_pg_contrib_hstore; +static PyObject *__pyx_n_u_pg_ddl_command; +static PyObject *__pyx_n_s_pg_epoch_date; +static PyObject *__pyx_n_s_pg_epoch_datetime; +static PyObject *__pyx_n_s_pg_epoch_datetime_utc; +static PyObject *__pyx_n_u_pg_lsn; +static PyObject *__pyx_n_u_pg_node_tree; +static PyObject *__pyx_n_u_point; +static PyObject *__pyx_n_u_polygon; +static PyObject *__pyx_kp_u_polygon_value_too_long; +static PyObject *__pyx_n_s_popleft; +static PyObject *__pyx_n_s_portal_name; +static PyObject *__pyx_n_s_prefixlen; +static PyObject *__pyx_n_s_prepare; +static PyObject *__pyx_n_s_prepare_2; +static PyObject *__pyx_n_s_print; +static PyObject *__pyx_n_s_protocol; +static PyObject *__pyx_kp_u_protocol_is_already_in_the_idle; +static PyObject *__pyx_kp_u_protocol_is_in_an_unknown_state; +static PyObject *__pyx_n_s_pyx_capi; +static PyObject *__pyx_n_s_pyx_vtable; +static PyObject *__pyx_n_s_qualname; +static PyObject *__pyx_n_s_query; +static PyObject *__pyx_n_b_r; +static PyObject *__pyx_n_s_range; +static PyObject *__pyx_n_u_range; +static PyObject *__pyx_n_u_range_subtype; +static PyObject *__pyx_kp_u_read_cstr_buffer_overread; +static PyObject *__pyx_kp_u_read_cstr_only_works_when_the_me; +static PyObject *__pyx_n_s_rec; +static PyObject *__pyx_n_u_record; +static PyObject *__pyx_n_u_refcursor; +static PyObject *__pyx_n_u_regclass; +static PyObject *__pyx_n_u_regconfig; +static PyObject *__pyx_n_u_regdictionary; +static PyObject *__pyx_n_u_regnamespace; +static PyObject *__pyx_n_u_regoper; +static PyObject *__pyx_n_u_regoperator; +static PyObject *__pyx_n_u_regproc; +static PyObject *__pyx_n_u_regprocedure; +static PyObject *__pyx_n_u_regrole; +static PyObject *__pyx_n_u_regtype; +static PyObject *__pyx_n_u_reltime; +static PyObject *__pyx_n_s_replace; +static PyObject *__pyx_n_s_request_cancel; +static PyObject *__pyx_n_s_return_extra; +static PyObject *__pyx_n_u_scalar; +static PyObject *__pyx_n_s_second; +static PyObject *__pyx_n_s_seconds; +static PyObject *__pyx_n_s_send; +static PyObject *__pyx_n_s_set_builtin_type_codec; +static PyObject *__pyx_n_s_set_exception; +static PyObject *__pyx_n_s_set_result; +static PyObject *__pyx_n_s_setsockopt; +static PyObject *__pyx_n_u_shift_jis; +static PyObject *__pyx_n_u_shift_jis_2004; +static PyObject *__pyx_n_u_sjis; +static PyObject *__pyx_n_u_smgr; +static PyObject *__pyx_n_s_socket; +static PyObject *__pyx_n_u_socket; +static PyObject *__pyx_kp_u_specified_array_dimensions_do_no; +static PyObject *__pyx_n_u_sql_ascii; +static PyObject *__pyx_n_s_startswith; +static PyObject *__pyx_n_s_state; +static PyObject *__pyx_kp_u_stmt; +static PyObject *__pyx_n_s_stmt_name; +static PyObject *__pyx_kp_u_string_too_long; +static PyObject *__pyx_n_s_supernet; +static PyObject *__pyx_n_u_tcvn; +static PyObject *__pyx_n_u_tcvn5712; +static PyObject *__pyx_n_s_test; +static PyObject *__pyx_n_u_text; +static PyObject *__pyx_kp_u_text_2; +static PyObject *__pyx_kp_u_the_buffer_is_in_read_only_mode; +static PyObject *__pyx_n_s_throw; +static PyObject *__pyx_n_u_tid; +static PyObject *__pyx_n_s_time; +static PyObject *__pyx_n_u_time; +static PyObject *__pyx_n_s_timedelta; +static PyObject *__pyx_n_s_timeout; +static PyObject *__pyx_n_s_timestamp; +static PyObject *__pyx_n_u_timestamp; +static PyObject *__pyx_n_u_timestamptz; +static PyObject *__pyx_n_u_timetz; +static PyObject *__pyx_n_s_timezone; +static PyObject *__pyx_n_u_tinterval; +static PyObject *__pyx_kp_u_too_many_elements_in_array_value; +static PyObject *__pyx_kp_u_too_many_elements_in_composite_t; +static PyObject *__pyx_n_s_toordinal; +static PyObject *__pyx_n_u_trigger; +static PyObject *__pyx_n_u_tsm_handler; +static PyObject *__pyx_n_u_tsquery; +static PyObject *__pyx_n_u_tsvector; +static PyObject *__pyx_n_u_txid_snapshot; +static PyObject *__pyx_kp_u_txid_snapshot_value_is_too_long; +static PyObject *__pyx_kp_u_type_record_missing_base_type_fo; +static PyObject *__pyx_kp_u_type_record_missing_base_type_fo_2; +static PyObject *__pyx_kp_u_type_record_missing_field_types; +static PyObject *__pyx_n_s_typekind; +static PyObject *__pyx_n_s_typename; +static PyObject *__pyx_n_s_typeoid; +static PyObject *__pyx_n_s_types; +static PyObject *__pyx_n_s_typeschema; +static PyObject *__pyx_n_s_tzinfo; +static PyObject *__pyx_kp_u_unexpected_JSONB_format; +static PyObject *__pyx_kp_u_unexpected_character_r_at_positi; +static PyObject *__pyx_kp_u_unexpected_codec_type; +static PyObject *__pyx_kp_u_unexpected_data_type_of_composit; +static PyObject *__pyx_kp_u_unexpected_end_of_string; +static PyObject *__pyx_kp_u_unexpected_trailing_bytes_in_buf; +static PyObject *__pyx_kp_u_unhandled_standard_data_type_r_O; +static PyObject *__pyx_n_u_unicode; +static PyObject *__pyx_n_u_unknown; +static PyObject *__pyx_kp_u_unknown_alias_target; +static PyObject *__pyx_kp_u_unknown_error_in_protocol_implem; +static PyObject *__pyx_kp_u_unsupported_authentication_metho; +static PyObject *__pyx_kp_u_unsupported_authentication_metho_2; +static PyObject *__pyx_n_s_upper; +static PyObject *__pyx_n_s_upper_inc; +static PyObject *__pyx_n_s_user; +static PyObject *__pyx_n_u_user; +static PyObject *__pyx_n_s_utc; +static PyObject *__pyx_n_s_utcoffset; +static PyObject *__pyx_kp_u_utf_8; +static PyObject *__pyx_n_u_utf_8_2; +static PyObject *__pyx_n_s_uuid; +static PyObject *__pyx_n_u_uuid; +static PyObject *__pyx_n_u_varbit; +static PyObject *__pyx_n_u_varchar; +static PyObject *__pyx_n_s_version; +static PyObject *__pyx_n_u_void; +static PyObject *__pyx_n_u_vscii; +static PyObject *__pyx_n_u_win; +static PyObject *__pyx_n_u_win1250; +static PyObject *__pyx_n_u_win1251; +static PyObject *__pyx_n_u_win1252; +static PyObject *__pyx_n_u_win1253; +static PyObject *__pyx_n_u_win1254; +static PyObject *__pyx_n_u_win1255; +static PyObject *__pyx_n_u_win1256; +static PyObject *__pyx_n_u_win1257; +static PyObject *__pyx_n_u_win1258; +static PyObject *__pyx_n_u_win866; +static PyObject *__pyx_n_u_win874; +static PyObject *__pyx_n_u_win932; +static PyObject *__pyx_n_u_win936; +static PyObject *__pyx_n_u_win949; +static PyObject *__pyx_n_u_win950; +static PyObject *__pyx_n_u_windows1250; +static PyObject *__pyx_n_u_windows1251; +static PyObject *__pyx_n_u_windows1252; +static PyObject *__pyx_n_u_windows1253; +static PyObject *__pyx_n_u_windows1254; +static PyObject *__pyx_n_u_windows1255; +static PyObject *__pyx_n_u_windows1256; +static PyObject *__pyx_n_u_windows1257; +static PyObject *__pyx_n_u_windows1258; +static PyObject *__pyx_n_u_windows866; +static PyObject *__pyx_n_u_windows874; +static PyObject *__pyx_n_u_windows932; +static PyObject *__pyx_n_u_windows936; +static PyObject *__pyx_n_u_windows949; +static PyObject *__pyx_n_u_windows950; +static PyObject *__pyx_n_s_write; +static PyObject *__pyx_n_u_xid; +static PyObject *__pyx_n_u_xml; +static int __pyx_pf_7asyncpg_8protocol_8protocol_18ConnectionSettings___cinit__(struct __pyx_obj_7asyncpg_8protocol_8protocol_ConnectionSettings *__pyx_v_self, PyObject *__pyx_v_conn_key); /* proto */ +static PyObject *__pyx_pf_7asyncpg_8protocol_8protocol_18ConnectionSettings_2get_text_codec(struct __pyx_obj_7asyncpg_8protocol_8protocol_ConnectionSettings *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_7asyncpg_8protocol_8protocol_18ConnectionSettings_4register_data_types(struct __pyx_obj_7asyncpg_8protocol_8protocol_ConnectionSettings *__pyx_v_self, PyObject *__pyx_v_types); /* proto */ +static PyObject *__pyx_pf_7asyncpg_8protocol_8protocol_18ConnectionSettings_6add_python_codec(struct __pyx_obj_7asyncpg_8protocol_8protocol_ConnectionSettings *__pyx_v_self, PyObject *__pyx_v_typeoid, PyObject *__pyx_v_typename, PyObject *__pyx_v_typeschema, PyObject *__pyx_v_typekind, PyObject *__pyx_v_encoder, PyObject *__pyx_v_decoder, PyObject *__pyx_v_binary); /* proto */ +static PyObject *__pyx_pf_7asyncpg_8protocol_8protocol_18ConnectionSettings_8set_builtin_type_codec(struct __pyx_obj_7asyncpg_8protocol_8protocol_ConnectionSettings *__pyx_v_self, PyObject *__pyx_v_typeoid, PyObject *__pyx_v_typename, PyObject *__pyx_v_typeschema, PyObject *__pyx_v_typekind, PyObject *__pyx_v_alias_to); /* proto */ +static PyObject *__pyx_pf_7asyncpg_8protocol_8protocol_18ConnectionSettings_10get_data_codec(struct __pyx_obj_7asyncpg_8protocol_8protocol_ConnectionSettings *__pyx_v_self, uint32_t __pyx_v_oid, enum __pyx_t_7asyncpg_8protocol_8protocol_CodecFormat __pyx_v_format); /* proto */ +static PyObject *__pyx_pf_7asyncpg_8protocol_8protocol_18ConnectionSettings_12__getattr__(struct __pyx_obj_7asyncpg_8protocol_8protocol_ConnectionSettings *__pyx_v_self, PyObject *__pyx_v_name); /* proto */ +static int __pyx_pf_7asyncpg_8protocol_8protocol_11WriteBuffer___cinit__(struct __pyx_obj_7asyncpg_8protocol_8protocol_WriteBuffer *__pyx_v_self); /* proto */ +static void __pyx_pf_7asyncpg_8protocol_8protocol_11WriteBuffer_2__dealloc__(struct __pyx_obj_7asyncpg_8protocol_8protocol_WriteBuffer *__pyx_v_self); /* proto */ +static int __pyx_pf_7asyncpg_8protocol_8protocol_11WriteBuffer_4__getbuffer__(struct __pyx_obj_7asyncpg_8protocol_8protocol_WriteBuffer *__pyx_v_self, Py_buffer *__pyx_v_buffer, int __pyx_v_flags); /* proto */ +static void __pyx_pf_7asyncpg_8protocol_8protocol_11WriteBuffer_6__releasebuffer__(struct __pyx_obj_7asyncpg_8protocol_8protocol_WriteBuffer *__pyx_v_self, CYTHON_UNUSED Py_buffer *__pyx_v_buffer); /* proto */ +static int __pyx_pf_7asyncpg_8protocol_8protocol_10ReadBuffer___cinit__(struct __pyx_obj_7asyncpg_8protocol_8protocol_ReadBuffer *__pyx_v_self); /* proto */ +static int __pyx_pf_7asyncpg_8protocol_8protocol_5Codec___cinit__(struct __pyx_obj_7asyncpg_8protocol_8protocol_Codec *__pyx_v_self, uint32_t __pyx_v_oid); /* proto */ +static PyObject *__pyx_pf_7asyncpg_8protocol_8protocol_5Codec_2__repr__(struct __pyx_obj_7asyncpg_8protocol_8protocol_Codec *__pyx_v_self); /* proto */ +static int __pyx_pf_7asyncpg_8protocol_8protocol_15DataCodecConfig___init__(struct __pyx_obj_7asyncpg_8protocol_8protocol_DataCodecConfig *__pyx_v_self, PyObject *__pyx_v_cache_key); /* proto */ +static PyObject *__pyx_pf_7asyncpg_8protocol_8protocol_15DataCodecConfig_2add_types(struct __pyx_obj_7asyncpg_8protocol_8protocol_DataCodecConfig *__pyx_v_self, PyObject *__pyx_v_types); /* proto */ +static PyObject *__pyx_pf_7asyncpg_8protocol_8protocol_15DataCodecConfig_4add_python_codec(struct __pyx_obj_7asyncpg_8protocol_8protocol_DataCodecConfig *__pyx_v_self, PyObject *__pyx_v_typeoid, PyObject *__pyx_v_typename, PyObject *__pyx_v_typeschema, PyObject *__pyx_v_typekind, PyObject *__pyx_v_encoder, PyObject *__pyx_v_decoder, PyObject *__pyx_v_binary); /* proto */ +static PyObject *__pyx_pf_7asyncpg_8protocol_8protocol_15DataCodecConfig_6set_builtin_type_codec(struct __pyx_obj_7asyncpg_8protocol_8protocol_DataCodecConfig *__pyx_v_self, PyObject *__pyx_v_typeoid, PyObject *__pyx_v_typename, PyObject *__pyx_v_typeschema, PyObject *__pyx_v_typekind, PyObject *__pyx_v_alias_to); /* proto */ +static PyObject *__pyx_pf_7asyncpg_8protocol_8protocol_15DataCodecConfig_8clear_type_cache(struct __pyx_obj_7asyncpg_8protocol_8protocol_DataCodecConfig *__pyx_v_self); /* proto */ +static int __pyx_pf_7asyncpg_8protocol_8protocol_12CoreProtocol___init__(struct __pyx_obj_7asyncpg_8protocol_8protocol_CoreProtocol *__pyx_v_self, PyObject *__pyx_v_con_args); /* proto */ +static PyObject *__pyx_pf_7asyncpg_8protocol_8protocol_12CoreProtocol_2data_received(struct __pyx_obj_7asyncpg_8protocol_8protocol_CoreProtocol *__pyx_v_self, PyObject *__pyx_v_data); /* proto */ +static PyObject *__pyx_pf_7asyncpg_8protocol_8protocol_12CoreProtocol_4connection_made(struct __pyx_obj_7asyncpg_8protocol_8protocol_CoreProtocol *__pyx_v_self, PyObject *__pyx_v_transport); /* proto */ +static PyObject *__pyx_pf_7asyncpg_8protocol_8protocol_12CoreProtocol_6connection_lost(struct __pyx_obj_7asyncpg_8protocol_8protocol_CoreProtocol *__pyx_v_self, PyObject *__pyx_v_exc); /* proto */ +static PyObject *__pyx_pf_7asyncpg_8protocol_8protocol_12CoreProtocol_11backend_pid___get__(struct __pyx_obj_7asyncpg_8protocol_8protocol_CoreProtocol *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_7asyncpg_8protocol_8protocol_12CoreProtocol_14backend_secret___get__(struct __pyx_obj_7asyncpg_8protocol_8protocol_CoreProtocol *__pyx_v_self); /* proto */ +static int __pyx_pf_7asyncpg_8protocol_8protocol_22PreparedStatementState___cinit__(struct __pyx_obj_7asyncpg_8protocol_8protocol_PreparedStatementState *__pyx_v_self, PyObject *__pyx_v_name, PyObject *__pyx_v_query, struct __pyx_obj_7asyncpg_8protocol_8protocol_BaseProtocol *__pyx_v_protocol); /* proto */ +static PyObject *__pyx_pf_7asyncpg_8protocol_8protocol_22PreparedStatementState_2_get_parameters(struct __pyx_obj_7asyncpg_8protocol_8protocol_PreparedStatementState *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_7asyncpg_8protocol_8protocol_22PreparedStatementState_4_get_attributes(struct __pyx_obj_7asyncpg_8protocol_8protocol_PreparedStatementState *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_7asyncpg_8protocol_8protocol_22PreparedStatementState_6_init_types(struct __pyx_obj_7asyncpg_8protocol_8protocol_PreparedStatementState *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_7asyncpg_8protocol_8protocol_22PreparedStatementState_8attach(struct __pyx_obj_7asyncpg_8protocol_8protocol_PreparedStatementState *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_7asyncpg_8protocol_8protocol_22PreparedStatementState_10detach(struct __pyx_obj_7asyncpg_8protocol_8protocol_PreparedStatementState *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_7asyncpg_8protocol_8protocol_22PreparedStatementState_12mark_closed(struct __pyx_obj_7asyncpg_8protocol_8protocol_PreparedStatementState *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_7asyncpg_8protocol_8protocol_22PreparedStatementState_4name___get__(struct __pyx_obj_7asyncpg_8protocol_8protocol_PreparedStatementState *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_7asyncpg_8protocol_8protocol_22PreparedStatementState_5query___get__(struct __pyx_obj_7asyncpg_8protocol_8protocol_PreparedStatementState *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_7asyncpg_8protocol_8protocol_22PreparedStatementState_6closed___get__(struct __pyx_obj_7asyncpg_8protocol_8protocol_PreparedStatementState *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_7asyncpg_8protocol_8protocol_22PreparedStatementState_4refs___get__(struct __pyx_obj_7asyncpg_8protocol_8protocol_PreparedStatementState *__pyx_v_self); /* proto */ +static int __pyx_pf_7asyncpg_8protocol_8protocol_12BaseProtocol___init__(struct __pyx_obj_7asyncpg_8protocol_8protocol_BaseProtocol *__pyx_v_self, PyObject *__pyx_v_addr, PyObject *__pyx_v_connected_fut, PyObject *__pyx_v_con_args, PyObject *__pyx_v_loop); /* proto */ +static PyObject *__pyx_pf_7asyncpg_8protocol_8protocol_12BaseProtocol_2set_connection(struct __pyx_obj_7asyncpg_8protocol_8protocol_BaseProtocol *__pyx_v_self, PyObject *__pyx_v_connection); /* proto */ +static PyObject *__pyx_pf_7asyncpg_8protocol_8protocol_12BaseProtocol_4get_server_pid(struct __pyx_obj_7asyncpg_8protocol_8protocol_BaseProtocol *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_7asyncpg_8protocol_8protocol_12BaseProtocol_6get_settings(struct __pyx_obj_7asyncpg_8protocol_8protocol_BaseProtocol *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_7asyncpg_8protocol_8protocol_12BaseProtocol_8prepare(struct __pyx_obj_7asyncpg_8protocol_8protocol_BaseProtocol *__pyx_v_self, PyObject *__pyx_v_stmt_name, PyObject *__pyx_v_query, PyObject *__pyx_v_timeout); /* proto */ +static PyObject *__pyx_pf_7asyncpg_8protocol_8protocol_12BaseProtocol_11bind_execute(struct __pyx_obj_7asyncpg_8protocol_8protocol_BaseProtocol *__pyx_v_self, struct __pyx_obj_7asyncpg_8protocol_8protocol_PreparedStatementState *__pyx_v_state, PyObject *__pyx_v_args, PyObject *__pyx_v_portal_name, int __pyx_v_limit, PyObject *__pyx_v_return_extra, PyObject *__pyx_v_timeout); /* proto */ +static PyObject *__pyx_pf_7asyncpg_8protocol_8protocol_12BaseProtocol_17bind_execute_many_genexpr(PyObject *__pyx_self); /* proto */ +static PyObject *__pyx_pf_7asyncpg_8protocol_8protocol_12BaseProtocol_14bind_execute_many(struct __pyx_obj_7asyncpg_8protocol_8protocol_BaseProtocol *__pyx_v_self, struct __pyx_obj_7asyncpg_8protocol_8protocol_PreparedStatementState *__pyx_v_state, PyObject *__pyx_v_args, PyObject *__pyx_v_portal_name, PyObject *__pyx_v_timeout); /* proto */ +static PyObject *__pyx_pf_7asyncpg_8protocol_8protocol_12BaseProtocol_17bind(struct __pyx_obj_7asyncpg_8protocol_8protocol_BaseProtocol *__pyx_v_self, struct __pyx_obj_7asyncpg_8protocol_8protocol_PreparedStatementState *__pyx_v_state, PyObject *__pyx_v_args, PyObject *__pyx_v_portal_name, PyObject *__pyx_v_timeout); /* proto */ +static PyObject *__pyx_pf_7asyncpg_8protocol_8protocol_12BaseProtocol_20execute(struct __pyx_obj_7asyncpg_8protocol_8protocol_BaseProtocol *__pyx_v_self, struct __pyx_obj_7asyncpg_8protocol_8protocol_PreparedStatementState *__pyx_v_state, PyObject *__pyx_v_portal_name, int __pyx_v_limit, PyObject *__pyx_v_return_extra, PyObject *__pyx_v_timeout); /* proto */ +static PyObject *__pyx_pf_7asyncpg_8protocol_8protocol_12BaseProtocol_23query(struct __pyx_obj_7asyncpg_8protocol_8protocol_BaseProtocol *__pyx_v_self, PyObject *__pyx_v_query, PyObject *__pyx_v_timeout); /* proto */ +static PyObject *__pyx_pf_7asyncpg_8protocol_8protocol_12BaseProtocol_26close_statement(struct __pyx_obj_7asyncpg_8protocol_8protocol_BaseProtocol *__pyx_v_self, struct __pyx_obj_7asyncpg_8protocol_8protocol_PreparedStatementState *__pyx_v_state, PyObject *__pyx_v_timeout); /* proto */ +static PyObject *__pyx_pf_7asyncpg_8protocol_8protocol_12BaseProtocol_29is_closed(struct __pyx_obj_7asyncpg_8protocol_8protocol_BaseProtocol *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_7asyncpg_8protocol_8protocol_12BaseProtocol_31is_connected(struct __pyx_obj_7asyncpg_8protocol_8protocol_BaseProtocol *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_7asyncpg_8protocol_8protocol_12BaseProtocol_33abort(struct __pyx_obj_7asyncpg_8protocol_8protocol_BaseProtocol *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_7asyncpg_8protocol_8protocol_12BaseProtocol_35close(struct __pyx_obj_7asyncpg_8protocol_8protocol_BaseProtocol *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_7asyncpg_8protocol_8protocol_12BaseProtocol_38_request_cancel(struct __pyx_obj_7asyncpg_8protocol_8protocol_BaseProtocol *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_7asyncpg_8protocol_8protocol_12BaseProtocol_40_on_timeout(struct __pyx_obj_7asyncpg_8protocol_8protocol_BaseProtocol *__pyx_v_self, PyObject *__pyx_v_fut); /* proto */ +static PyObject *__pyx_pf_7asyncpg_8protocol_8protocol_12BaseProtocol_42_on_waiter_completed(struct __pyx_obj_7asyncpg_8protocol_8protocol_BaseProtocol *__pyx_v_self, PyObject *__pyx_v_fut); /* proto */ +static PyObject *__pyx_pf_7asyncpg_8protocol_8protocol_12BaseProtocol_44_create_future_fallback(struct __pyx_obj_7asyncpg_8protocol_8protocol_BaseProtocol *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_7asyncpg_8protocol_8protocol_12BaseProtocol_13queries_count___get__(struct __pyx_obj_7asyncpg_8protocol_8protocol_BaseProtocol *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_7asyncpg_8protocol_8protocol__create_record(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_mapping, PyObject *__pyx_v_elems); /* proto */ +static PyObject *__pyx_tp_new_7asyncpg_8protocol_8protocol_Memory(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/ +static PyObject *__pyx_tp_new_7asyncpg_8protocol_8protocol_WriteBuffer(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/ +static PyObject *__pyx_tp_new_7asyncpg_8protocol_8protocol_ReadBuffer(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/ +static PyObject *__pyx_tp_new_7asyncpg_8protocol_8protocol_FastReadBuffer(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/ +static PyObject *__pyx_tp_new_7asyncpg_8protocol_8protocol_Codec(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/ +static PyObject *__pyx_tp_new_7asyncpg_8protocol_8protocol_DataCodecConfig(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/ +static PyObject *__pyx_tp_new_7asyncpg_8protocol_8protocol_ConnectionSettings(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/ +static PyObject *__pyx_tp_new_7asyncpg_8protocol_8protocol_CoreProtocol(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/ +static PyObject *__pyx_tp_new_7asyncpg_8protocol_8protocol_PreparedStatementState(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/ +static PyObject *__pyx_tp_new_7asyncpg_8protocol_8protocol_BaseProtocol(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/ +static PyObject *__pyx_tp_new_7asyncpg_8protocol_8protocol___pyx_scope_struct__prepare(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/ +static PyObject *__pyx_tp_new_7asyncpg_8protocol_8protocol___pyx_scope_struct_1_bind_execute(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/ +static PyObject *__pyx_tp_new_7asyncpg_8protocol_8protocol___pyx_scope_struct_2_bind_execute_many(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/ +static PyObject *__pyx_tp_new_7asyncpg_8protocol_8protocol___pyx_scope_struct_3_genexpr(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/ +static PyObject *__pyx_tp_new_7asyncpg_8protocol_8protocol___pyx_scope_struct_4_bind(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/ +static PyObject *__pyx_tp_new_7asyncpg_8protocol_8protocol___pyx_scope_struct_5_execute(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/ +static PyObject *__pyx_tp_new_7asyncpg_8protocol_8protocol___pyx_scope_struct_6_query(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/ +static PyObject *__pyx_tp_new_7asyncpg_8protocol_8protocol___pyx_scope_struct_7_close_statement(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/ +static PyObject *__pyx_tp_new_7asyncpg_8protocol_8protocol___pyx_scope_struct_8_close(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/ +static PyObject *__pyx_int_0; +static PyObject *__pyx_int_1; +static PyObject *__pyx_int_4; +static PyObject *__pyx_int_6; +static PyObject *__pyx_int_12; +static PyObject *__pyx_int_16; +static PyObject *__pyx_int_17; +static PyObject *__pyx_int_18; +static PyObject *__pyx_int_19; +static PyObject *__pyx_int_20; +static PyObject *__pyx_int_21; +static PyObject *__pyx_int_23; +static PyObject *__pyx_int_24; +static PyObject *__pyx_int_25; +static PyObject *__pyx_int_26; +static PyObject *__pyx_int_27; +static PyObject *__pyx_int_28; +static PyObject *__pyx_int_29; +static PyObject *__pyx_int_31; +static PyObject *__pyx_int_32; +static PyObject *__pyx_int_59; +static PyObject *__pyx_int_114; +static PyObject *__pyx_int_142; +static PyObject *__pyx_int_194; +static PyObject *__pyx_int_210; +static PyObject *__pyx_int_600; +static PyObject *__pyx_int_601; +static PyObject *__pyx_int_602; +static PyObject *__pyx_int_603; +static PyObject *__pyx_int_604; +static PyObject *__pyx_int_628; +static PyObject *__pyx_int_650; +static PyObject *__pyx_int_700; +static PyObject *__pyx_int_701; +static PyObject *__pyx_int_702; +static PyObject *__pyx_int_703; +static PyObject *__pyx_int_704; +static PyObject *__pyx_int_705; +static PyObject *__pyx_int_718; +static PyObject *__pyx_int_790; +static PyObject *__pyx_int_829; +static PyObject *__pyx_int_869; +static PyObject *__pyx_int_1009; +static PyObject *__pyx_int_1028; +static PyObject *__pyx_int_1033; +static PyObject *__pyx_int_1042; +static PyObject *__pyx_int_1043; +static PyObject *__pyx_int_1082; +static PyObject *__pyx_int_1083; +static PyObject *__pyx_int_1114; +static PyObject *__pyx_int_1184; +static PyObject *__pyx_int_1186; +static PyObject *__pyx_int_1266; +static PyObject *__pyx_int_1560; +static PyObject *__pyx_int_1562; +static PyObject *__pyx_int_1700; +static PyObject *__pyx_int_1790; +static PyObject *__pyx_int_2000; +static PyObject *__pyx_int_2202; +static PyObject *__pyx_int_2203; +static PyObject *__pyx_int_2204; +static PyObject *__pyx_int_2205; +static PyObject *__pyx_int_2206; +static PyObject *__pyx_int_2249; +static PyObject *__pyx_int_2275; +static PyObject *__pyx_int_2276; +static PyObject *__pyx_int_2277; +static PyObject *__pyx_int_2278; +static PyObject *__pyx_int_2279; +static PyObject *__pyx_int_2280; +static PyObject *__pyx_int_2281; +static PyObject *__pyx_int_2282; +static PyObject *__pyx_int_2283; +static PyObject *__pyx_int_2776; +static PyObject *__pyx_int_2950; +static PyObject *__pyx_int_2970; +static PyObject *__pyx_int_3115; +static PyObject *__pyx_int_3220; +static PyObject *__pyx_int_3310; +static PyObject *__pyx_int_3500; +static PyObject *__pyx_int_3614; +static PyObject *__pyx_int_3615; +static PyObject *__pyx_int_3642; +static PyObject *__pyx_int_3734; +static PyObject *__pyx_int_3769; +static PyObject *__pyx_int_3802; +static PyObject *__pyx_int_3831; +static PyObject *__pyx_int_3838; +static PyObject *__pyx_int_4089; +static PyObject *__pyx_int_4096; +static PyObject *__pyx_int_9999; +static PyObject *__pyx_int_999999; +static enum __pyx_t_7asyncpg_8protocol_8protocol_CodecFormat __pyx_k__2; +static PyObject *__pyx_tuple_; +static PyObject *__pyx_tuple__4; +static PyObject *__pyx_tuple__5; +static PyObject *__pyx_tuple__6; +static PyObject *__pyx_tuple__7; +static PyObject *__pyx_tuple__8; +static PyObject *__pyx_tuple__9; +static PyObject *__pyx_slice__27; +static PyObject *__pyx_tuple__10; +static PyObject *__pyx_tuple__11; +static PyObject *__pyx_tuple__12; +static PyObject *__pyx_tuple__13; +static PyObject *__pyx_tuple__14; +static PyObject *__pyx_tuple__15; +static PyObject *__pyx_tuple__16; +static PyObject *__pyx_tuple__17; +static PyObject *__pyx_tuple__20; +static PyObject *__pyx_tuple__21; +static PyObject *__pyx_tuple__22; +static PyObject *__pyx_tuple__23; +static PyObject *__pyx_tuple__24; +static PyObject *__pyx_tuple__25; +static PyObject *__pyx_tuple__26; +static PyObject *__pyx_tuple__29; +static PyObject *__pyx_tuple__30; +static PyObject *__pyx_tuple__31; +static PyObject *__pyx_tuple__32; +static PyObject *__pyx_tuple__33; +static PyObject *__pyx_tuple__34; +static PyObject *__pyx_tuple__35; +static PyObject *__pyx_tuple__36; +static PyObject *__pyx_tuple__37; +static PyObject *__pyx_tuple__38; +static PyObject *__pyx_tuple__39; +static PyObject *__pyx_tuple__40; +static PyObject *__pyx_tuple__41; +static PyObject *__pyx_tuple__42; +static PyObject *__pyx_tuple__43; +static PyObject *__pyx_tuple__44; +static PyObject *__pyx_tuple__45; +static PyObject *__pyx_tuple__46; +static PyObject *__pyx_tuple__47; +static PyObject *__pyx_tuple__48; +static PyObject *__pyx_tuple__49; +static PyObject *__pyx_tuple__50; +static PyObject *__pyx_tuple__51; +static PyObject *__pyx_tuple__52; +static PyObject *__pyx_tuple__53; +static PyObject *__pyx_tuple__54; +static PyObject *__pyx_tuple__55; +static PyObject *__pyx_tuple__56; +static PyObject *__pyx_tuple__57; +static PyObject *__pyx_tuple__58; +static PyObject *__pyx_tuple__59; +static PyObject *__pyx_tuple__60; +static PyObject *__pyx_tuple__61; +static PyObject *__pyx_tuple__62; +static PyObject *__pyx_tuple__63; +static PyObject *__pyx_tuple__64; +static PyObject *__pyx_tuple__65; +static PyObject *__pyx_tuple__67; +static PyObject *__pyx_tuple__68; +static PyObject *__pyx_tuple__69; +static PyObject *__pyx_tuple__70; +static PyObject *__pyx_tuple__71; +static PyObject *__pyx_tuple__72; +static PyObject *__pyx_tuple__73; +static PyObject *__pyx_tuple__74; +static PyObject *__pyx_tuple__75; +static PyObject *__pyx_tuple__76; +static PyObject *__pyx_tuple__77; +static PyObject *__pyx_tuple__78; +static PyObject *__pyx_tuple__79; +static PyObject *__pyx_tuple__80; +static PyObject *__pyx_tuple__81; +static PyObject *__pyx_tuple__82; +static PyObject *__pyx_tuple__83; +static PyObject *__pyx_tuple__84; +static PyObject *__pyx_tuple__85; +static PyObject *__pyx_tuple__86; +static PyObject *__pyx_tuple__87; +static PyObject *__pyx_codeobj__88; + +/* "asyncpg/protocol/encodings.pyx":62 + * + * + * cdef get_python_encoding(pg_encoding): # <<<<<<<<<<<<<< + * return ENCODINGS_MAP.get(pg_encoding.lower(), pg_encoding.lower()) + */ + +static PyObject *__pyx_f_7asyncpg_8protocol_8protocol_get_python_encoding(PyObject *__pyx_v_pg_encoding) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + __Pyx_RefNannySetupContext("get_python_encoding", 0); + + /* "asyncpg/protocol/encodings.pyx":63 + * + * cdef get_python_encoding(pg_encoding): + * return ENCODINGS_MAP.get(pg_encoding.lower(), pg_encoding.lower()) # <<<<<<<<<<<<<< + */ + __Pyx_XDECREF(__pyx_r); + if (unlikely(__pyx_v_7asyncpg_8protocol_8protocol_ENCODINGS_MAP == Py_None)) { + PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%s'", "get"); + __PYX_ERR(5, 63, __pyx_L1_error) + } + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_pg_encoding, __pyx_n_s_lower); if (unlikely(!__pyx_t_2)) __PYX_ERR(5, 63, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = NULL; + if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_3)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_3); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + } + } + if (__pyx_t_3) { + __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_3); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 63, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + } else { + __pyx_t_1 = __Pyx_PyObject_CallNoArg(__pyx_t_2); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 63, __pyx_L1_error) + } + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_pg_encoding, __pyx_n_s_lower); if (unlikely(!__pyx_t_3)) __PYX_ERR(5, 63, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = NULL; + if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_3))) { + __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_3); + if (likely(__pyx_t_4)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); + __Pyx_INCREF(__pyx_t_4); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_3, function); + } + } + if (__pyx_t_4) { + __pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_4); if (unlikely(!__pyx_t_2)) __PYX_ERR(5, 63, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + } else { + __pyx_t_2 = __Pyx_PyObject_CallNoArg(__pyx_t_3); if (unlikely(!__pyx_t_2)) __PYX_ERR(5, 63, __pyx_L1_error) + } + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_3 = __Pyx_PyDict_GetItemDefault(__pyx_v_7asyncpg_8protocol_8protocol_ENCODINGS_MAP, __pyx_t_1, __pyx_t_2); if (unlikely(!__pyx_t_3)) __PYX_ERR(5, 63, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_r = __pyx_t_3; + __pyx_t_3 = 0; + goto __pyx_L0; + + /* "asyncpg/protocol/encodings.pyx":62 + * + * + * cdef get_python_encoding(pg_encoding): # <<<<<<<<<<<<<< + * return ENCODINGS_MAP.get(pg_encoding.lower(), pg_encoding.lower()) + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_AddTraceback("asyncpg.protocol.protocol.get_python_encoding", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "asyncpg/protocol/settings.pyx":11 + * cdef class ConnectionSettings: + * + * def __cinit__(self, conn_key): # <<<<<<<<<<<<<< + * self._encoding = 'utf-8' + * self._is_utf8 = True + */ + +/* Python wrapper */ +static int __pyx_pw_7asyncpg_8protocol_8protocol_18ConnectionSettings_1__cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ +static int __pyx_pw_7asyncpg_8protocol_8protocol_18ConnectionSettings_1__cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { + PyObject *__pyx_v_conn_key = 0; + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__cinit__ (wrapper)", 0); + { + static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_conn_key,0}; + PyObject* values[1] = {0}; + if (unlikely(__pyx_kwds)) { + Py_ssize_t kw_args; + const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args); + switch (pos_args) { + case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = PyDict_Size(__pyx_kwds); + switch (pos_args) { + case 0: + if (likely((values[0] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_conn_key)) != 0)) kw_args--; + else goto __pyx_L5_argtuple_error; + } + if (unlikely(kw_args > 0)) { + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "__cinit__") < 0)) __PYX_ERR(0, 11, __pyx_L3_error) + } + } else if (PyTuple_GET_SIZE(__pyx_args) != 1) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + } + __pyx_v_conn_key = values[0]; + } + goto __pyx_L4_argument_unpacking_done; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("__cinit__", 1, 1, 1, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 11, __pyx_L3_error) + __pyx_L3_error:; + __Pyx_AddTraceback("asyncpg.protocol.protocol.ConnectionSettings.__cinit__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return -1; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_7asyncpg_8protocol_8protocol_18ConnectionSettings___cinit__(((struct __pyx_obj_7asyncpg_8protocol_8protocol_ConnectionSettings *)__pyx_v_self), __pyx_v_conn_key); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_7asyncpg_8protocol_8protocol_18ConnectionSettings___cinit__(struct __pyx_obj_7asyncpg_8protocol_8protocol_ConnectionSettings *__pyx_v_self, PyObject *__pyx_v_conn_key) { + int __pyx_r; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + __Pyx_RefNannySetupContext("__cinit__", 0); + + /* "asyncpg/protocol/settings.pyx":12 + * + * def __cinit__(self, conn_key): + * self._encoding = 'utf-8' # <<<<<<<<<<<<<< + * self._is_utf8 = True + * self._settings = {} + */ + __Pyx_INCREF(__pyx_kp_u_utf_8); + __Pyx_GIVEREF(__pyx_kp_u_utf_8); + __Pyx_GOTREF(__pyx_v_self->_encoding); + __Pyx_DECREF(__pyx_v_self->_encoding); + __pyx_v_self->_encoding = __pyx_kp_u_utf_8; + + /* "asyncpg/protocol/settings.pyx":13 + * def __cinit__(self, conn_key): + * self._encoding = 'utf-8' + * self._is_utf8 = True # <<<<<<<<<<<<<< + * self._settings = {} + * self._codec = codecs.lookup('utf-8') + */ + __pyx_v_self->_is_utf8 = 1; + + /* "asyncpg/protocol/settings.pyx":14 + * self._encoding = 'utf-8' + * self._is_utf8 = True + * self._settings = {} # <<<<<<<<<<<<<< + * self._codec = codecs.lookup('utf-8') + * self._data_codecs = DataCodecConfig(conn_key) + */ + __pyx_t_1 = PyDict_New(); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 14, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_GIVEREF(__pyx_t_1); + __Pyx_GOTREF(__pyx_v_self->_settings); + __Pyx_DECREF(__pyx_v_self->_settings); + __pyx_v_self->_settings = ((PyObject*)__pyx_t_1); + __pyx_t_1 = 0; + + /* "asyncpg/protocol/settings.pyx":15 + * self._is_utf8 = True + * self._settings = {} + * self._codec = codecs.lookup('utf-8') # <<<<<<<<<<<<<< + * self._data_codecs = DataCodecConfig(conn_key) + * + */ + __pyx_t_1 = __Pyx_GetModuleGlobalName(__pyx_n_s_codecs); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 15, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_lookup); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 15, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_tuple_, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 15, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_GIVEREF(__pyx_t_1); + __Pyx_GOTREF(__pyx_v_self->_codec); + __Pyx_DECREF(__pyx_v_self->_codec); + __pyx_v_self->_codec = __pyx_t_1; + __pyx_t_1 = 0; + + /* "asyncpg/protocol/settings.pyx":16 + * self._settings = {} + * self._codec = codecs.lookup('utf-8') + * self._data_codecs = DataCodecConfig(conn_key) # <<<<<<<<<<<<<< + * + * cdef add_setting(self, str name, str val): + */ + __pyx_t_1 = PyTuple_New(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 16, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_INCREF(__pyx_v_conn_key); + __Pyx_GIVEREF(__pyx_v_conn_key); + PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_v_conn_key); + __pyx_t_2 = __Pyx_PyObject_Call(((PyObject *)__pyx_ptype_7asyncpg_8protocol_8protocol_DataCodecConfig), __pyx_t_1, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 16, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_GIVEREF(__pyx_t_2); + __Pyx_GOTREF(__pyx_v_self->_data_codecs); + __Pyx_DECREF(((PyObject *)__pyx_v_self->_data_codecs)); + __pyx_v_self->_data_codecs = ((struct __pyx_obj_7asyncpg_8protocol_8protocol_DataCodecConfig *)__pyx_t_2); + __pyx_t_2 = 0; + + /* "asyncpg/protocol/settings.pyx":11 + * cdef class ConnectionSettings: + * + * def __cinit__(self, conn_key): # <<<<<<<<<<<<<< + * self._encoding = 'utf-8' + * self._is_utf8 = True + */ + + /* function exit code */ + __pyx_r = 0; + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_AddTraceback("asyncpg.protocol.protocol.ConnectionSettings.__cinit__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = -1; + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "asyncpg/protocol/settings.pyx":18 + * self._data_codecs = DataCodecConfig(conn_key) + * + * cdef add_setting(self, str name, str val): # <<<<<<<<<<<<<< + * self._settings[name] = val + * if name == 'client_encoding': + */ + +static PyObject *__pyx_f_7asyncpg_8protocol_8protocol_18ConnectionSettings_add_setting(struct __pyx_obj_7asyncpg_8protocol_8protocol_ConnectionSettings *__pyx_v_self, PyObject *__pyx_v_name, PyObject *__pyx_v_val) { + PyObject *__pyx_v_py_enc = NULL; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + int __pyx_t_2; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + PyObject *__pyx_t_5 = NULL; + PyObject *__pyx_t_6 = NULL; + __Pyx_RefNannySetupContext("add_setting", 0); + + /* "asyncpg/protocol/settings.pyx":19 + * + * cdef add_setting(self, str name, str val): + * self._settings[name] = val # <<<<<<<<<<<<<< + * if name == 'client_encoding': + * py_enc = get_python_encoding(val) + */ + if (unlikely(__pyx_v_self->_settings == Py_None)) { + PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable"); + __PYX_ERR(0, 19, __pyx_L1_error) + } + if (unlikely(PyDict_SetItem(__pyx_v_self->_settings, __pyx_v_name, __pyx_v_val) < 0)) __PYX_ERR(0, 19, __pyx_L1_error) + + /* "asyncpg/protocol/settings.pyx":20 + * cdef add_setting(self, str name, str val): + * self._settings[name] = val + * if name == 'client_encoding': # <<<<<<<<<<<<<< + * py_enc = get_python_encoding(val) + * self._codec = codecs.lookup(py_enc) + */ + __pyx_t_1 = (__Pyx_PyUnicode_Equals(__pyx_v_name, __pyx_n_u_client_encoding, Py_EQ)); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(0, 20, __pyx_L1_error) + __pyx_t_2 = (__pyx_t_1 != 0); + if (__pyx_t_2) { + + /* "asyncpg/protocol/settings.pyx":21 + * self._settings[name] = val + * if name == 'client_encoding': + * py_enc = get_python_encoding(val) # <<<<<<<<<<<<<< + * self._codec = codecs.lookup(py_enc) + * self._encoding = self._codec.name + */ + __pyx_t_3 = __pyx_f_7asyncpg_8protocol_8protocol_get_python_encoding(__pyx_v_val); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 21, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_v_py_enc = __pyx_t_3; + __pyx_t_3 = 0; + + /* "asyncpg/protocol/settings.pyx":22 + * if name == 'client_encoding': + * py_enc = get_python_encoding(val) + * self._codec = codecs.lookup(py_enc) # <<<<<<<<<<<<<< + * self._encoding = self._codec.name + * self._is_utf8 = self._encoding == 'utf-8' + */ + __pyx_t_4 = __Pyx_GetModuleGlobalName(__pyx_n_s_codecs); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 22, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_n_s_lookup); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 22, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_4 = NULL; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_5))) { + __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_5); + if (likely(__pyx_t_4)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_5); + __Pyx_INCREF(__pyx_t_4); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_5, function); + } + } + if (!__pyx_t_4) { + __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_t_5, __pyx_v_py_enc); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 22, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + } else { + #if CYTHON_FAST_PYCALL + if (PyFunction_Check(__pyx_t_5)) { + PyObject *__pyx_temp[2] = {__pyx_t_4, __pyx_v_py_enc}; + __pyx_t_3 = __Pyx_PyFunction_FastCall(__pyx_t_5, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 22, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_GOTREF(__pyx_t_3); + } else + #endif + #if CYTHON_FAST_PYCCALL + if (__Pyx_PyFastCFunction_Check(__pyx_t_5)) { + PyObject *__pyx_temp[2] = {__pyx_t_4, __pyx_v_py_enc}; + __pyx_t_3 = __Pyx_PyCFunction_FastCall(__pyx_t_5, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 22, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_GOTREF(__pyx_t_3); + } else + #endif + { + __pyx_t_6 = PyTuple_New(1+1); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 22, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_GIVEREF(__pyx_t_4); PyTuple_SET_ITEM(__pyx_t_6, 0, __pyx_t_4); __pyx_t_4 = NULL; + __Pyx_INCREF(__pyx_v_py_enc); + __Pyx_GIVEREF(__pyx_v_py_enc); + PyTuple_SET_ITEM(__pyx_t_6, 0+1, __pyx_v_py_enc); + __pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_5, __pyx_t_6, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 22, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + } + } + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_GIVEREF(__pyx_t_3); + __Pyx_GOTREF(__pyx_v_self->_codec); + __Pyx_DECREF(__pyx_v_self->_codec); + __pyx_v_self->_codec = __pyx_t_3; + __pyx_t_3 = 0; + + /* "asyncpg/protocol/settings.pyx":23 + * py_enc = get_python_encoding(val) + * self._codec = codecs.lookup(py_enc) + * self._encoding = self._codec.name # <<<<<<<<<<<<<< + * self._is_utf8 = self._encoding == 'utf-8' + * + */ + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_self->_codec, __pyx_n_s_name); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 23, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + if (!(likely(PyUnicode_CheckExact(__pyx_t_3))||((__pyx_t_3) == Py_None)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "unicode", Py_TYPE(__pyx_t_3)->tp_name), 0))) __PYX_ERR(0, 23, __pyx_L1_error) + __Pyx_GIVEREF(__pyx_t_3); + __Pyx_GOTREF(__pyx_v_self->_encoding); + __Pyx_DECREF(__pyx_v_self->_encoding); + __pyx_v_self->_encoding = ((PyObject*)__pyx_t_3); + __pyx_t_3 = 0; + + /* "asyncpg/protocol/settings.pyx":24 + * self._codec = codecs.lookup(py_enc) + * self._encoding = self._codec.name + * self._is_utf8 = self._encoding == 'utf-8' # <<<<<<<<<<<<<< + * + * cdef inline is_encoding_utf8(self): + */ + __pyx_t_2 = (__Pyx_PyUnicode_Equals(__pyx_v_self->_encoding, __pyx_kp_u_utf_8, Py_EQ)); if (unlikely(__pyx_t_2 < 0)) __PYX_ERR(0, 24, __pyx_L1_error) + __pyx_v_self->_is_utf8 = __pyx_t_2; + + /* "asyncpg/protocol/settings.pyx":20 + * cdef add_setting(self, str name, str val): + * self._settings[name] = val + * if name == 'client_encoding': # <<<<<<<<<<<<<< + * py_enc = get_python_encoding(val) + * self._codec = codecs.lookup(py_enc) + */ + } + + /* "asyncpg/protocol/settings.pyx":18 + * self._data_codecs = DataCodecConfig(conn_key) + * + * cdef add_setting(self, str name, str val): # <<<<<<<<<<<<<< + * self._settings[name] = val + * if name == 'client_encoding': + */ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_XDECREF(__pyx_t_6); + __Pyx_AddTraceback("asyncpg.protocol.protocol.ConnectionSettings.add_setting", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XDECREF(__pyx_v_py_enc); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "asyncpg/protocol/settings.pyx":26 + * self._is_utf8 = self._encoding == 'utf-8' + * + * cdef inline is_encoding_utf8(self): # <<<<<<<<<<<<<< + * return self._is_utf8 + * + */ + +static CYTHON_INLINE PyObject *__pyx_f_7asyncpg_8protocol_8protocol_18ConnectionSettings_is_encoding_utf8(struct __pyx_obj_7asyncpg_8protocol_8protocol_ConnectionSettings *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + __Pyx_RefNannySetupContext("is_encoding_utf8", 0); + + /* "asyncpg/protocol/settings.pyx":27 + * + * cdef inline is_encoding_utf8(self): + * return self._is_utf8 # <<<<<<<<<<<<<< + * + * cpdef inline get_text_codec(self): + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyBool_FromLong(__pyx_v_self->_is_utf8); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 27, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "asyncpg/protocol/settings.pyx":26 + * self._is_utf8 = self._encoding == 'utf-8' + * + * cdef inline is_encoding_utf8(self): # <<<<<<<<<<<<<< + * return self._is_utf8 + * + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("asyncpg.protocol.protocol.ConnectionSettings.is_encoding_utf8", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "asyncpg/protocol/settings.pyx":29 + * return self._is_utf8 + * + * cpdef inline get_text_codec(self): # <<<<<<<<<<<<<< + * return self._codec + * + */ + +static PyObject *__pyx_pw_7asyncpg_8protocol_8protocol_18ConnectionSettings_3get_text_codec(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/ +static CYTHON_INLINE PyObject *__pyx_f_7asyncpg_8protocol_8protocol_18ConnectionSettings_get_text_codec(struct __pyx_obj_7asyncpg_8protocol_8protocol_ConnectionSettings *__pyx_v_self, CYTHON_UNUSED int __pyx_skip_dispatch) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("get_text_codec", 0); + + /* "asyncpg/protocol/settings.pyx":30 + * + * cpdef inline get_text_codec(self): + * return self._codec # <<<<<<<<<<<<<< + * + * cpdef inline register_data_types(self, types): + */ + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(__pyx_v_self->_codec); + __pyx_r = __pyx_v_self->_codec; + goto __pyx_L0; + + /* "asyncpg/protocol/settings.pyx":29 + * return self._is_utf8 + * + * cpdef inline get_text_codec(self): # <<<<<<<<<<<<<< + * return self._codec + * + */ + + /* function exit code */ + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* Python wrapper */ +static PyObject *__pyx_pw_7asyncpg_8protocol_8protocol_18ConnectionSettings_3get_text_codec(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/ +static PyObject *__pyx_pw_7asyncpg_8protocol_8protocol_18ConnectionSettings_3get_text_codec(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("get_text_codec (wrapper)", 0); + __pyx_r = __pyx_pf_7asyncpg_8protocol_8protocol_18ConnectionSettings_2get_text_codec(((struct __pyx_obj_7asyncpg_8protocol_8protocol_ConnectionSettings *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_7asyncpg_8protocol_8protocol_18ConnectionSettings_2get_text_codec(struct __pyx_obj_7asyncpg_8protocol_8protocol_ConnectionSettings *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + __Pyx_RefNannySetupContext("get_text_codec", 0); + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __pyx_f_7asyncpg_8protocol_8protocol_18ConnectionSettings_get_text_codec(__pyx_v_self, 1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 29, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("asyncpg.protocol.protocol.ConnectionSettings.get_text_codec", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "asyncpg/protocol/settings.pyx":32 + * return self._codec + * + * cpdef inline register_data_types(self, types): # <<<<<<<<<<<<<< + * self._data_codecs.add_types(types) + * + */ + +static PyObject *__pyx_pw_7asyncpg_8protocol_8protocol_18ConnectionSettings_5register_data_types(PyObject *__pyx_v_self, PyObject *__pyx_v_types); /*proto*/ +static CYTHON_INLINE PyObject *__pyx_f_7asyncpg_8protocol_8protocol_18ConnectionSettings_register_data_types(struct __pyx_obj_7asyncpg_8protocol_8protocol_ConnectionSettings *__pyx_v_self, PyObject *__pyx_v_types, CYTHON_UNUSED int __pyx_skip_dispatch) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + __Pyx_RefNannySetupContext("register_data_types", 0); + + /* "asyncpg/protocol/settings.pyx":33 + * + * cpdef inline register_data_types(self, types): + * self._data_codecs.add_types(types) # <<<<<<<<<<<<<< + * + * cpdef inline add_python_codec(self, typeoid, typename, typeschema, + */ + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self->_data_codecs), __pyx_n_s_add_types); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 33, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = NULL; + if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_3)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_3); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + } + } + if (!__pyx_t_3) { + __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_v_types); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 33, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + } else { + #if CYTHON_FAST_PYCALL + if (PyFunction_Check(__pyx_t_2)) { + PyObject *__pyx_temp[2] = {__pyx_t_3, __pyx_v_types}; + __pyx_t_1 = __Pyx_PyFunction_FastCall(__pyx_t_2, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 33, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_GOTREF(__pyx_t_1); + } else + #endif + #if CYTHON_FAST_PYCCALL + if (__Pyx_PyFastCFunction_Check(__pyx_t_2)) { + PyObject *__pyx_temp[2] = {__pyx_t_3, __pyx_v_types}; + __pyx_t_1 = __Pyx_PyCFunction_FastCall(__pyx_t_2, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 33, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_GOTREF(__pyx_t_1); + } else + #endif + { + __pyx_t_4 = PyTuple_New(1+1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 33, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_GIVEREF(__pyx_t_3); PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_3); __pyx_t_3 = NULL; + __Pyx_INCREF(__pyx_v_types); + __Pyx_GIVEREF(__pyx_v_types); + PyTuple_SET_ITEM(__pyx_t_4, 0+1, __pyx_v_types); + __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_t_4, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 33, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + } + } + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "asyncpg/protocol/settings.pyx":32 + * return self._codec + * + * cpdef inline register_data_types(self, types): # <<<<<<<<<<<<<< + * self._data_codecs.add_types(types) + * + */ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_AddTraceback("asyncpg.protocol.protocol.ConnectionSettings.register_data_types", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* Python wrapper */ +static PyObject *__pyx_pw_7asyncpg_8protocol_8protocol_18ConnectionSettings_5register_data_types(PyObject *__pyx_v_self, PyObject *__pyx_v_types); /*proto*/ +static PyObject *__pyx_pw_7asyncpg_8protocol_8protocol_18ConnectionSettings_5register_data_types(PyObject *__pyx_v_self, PyObject *__pyx_v_types) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("register_data_types (wrapper)", 0); + __pyx_r = __pyx_pf_7asyncpg_8protocol_8protocol_18ConnectionSettings_4register_data_types(((struct __pyx_obj_7asyncpg_8protocol_8protocol_ConnectionSettings *)__pyx_v_self), ((PyObject *)__pyx_v_types)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_7asyncpg_8protocol_8protocol_18ConnectionSettings_4register_data_types(struct __pyx_obj_7asyncpg_8protocol_8protocol_ConnectionSettings *__pyx_v_self, PyObject *__pyx_v_types) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + __Pyx_RefNannySetupContext("register_data_types", 0); + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __pyx_f_7asyncpg_8protocol_8protocol_18ConnectionSettings_register_data_types(__pyx_v_self, __pyx_v_types, 1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 32, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("asyncpg.protocol.protocol.ConnectionSettings.register_data_types", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "asyncpg/protocol/settings.pyx":35 + * self._data_codecs.add_types(types) + * + * cpdef inline add_python_codec(self, typeoid, typename, typeschema, # <<<<<<<<<<<<<< + * typekind, encoder, decoder, binary): + * self._data_codecs.add_python_codec(typeoid, typename, typeschema, + */ + +static PyObject *__pyx_pw_7asyncpg_8protocol_8protocol_18ConnectionSettings_7add_python_codec(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ +static CYTHON_INLINE PyObject *__pyx_f_7asyncpg_8protocol_8protocol_18ConnectionSettings_add_python_codec(struct __pyx_obj_7asyncpg_8protocol_8protocol_ConnectionSettings *__pyx_v_self, PyObject *__pyx_v_typeoid, PyObject *__pyx_v_typename, PyObject *__pyx_v_typeschema, PyObject *__pyx_v_typekind, PyObject *__pyx_v_encoder, PyObject *__pyx_v_decoder, PyObject *__pyx_v_binary, CYTHON_UNUSED int __pyx_skip_dispatch) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + int __pyx_t_4; + PyObject *__pyx_t_5 = NULL; + __Pyx_RefNannySetupContext("add_python_codec", 0); + + /* "asyncpg/protocol/settings.pyx":37 + * cpdef inline add_python_codec(self, typeoid, typename, typeschema, + * typekind, encoder, decoder, binary): + * self._data_codecs.add_python_codec(typeoid, typename, typeschema, # <<<<<<<<<<<<<< + * typekind, encoder, decoder, binary) + * + */ + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self->_data_codecs), __pyx_n_s_add_python_codec); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 37, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + + /* "asyncpg/protocol/settings.pyx":38 + * typekind, encoder, decoder, binary): + * self._data_codecs.add_python_codec(typeoid, typename, typeschema, + * typekind, encoder, decoder, binary) # <<<<<<<<<<<<<< + * + * cpdef inline set_builtin_type_codec(self, typeoid, typename, typeschema, + */ + __pyx_t_3 = NULL; + __pyx_t_4 = 0; + if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_3)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_3); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + __pyx_t_4 = 1; + } + } + #if CYTHON_FAST_PYCALL + if (PyFunction_Check(__pyx_t_2)) { + PyObject *__pyx_temp[8] = {__pyx_t_3, __pyx_v_typeoid, __pyx_v_typename, __pyx_v_typeschema, __pyx_v_typekind, __pyx_v_encoder, __pyx_v_decoder, __pyx_v_binary}; + __pyx_t_1 = __Pyx_PyFunction_FastCall(__pyx_t_2, __pyx_temp+1-__pyx_t_4, 7+__pyx_t_4); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 37, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_GOTREF(__pyx_t_1); + } else + #endif + #if CYTHON_FAST_PYCCALL + if (__Pyx_PyFastCFunction_Check(__pyx_t_2)) { + PyObject *__pyx_temp[8] = {__pyx_t_3, __pyx_v_typeoid, __pyx_v_typename, __pyx_v_typeschema, __pyx_v_typekind, __pyx_v_encoder, __pyx_v_decoder, __pyx_v_binary}; + __pyx_t_1 = __Pyx_PyCFunction_FastCall(__pyx_t_2, __pyx_temp+1-__pyx_t_4, 7+__pyx_t_4); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 37, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_GOTREF(__pyx_t_1); + } else + #endif + { + __pyx_t_5 = PyTuple_New(7+__pyx_t_4); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 37, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + if (__pyx_t_3) { + __Pyx_GIVEREF(__pyx_t_3); PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_t_3); __pyx_t_3 = NULL; + } + __Pyx_INCREF(__pyx_v_typeoid); + __Pyx_GIVEREF(__pyx_v_typeoid); + PyTuple_SET_ITEM(__pyx_t_5, 0+__pyx_t_4, __pyx_v_typeoid); + __Pyx_INCREF(__pyx_v_typename); + __Pyx_GIVEREF(__pyx_v_typename); + PyTuple_SET_ITEM(__pyx_t_5, 1+__pyx_t_4, __pyx_v_typename); + __Pyx_INCREF(__pyx_v_typeschema); + __Pyx_GIVEREF(__pyx_v_typeschema); + PyTuple_SET_ITEM(__pyx_t_5, 2+__pyx_t_4, __pyx_v_typeschema); + __Pyx_INCREF(__pyx_v_typekind); + __Pyx_GIVEREF(__pyx_v_typekind); + PyTuple_SET_ITEM(__pyx_t_5, 3+__pyx_t_4, __pyx_v_typekind); + __Pyx_INCREF(__pyx_v_encoder); + __Pyx_GIVEREF(__pyx_v_encoder); + PyTuple_SET_ITEM(__pyx_t_5, 4+__pyx_t_4, __pyx_v_encoder); + __Pyx_INCREF(__pyx_v_decoder); + __Pyx_GIVEREF(__pyx_v_decoder); + PyTuple_SET_ITEM(__pyx_t_5, 5+__pyx_t_4, __pyx_v_decoder); + __Pyx_INCREF(__pyx_v_binary); + __Pyx_GIVEREF(__pyx_v_binary); + PyTuple_SET_ITEM(__pyx_t_5, 6+__pyx_t_4, __pyx_v_binary); + __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_t_5, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 37, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + } + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "asyncpg/protocol/settings.pyx":35 + * self._data_codecs.add_types(types) + * + * cpdef inline add_python_codec(self, typeoid, typename, typeschema, # <<<<<<<<<<<<<< + * typekind, encoder, decoder, binary): + * self._data_codecs.add_python_codec(typeoid, typename, typeschema, + */ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_AddTraceback("asyncpg.protocol.protocol.ConnectionSettings.add_python_codec", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* Python wrapper */ +static PyObject *__pyx_pw_7asyncpg_8protocol_8protocol_18ConnectionSettings_7add_python_codec(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ +static PyObject *__pyx_pw_7asyncpg_8protocol_8protocol_18ConnectionSettings_7add_python_codec(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { + PyObject *__pyx_v_typeoid = 0; + PyObject *__pyx_v_typename = 0; + PyObject *__pyx_v_typeschema = 0; + PyObject *__pyx_v_typekind = 0; + PyObject *__pyx_v_encoder = 0; + PyObject *__pyx_v_decoder = 0; + PyObject *__pyx_v_binary = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("add_python_codec (wrapper)", 0); + { + static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_typeoid,&__pyx_n_s_typename,&__pyx_n_s_typeschema,&__pyx_n_s_typekind,&__pyx_n_s_encoder,&__pyx_n_s_decoder,&__pyx_n_s_binary,0}; + PyObject* values[7] = {0,0,0,0,0,0,0}; + if (unlikely(__pyx_kwds)) { + Py_ssize_t kw_args; + const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args); + switch (pos_args) { + case 7: values[6] = PyTuple_GET_ITEM(__pyx_args, 6); + case 6: values[5] = PyTuple_GET_ITEM(__pyx_args, 5); + case 5: values[4] = PyTuple_GET_ITEM(__pyx_args, 4); + case 4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3); + case 3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2); + case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); + case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = PyDict_Size(__pyx_kwds); + switch (pos_args) { + case 0: + if (likely((values[0] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_typeoid)) != 0)) kw_args--; + else goto __pyx_L5_argtuple_error; + case 1: + if (likely((values[1] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_typename)) != 0)) kw_args--; + else { + __Pyx_RaiseArgtupleInvalid("add_python_codec", 1, 7, 7, 1); __PYX_ERR(0, 35, __pyx_L3_error) + } + case 2: + if (likely((values[2] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_typeschema)) != 0)) kw_args--; + else { + __Pyx_RaiseArgtupleInvalid("add_python_codec", 1, 7, 7, 2); __PYX_ERR(0, 35, __pyx_L3_error) + } + case 3: + if (likely((values[3] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_typekind)) != 0)) kw_args--; + else { + __Pyx_RaiseArgtupleInvalid("add_python_codec", 1, 7, 7, 3); __PYX_ERR(0, 35, __pyx_L3_error) + } + case 4: + if (likely((values[4] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_encoder)) != 0)) kw_args--; + else { + __Pyx_RaiseArgtupleInvalid("add_python_codec", 1, 7, 7, 4); __PYX_ERR(0, 35, __pyx_L3_error) + } + case 5: + if (likely((values[5] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_decoder)) != 0)) kw_args--; + else { + __Pyx_RaiseArgtupleInvalid("add_python_codec", 1, 7, 7, 5); __PYX_ERR(0, 35, __pyx_L3_error) + } + case 6: + if (likely((values[6] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_binary)) != 0)) kw_args--; + else { + __Pyx_RaiseArgtupleInvalid("add_python_codec", 1, 7, 7, 6); __PYX_ERR(0, 35, __pyx_L3_error) + } + } + if (unlikely(kw_args > 0)) { + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "add_python_codec") < 0)) __PYX_ERR(0, 35, __pyx_L3_error) + } + } else if (PyTuple_GET_SIZE(__pyx_args) != 7) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + values[1] = PyTuple_GET_ITEM(__pyx_args, 1); + values[2] = PyTuple_GET_ITEM(__pyx_args, 2); + values[3] = PyTuple_GET_ITEM(__pyx_args, 3); + values[4] = PyTuple_GET_ITEM(__pyx_args, 4); + values[5] = PyTuple_GET_ITEM(__pyx_args, 5); + values[6] = PyTuple_GET_ITEM(__pyx_args, 6); + } + __pyx_v_typeoid = values[0]; + __pyx_v_typename = values[1]; + __pyx_v_typeschema = values[2]; + __pyx_v_typekind = values[3]; + __pyx_v_encoder = values[4]; + __pyx_v_decoder = values[5]; + __pyx_v_binary = values[6]; + } + goto __pyx_L4_argument_unpacking_done; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("add_python_codec", 1, 7, 7, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 35, __pyx_L3_error) + __pyx_L3_error:; + __Pyx_AddTraceback("asyncpg.protocol.protocol.ConnectionSettings.add_python_codec", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_7asyncpg_8protocol_8protocol_18ConnectionSettings_6add_python_codec(((struct __pyx_obj_7asyncpg_8protocol_8protocol_ConnectionSettings *)__pyx_v_self), __pyx_v_typeoid, __pyx_v_typename, __pyx_v_typeschema, __pyx_v_typekind, __pyx_v_encoder, __pyx_v_decoder, __pyx_v_binary); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_7asyncpg_8protocol_8protocol_18ConnectionSettings_6add_python_codec(struct __pyx_obj_7asyncpg_8protocol_8protocol_ConnectionSettings *__pyx_v_self, PyObject *__pyx_v_typeoid, PyObject *__pyx_v_typename, PyObject *__pyx_v_typeschema, PyObject *__pyx_v_typekind, PyObject *__pyx_v_encoder, PyObject *__pyx_v_decoder, PyObject *__pyx_v_binary) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + __Pyx_RefNannySetupContext("add_python_codec", 0); + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __pyx_f_7asyncpg_8protocol_8protocol_18ConnectionSettings_add_python_codec(__pyx_v_self, __pyx_v_typeoid, __pyx_v_typename, __pyx_v_typeschema, __pyx_v_typekind, __pyx_v_encoder, __pyx_v_decoder, __pyx_v_binary, 1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 35, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("asyncpg.protocol.protocol.ConnectionSettings.add_python_codec", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "asyncpg/protocol/settings.pyx":40 + * typekind, encoder, decoder, binary) + * + * cpdef inline set_builtin_type_codec(self, typeoid, typename, typeschema, # <<<<<<<<<<<<<< + * typekind, alias_to): + * self._data_codecs.set_builtin_type_codec(typeoid, typename, typeschema, + */ + +static PyObject *__pyx_pw_7asyncpg_8protocol_8protocol_18ConnectionSettings_9set_builtin_type_codec(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ +static CYTHON_INLINE PyObject *__pyx_f_7asyncpg_8protocol_8protocol_18ConnectionSettings_set_builtin_type_codec(struct __pyx_obj_7asyncpg_8protocol_8protocol_ConnectionSettings *__pyx_v_self, PyObject *__pyx_v_typeoid, PyObject *__pyx_v_typename, PyObject *__pyx_v_typeschema, PyObject *__pyx_v_typekind, PyObject *__pyx_v_alias_to, CYTHON_UNUSED int __pyx_skip_dispatch) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + int __pyx_t_4; + PyObject *__pyx_t_5 = NULL; + __Pyx_RefNannySetupContext("set_builtin_type_codec", 0); + + /* "asyncpg/protocol/settings.pyx":42 + * cpdef inline set_builtin_type_codec(self, typeoid, typename, typeschema, + * typekind, alias_to): + * self._data_codecs.set_builtin_type_codec(typeoid, typename, typeschema, # <<<<<<<<<<<<<< + * typekind, alias_to) + * + */ + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self->_data_codecs), __pyx_n_s_set_builtin_type_codec); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 42, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + + /* "asyncpg/protocol/settings.pyx":43 + * typekind, alias_to): + * self._data_codecs.set_builtin_type_codec(typeoid, typename, typeschema, + * typekind, alias_to) # <<<<<<<<<<<<<< + * + * cpdef inline Codec get_data_codec(self, uint32_t oid, + */ + __pyx_t_3 = NULL; + __pyx_t_4 = 0; + if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_3)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_3); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + __pyx_t_4 = 1; + } + } + #if CYTHON_FAST_PYCALL + if (PyFunction_Check(__pyx_t_2)) { + PyObject *__pyx_temp[6] = {__pyx_t_3, __pyx_v_typeoid, __pyx_v_typename, __pyx_v_typeschema, __pyx_v_typekind, __pyx_v_alias_to}; + __pyx_t_1 = __Pyx_PyFunction_FastCall(__pyx_t_2, __pyx_temp+1-__pyx_t_4, 5+__pyx_t_4); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 42, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_GOTREF(__pyx_t_1); + } else + #endif + #if CYTHON_FAST_PYCCALL + if (__Pyx_PyFastCFunction_Check(__pyx_t_2)) { + PyObject *__pyx_temp[6] = {__pyx_t_3, __pyx_v_typeoid, __pyx_v_typename, __pyx_v_typeschema, __pyx_v_typekind, __pyx_v_alias_to}; + __pyx_t_1 = __Pyx_PyCFunction_FastCall(__pyx_t_2, __pyx_temp+1-__pyx_t_4, 5+__pyx_t_4); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 42, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_GOTREF(__pyx_t_1); + } else + #endif + { + __pyx_t_5 = PyTuple_New(5+__pyx_t_4); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 42, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + if (__pyx_t_3) { + __Pyx_GIVEREF(__pyx_t_3); PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_t_3); __pyx_t_3 = NULL; + } + __Pyx_INCREF(__pyx_v_typeoid); + __Pyx_GIVEREF(__pyx_v_typeoid); + PyTuple_SET_ITEM(__pyx_t_5, 0+__pyx_t_4, __pyx_v_typeoid); + __Pyx_INCREF(__pyx_v_typename); + __Pyx_GIVEREF(__pyx_v_typename); + PyTuple_SET_ITEM(__pyx_t_5, 1+__pyx_t_4, __pyx_v_typename); + __Pyx_INCREF(__pyx_v_typeschema); + __Pyx_GIVEREF(__pyx_v_typeschema); + PyTuple_SET_ITEM(__pyx_t_5, 2+__pyx_t_4, __pyx_v_typeschema); + __Pyx_INCREF(__pyx_v_typekind); + __Pyx_GIVEREF(__pyx_v_typekind); + PyTuple_SET_ITEM(__pyx_t_5, 3+__pyx_t_4, __pyx_v_typekind); + __Pyx_INCREF(__pyx_v_alias_to); + __Pyx_GIVEREF(__pyx_v_alias_to); + PyTuple_SET_ITEM(__pyx_t_5, 4+__pyx_t_4, __pyx_v_alias_to); + __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_t_5, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 42, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + } + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "asyncpg/protocol/settings.pyx":40 + * typekind, encoder, decoder, binary) + * + * cpdef inline set_builtin_type_codec(self, typeoid, typename, typeschema, # <<<<<<<<<<<<<< + * typekind, alias_to): + * self._data_codecs.set_builtin_type_codec(typeoid, typename, typeschema, + */ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_AddTraceback("asyncpg.protocol.protocol.ConnectionSettings.set_builtin_type_codec", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* Python wrapper */ +static PyObject *__pyx_pw_7asyncpg_8protocol_8protocol_18ConnectionSettings_9set_builtin_type_codec(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ +static PyObject *__pyx_pw_7asyncpg_8protocol_8protocol_18ConnectionSettings_9set_builtin_type_codec(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { + PyObject *__pyx_v_typeoid = 0; + PyObject *__pyx_v_typename = 0; + PyObject *__pyx_v_typeschema = 0; + PyObject *__pyx_v_typekind = 0; + PyObject *__pyx_v_alias_to = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("set_builtin_type_codec (wrapper)", 0); + { + static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_typeoid,&__pyx_n_s_typename,&__pyx_n_s_typeschema,&__pyx_n_s_typekind,&__pyx_n_s_alias_to,0}; + PyObject* values[5] = {0,0,0,0,0}; + if (unlikely(__pyx_kwds)) { + Py_ssize_t kw_args; + const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args); + switch (pos_args) { + case 5: values[4] = PyTuple_GET_ITEM(__pyx_args, 4); + case 4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3); + case 3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2); + case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); + case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = PyDict_Size(__pyx_kwds); + switch (pos_args) { + case 0: + if (likely((values[0] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_typeoid)) != 0)) kw_args--; + else goto __pyx_L5_argtuple_error; + case 1: + if (likely((values[1] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_typename)) != 0)) kw_args--; + else { + __Pyx_RaiseArgtupleInvalid("set_builtin_type_codec", 1, 5, 5, 1); __PYX_ERR(0, 40, __pyx_L3_error) + } + case 2: + if (likely((values[2] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_typeschema)) != 0)) kw_args--; + else { + __Pyx_RaiseArgtupleInvalid("set_builtin_type_codec", 1, 5, 5, 2); __PYX_ERR(0, 40, __pyx_L3_error) + } + case 3: + if (likely((values[3] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_typekind)) != 0)) kw_args--; + else { + __Pyx_RaiseArgtupleInvalid("set_builtin_type_codec", 1, 5, 5, 3); __PYX_ERR(0, 40, __pyx_L3_error) + } + case 4: + if (likely((values[4] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_alias_to)) != 0)) kw_args--; + else { + __Pyx_RaiseArgtupleInvalid("set_builtin_type_codec", 1, 5, 5, 4); __PYX_ERR(0, 40, __pyx_L3_error) + } + } + if (unlikely(kw_args > 0)) { + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "set_builtin_type_codec") < 0)) __PYX_ERR(0, 40, __pyx_L3_error) + } + } else if (PyTuple_GET_SIZE(__pyx_args) != 5) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + values[1] = PyTuple_GET_ITEM(__pyx_args, 1); + values[2] = PyTuple_GET_ITEM(__pyx_args, 2); + values[3] = PyTuple_GET_ITEM(__pyx_args, 3); + values[4] = PyTuple_GET_ITEM(__pyx_args, 4); + } + __pyx_v_typeoid = values[0]; + __pyx_v_typename = values[1]; + __pyx_v_typeschema = values[2]; + __pyx_v_typekind = values[3]; + __pyx_v_alias_to = values[4]; + } + goto __pyx_L4_argument_unpacking_done; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("set_builtin_type_codec", 1, 5, 5, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 40, __pyx_L3_error) + __pyx_L3_error:; + __Pyx_AddTraceback("asyncpg.protocol.protocol.ConnectionSettings.set_builtin_type_codec", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_7asyncpg_8protocol_8protocol_18ConnectionSettings_8set_builtin_type_codec(((struct __pyx_obj_7asyncpg_8protocol_8protocol_ConnectionSettings *)__pyx_v_self), __pyx_v_typeoid, __pyx_v_typename, __pyx_v_typeschema, __pyx_v_typekind, __pyx_v_alias_to); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_7asyncpg_8protocol_8protocol_18ConnectionSettings_8set_builtin_type_codec(struct __pyx_obj_7asyncpg_8protocol_8protocol_ConnectionSettings *__pyx_v_self, PyObject *__pyx_v_typeoid, PyObject *__pyx_v_typename, PyObject *__pyx_v_typeschema, PyObject *__pyx_v_typekind, PyObject *__pyx_v_alias_to) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + __Pyx_RefNannySetupContext("set_builtin_type_codec", 0); + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __pyx_f_7asyncpg_8protocol_8protocol_18ConnectionSettings_set_builtin_type_codec(__pyx_v_self, __pyx_v_typeoid, __pyx_v_typename, __pyx_v_typeschema, __pyx_v_typekind, __pyx_v_alias_to, 1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 40, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("asyncpg.protocol.protocol.ConnectionSettings.set_builtin_type_codec", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "asyncpg/protocol/settings.pyx":45 + * typekind, alias_to) + * + * cpdef inline Codec get_data_codec(self, uint32_t oid, # <<<<<<<<<<<<<< + * CodecFormat format=PG_FORMAT_ANY): + * if format == PG_FORMAT_ANY: + */ + +static PyObject *__pyx_pw_7asyncpg_8protocol_8protocol_18ConnectionSettings_11get_data_codec(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ +static CYTHON_INLINE struct __pyx_obj_7asyncpg_8protocol_8protocol_Codec *__pyx_f_7asyncpg_8protocol_8protocol_18ConnectionSettings_get_data_codec(struct __pyx_obj_7asyncpg_8protocol_8protocol_ConnectionSettings *__pyx_v_self, uint32_t __pyx_v_oid, CYTHON_UNUSED int __pyx_skip_dispatch, struct __pyx_opt_args_7asyncpg_8protocol_8protocol_18ConnectionSettings_get_data_codec *__pyx_optional_args) { + enum __pyx_t_7asyncpg_8protocol_8protocol_CodecFormat __pyx_v_format = __pyx_k__2; + struct __pyx_obj_7asyncpg_8protocol_8protocol_Codec *__pyx_v_codec = NULL; + struct __pyx_obj_7asyncpg_8protocol_8protocol_Codec *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + PyObject *__pyx_t_2 = NULL; + int __pyx_t_3; + __Pyx_RefNannySetupContext("get_data_codec", 0); + if (__pyx_optional_args) { + if (__pyx_optional_args->__pyx_n > 0) { + __pyx_v_format = __pyx_optional_args->format; + } + } + + /* "asyncpg/protocol/settings.pyx":47 + * cpdef inline Codec get_data_codec(self, uint32_t oid, + * CodecFormat format=PG_FORMAT_ANY): + * if format == PG_FORMAT_ANY: # <<<<<<<<<<<<<< + * codec = self._data_codecs.get_codec(oid, PG_FORMAT_BINARY) + * if codec is None: + */ + __pyx_t_1 = ((__pyx_v_format == __pyx_e_7asyncpg_8protocol_8protocol_PG_FORMAT_ANY) != 0); + if (__pyx_t_1) { + + /* "asyncpg/protocol/settings.pyx":48 + * CodecFormat format=PG_FORMAT_ANY): + * if format == PG_FORMAT_ANY: + * codec = self._data_codecs.get_codec(oid, PG_FORMAT_BINARY) # <<<<<<<<<<<<<< + * if codec is None: + * codec = self._data_codecs.get_codec(oid, PG_FORMAT_TEXT) + */ + __pyx_t_2 = ((PyObject *)__pyx_f_7asyncpg_8protocol_8protocol_15DataCodecConfig_get_codec(__pyx_v_self->_data_codecs, __pyx_v_oid, __pyx_e_7asyncpg_8protocol_8protocol_PG_FORMAT_BINARY)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 48, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_v_codec = ((struct __pyx_obj_7asyncpg_8protocol_8protocol_Codec *)__pyx_t_2); + __pyx_t_2 = 0; + + /* "asyncpg/protocol/settings.pyx":49 + * if format == PG_FORMAT_ANY: + * codec = self._data_codecs.get_codec(oid, PG_FORMAT_BINARY) + * if codec is None: # <<<<<<<<<<<<<< + * codec = self._data_codecs.get_codec(oid, PG_FORMAT_TEXT) + * return codec + */ + __pyx_t_1 = (((PyObject *)__pyx_v_codec) == Py_None); + __pyx_t_3 = (__pyx_t_1 != 0); + if (__pyx_t_3) { + + /* "asyncpg/protocol/settings.pyx":50 + * codec = self._data_codecs.get_codec(oid, PG_FORMAT_BINARY) + * if codec is None: + * codec = self._data_codecs.get_codec(oid, PG_FORMAT_TEXT) # <<<<<<<<<<<<<< + * return codec + * else: + */ + __pyx_t_2 = ((PyObject *)__pyx_f_7asyncpg_8protocol_8protocol_15DataCodecConfig_get_codec(__pyx_v_self->_data_codecs, __pyx_v_oid, __pyx_e_7asyncpg_8protocol_8protocol_PG_FORMAT_TEXT)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 50, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF_SET(__pyx_v_codec, ((struct __pyx_obj_7asyncpg_8protocol_8protocol_Codec *)__pyx_t_2)); + __pyx_t_2 = 0; + + /* "asyncpg/protocol/settings.pyx":49 + * if format == PG_FORMAT_ANY: + * codec = self._data_codecs.get_codec(oid, PG_FORMAT_BINARY) + * if codec is None: # <<<<<<<<<<<<<< + * codec = self._data_codecs.get_codec(oid, PG_FORMAT_TEXT) + * return codec + */ + } + + /* "asyncpg/protocol/settings.pyx":51 + * if codec is None: + * codec = self._data_codecs.get_codec(oid, PG_FORMAT_TEXT) + * return codec # <<<<<<<<<<<<<< + * else: + * return self._data_codecs.get_codec(oid, format) + */ + __Pyx_XDECREF(((PyObject *)__pyx_r)); + __Pyx_INCREF(((PyObject *)__pyx_v_codec)); + __pyx_r = __pyx_v_codec; + goto __pyx_L0; + + /* "asyncpg/protocol/settings.pyx":47 + * cpdef inline Codec get_data_codec(self, uint32_t oid, + * CodecFormat format=PG_FORMAT_ANY): + * if format == PG_FORMAT_ANY: # <<<<<<<<<<<<<< + * codec = self._data_codecs.get_codec(oid, PG_FORMAT_BINARY) + * if codec is None: + */ + } + + /* "asyncpg/protocol/settings.pyx":53 + * return codec + * else: + * return self._data_codecs.get_codec(oid, format) # <<<<<<<<<<<<<< + * + * def __getattr__(self, name): + */ + /*else*/ { + __Pyx_XDECREF(((PyObject *)__pyx_r)); + __pyx_t_2 = ((PyObject *)__pyx_f_7asyncpg_8protocol_8protocol_15DataCodecConfig_get_codec(__pyx_v_self->_data_codecs, __pyx_v_oid, __pyx_v_format)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 53, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_r = ((struct __pyx_obj_7asyncpg_8protocol_8protocol_Codec *)__pyx_t_2); + __pyx_t_2 = 0; + goto __pyx_L0; + } + + /* "asyncpg/protocol/settings.pyx":45 + * typekind, alias_to) + * + * cpdef inline Codec get_data_codec(self, uint32_t oid, # <<<<<<<<<<<<<< + * CodecFormat format=PG_FORMAT_ANY): + * if format == PG_FORMAT_ANY: + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_2); + __Pyx_AddTraceback("asyncpg.protocol.protocol.ConnectionSettings.get_data_codec", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XDECREF((PyObject *)__pyx_v_codec); + __Pyx_XGIVEREF((PyObject *)__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* Python wrapper */ +static PyObject *__pyx_pw_7asyncpg_8protocol_8protocol_18ConnectionSettings_11get_data_codec(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ +static PyObject *__pyx_pw_7asyncpg_8protocol_8protocol_18ConnectionSettings_11get_data_codec(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { + uint32_t __pyx_v_oid; + enum __pyx_t_7asyncpg_8protocol_8protocol_CodecFormat __pyx_v_format; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("get_data_codec (wrapper)", 0); + { + static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_oid,&__pyx_n_s_format,0}; + PyObject* values[2] = {0,0}; + if (unlikely(__pyx_kwds)) { + Py_ssize_t kw_args; + const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args); + switch (pos_args) { + case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); + case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = PyDict_Size(__pyx_kwds); + switch (pos_args) { + case 0: + if (likely((values[0] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_oid)) != 0)) kw_args--; + else goto __pyx_L5_argtuple_error; + case 1: + if (kw_args > 0) { + PyObject* value = PyDict_GetItem(__pyx_kwds, __pyx_n_s_format); + if (value) { values[1] = value; kw_args--; } + } + } + if (unlikely(kw_args > 0)) { + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "get_data_codec") < 0)) __PYX_ERR(0, 45, __pyx_L3_error) + } + } else { + switch (PyTuple_GET_SIZE(__pyx_args)) { + case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); + case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + break; + default: goto __pyx_L5_argtuple_error; + } + } + __pyx_v_oid = __Pyx_PyInt_As_uint32_t(values[0]); if (unlikely((__pyx_v_oid == ((uint32_t)-1)) && PyErr_Occurred())) __PYX_ERR(0, 45, __pyx_L3_error) + if (values[1]) { + __pyx_v_format = ((enum __pyx_t_7asyncpg_8protocol_8protocol_CodecFormat)__Pyx_PyInt_As_enum____pyx_t_7asyncpg_8protocol_8protocol_CodecFormat(values[1])); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 46, __pyx_L3_error) + } else { + __pyx_v_format = __pyx_k__2; + } + } + goto __pyx_L4_argument_unpacking_done; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("get_data_codec", 0, 1, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 45, __pyx_L3_error) + __pyx_L3_error:; + __Pyx_AddTraceback("asyncpg.protocol.protocol.ConnectionSettings.get_data_codec", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_7asyncpg_8protocol_8protocol_18ConnectionSettings_10get_data_codec(((struct __pyx_obj_7asyncpg_8protocol_8protocol_ConnectionSettings *)__pyx_v_self), __pyx_v_oid, __pyx_v_format); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_7asyncpg_8protocol_8protocol_18ConnectionSettings_10get_data_codec(struct __pyx_obj_7asyncpg_8protocol_8protocol_ConnectionSettings *__pyx_v_self, uint32_t __pyx_v_oid, enum __pyx_t_7asyncpg_8protocol_8protocol_CodecFormat __pyx_v_format) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + struct __pyx_opt_args_7asyncpg_8protocol_8protocol_18ConnectionSettings_get_data_codec __pyx_t_2; + __Pyx_RefNannySetupContext("get_data_codec", 0); + __Pyx_XDECREF(__pyx_r); + __pyx_t_2.__pyx_n = 1; + __pyx_t_2.format = __pyx_v_format; + __pyx_t_1 = ((PyObject *)__pyx_vtabptr_7asyncpg_8protocol_8protocol_ConnectionSettings->get_data_codec(__pyx_v_self, __pyx_v_oid, 1, &__pyx_t_2)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 45, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("asyncpg.protocol.protocol.ConnectionSettings.get_data_codec", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "asyncpg/protocol/settings.pyx":55 + * return self._data_codecs.get_codec(oid, format) + * + * def __getattr__(self, name): # <<<<<<<<<<<<<< + * if not name.startswith('_'): + * try: + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_7asyncpg_8protocol_8protocol_18ConnectionSettings_13__getattr__(PyObject *__pyx_v_self, PyObject *__pyx_v_name); /*proto*/ +static PyObject *__pyx_pw_7asyncpg_8protocol_8protocol_18ConnectionSettings_13__getattr__(PyObject *__pyx_v_self, PyObject *__pyx_v_name) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__getattr__ (wrapper)", 0); + __pyx_r = __pyx_pf_7asyncpg_8protocol_8protocol_18ConnectionSettings_12__getattr__(((struct __pyx_obj_7asyncpg_8protocol_8protocol_ConnectionSettings *)__pyx_v_self), ((PyObject *)__pyx_v_name)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_7asyncpg_8protocol_8protocol_18ConnectionSettings_12__getattr__(struct __pyx_obj_7asyncpg_8protocol_8protocol_ConnectionSettings *__pyx_v_self, PyObject *__pyx_v_name) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + int __pyx_t_3; + int __pyx_t_4; + PyObject *__pyx_t_5 = NULL; + PyObject *__pyx_t_6 = NULL; + PyObject *__pyx_t_7 = NULL; + int __pyx_t_8; + PyObject *__pyx_t_9 = NULL; + PyObject *__pyx_t_10 = NULL; + PyObject *__pyx_t_11 = NULL; + __Pyx_RefNannySetupContext("__getattr__", 0); + + /* "asyncpg/protocol/settings.pyx":56 + * + * def __getattr__(self, name): + * if not name.startswith('_'): # <<<<<<<<<<<<<< + * try: + * return self._settings[name] + */ + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_name, __pyx_n_s_startswith); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 56, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_tuple__4, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 56, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_3 = __Pyx_PyObject_IsTrue(__pyx_t_2); if (unlikely(__pyx_t_3 < 0)) __PYX_ERR(0, 56, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_4 = ((!__pyx_t_3) != 0); + if (__pyx_t_4) { + + /* "asyncpg/protocol/settings.pyx":57 + * def __getattr__(self, name): + * if not name.startswith('_'): + * try: # <<<<<<<<<<<<<< + * return self._settings[name] + * except KeyError: + */ + { + __Pyx_PyThreadState_declare + __Pyx_PyThreadState_assign + __Pyx_ExceptionSave(&__pyx_t_5, &__pyx_t_6, &__pyx_t_7); + __Pyx_XGOTREF(__pyx_t_5); + __Pyx_XGOTREF(__pyx_t_6); + __Pyx_XGOTREF(__pyx_t_7); + /*try:*/ { + + /* "asyncpg/protocol/settings.pyx":58 + * if not name.startswith('_'): + * try: + * return self._settings[name] # <<<<<<<<<<<<<< + * except KeyError: + * raise AttributeError(name) from None + */ + __Pyx_XDECREF(__pyx_r); + if (unlikely(__pyx_v_self->_settings == Py_None)) { + PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable"); + __PYX_ERR(0, 58, __pyx_L4_error) + } + __pyx_t_2 = __Pyx_PyDict_GetItem(__pyx_v_self->_settings, __pyx_v_name); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 58, __pyx_L4_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_r = __pyx_t_2; + __pyx_t_2 = 0; + goto __pyx_L8_try_return; + + /* "asyncpg/protocol/settings.pyx":57 + * def __getattr__(self, name): + * if not name.startswith('_'): + * try: # <<<<<<<<<<<<<< + * return self._settings[name] + * except KeyError: + */ + } + __pyx_L4_error:; + __Pyx_PyThreadState_assign + __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "asyncpg/protocol/settings.pyx":59 + * try: + * return self._settings[name] + * except KeyError: # <<<<<<<<<<<<<< + * raise AttributeError(name) from None + * + */ + __pyx_t_8 = __Pyx_PyErr_ExceptionMatches(__pyx_builtin_KeyError); + if (__pyx_t_8) { + __Pyx_AddTraceback("asyncpg.protocol.protocol.ConnectionSettings.__getattr__", __pyx_clineno, __pyx_lineno, __pyx_filename); + if (__Pyx_GetException(&__pyx_t_2, &__pyx_t_1, &__pyx_t_9) < 0) __PYX_ERR(0, 59, __pyx_L6_except_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_GOTREF(__pyx_t_1); + __Pyx_GOTREF(__pyx_t_9); + + /* "asyncpg/protocol/settings.pyx":60 + * return self._settings[name] + * except KeyError: + * raise AttributeError(name) from None # <<<<<<<<<<<<<< + * + * return object.__getattr__(self, name) + */ + __pyx_t_10 = PyTuple_New(1); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 60, __pyx_L6_except_error) + __Pyx_GOTREF(__pyx_t_10); + __Pyx_INCREF(__pyx_v_name); + __Pyx_GIVEREF(__pyx_v_name); + PyTuple_SET_ITEM(__pyx_t_10, 0, __pyx_v_name); + __pyx_t_11 = __Pyx_PyObject_Call(__pyx_builtin_AttributeError, __pyx_t_10, NULL); if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 60, __pyx_L6_except_error) + __Pyx_GOTREF(__pyx_t_11); + __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; + __Pyx_Raise(__pyx_t_11, 0, 0, Py_None); + __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0; + __PYX_ERR(0, 60, __pyx_L6_except_error) + } + goto __pyx_L6_except_error; + __pyx_L6_except_error:; + + /* "asyncpg/protocol/settings.pyx":57 + * def __getattr__(self, name): + * if not name.startswith('_'): + * try: # <<<<<<<<<<<<<< + * return self._settings[name] + * except KeyError: + */ + __Pyx_PyThreadState_assign + __Pyx_XGIVEREF(__pyx_t_5); + __Pyx_XGIVEREF(__pyx_t_6); + __Pyx_XGIVEREF(__pyx_t_7); + __Pyx_ExceptionReset(__pyx_t_5, __pyx_t_6, __pyx_t_7); + goto __pyx_L1_error; + __pyx_L8_try_return:; + __Pyx_PyThreadState_assign + __Pyx_XGIVEREF(__pyx_t_5); + __Pyx_XGIVEREF(__pyx_t_6); + __Pyx_XGIVEREF(__pyx_t_7); + __Pyx_ExceptionReset(__pyx_t_5, __pyx_t_6, __pyx_t_7); + goto __pyx_L0; + } + + /* "asyncpg/protocol/settings.pyx":56 + * + * def __getattr__(self, name): + * if not name.startswith('_'): # <<<<<<<<<<<<<< + * try: + * return self._settings[name] + */ + } + + /* "asyncpg/protocol/settings.pyx":62 + * raise AttributeError(name) from None + * + * return object.__getattr__(self, name) # <<<<<<<<<<<<<< + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_builtin_object, __pyx_n_s_getattr); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 62, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = NULL; + __pyx_t_8 = 0; + if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_1))) { + __pyx_t_2 = PyMethod_GET_SELF(__pyx_t_1); + if (likely(__pyx_t_2)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_1); + __Pyx_INCREF(__pyx_t_2); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_1, function); + __pyx_t_8 = 1; + } + } + #if CYTHON_FAST_PYCALL + if (PyFunction_Check(__pyx_t_1)) { + PyObject *__pyx_temp[3] = {__pyx_t_2, ((PyObject *)__pyx_v_self), __pyx_v_name}; + __pyx_t_9 = __Pyx_PyFunction_FastCall(__pyx_t_1, __pyx_temp+1-__pyx_t_8, 2+__pyx_t_8); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 62, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_GOTREF(__pyx_t_9); + } else + #endif + #if CYTHON_FAST_PYCCALL + if (__Pyx_PyFastCFunction_Check(__pyx_t_1)) { + PyObject *__pyx_temp[3] = {__pyx_t_2, ((PyObject *)__pyx_v_self), __pyx_v_name}; + __pyx_t_9 = __Pyx_PyCFunction_FastCall(__pyx_t_1, __pyx_temp+1-__pyx_t_8, 2+__pyx_t_8); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 62, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_GOTREF(__pyx_t_9); + } else + #endif + { + __pyx_t_11 = PyTuple_New(2+__pyx_t_8); if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 62, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_11); + if (__pyx_t_2) { + __Pyx_GIVEREF(__pyx_t_2); PyTuple_SET_ITEM(__pyx_t_11, 0, __pyx_t_2); __pyx_t_2 = NULL; + } + __Pyx_INCREF(((PyObject *)__pyx_v_self)); + __Pyx_GIVEREF(((PyObject *)__pyx_v_self)); + PyTuple_SET_ITEM(__pyx_t_11, 0+__pyx_t_8, ((PyObject *)__pyx_v_self)); + __Pyx_INCREF(__pyx_v_name); + __Pyx_GIVEREF(__pyx_v_name); + PyTuple_SET_ITEM(__pyx_t_11, 1+__pyx_t_8, __pyx_v_name); + __pyx_t_9 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_t_11, NULL); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 62, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_9); + __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0; + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_r = __pyx_t_9; + __pyx_t_9 = 0; + goto __pyx_L0; + + /* "asyncpg/protocol/settings.pyx":55 + * return self._data_codecs.get_codec(oid, format) + * + * def __getattr__(self, name): # <<<<<<<<<<<<<< + * if not name.startswith('_'): + * try: + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_9); + __Pyx_XDECREF(__pyx_t_10); + __Pyx_XDECREF(__pyx_t_11); + __Pyx_AddTraceback("asyncpg.protocol.protocol.ConnectionSettings.__getattr__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "asyncpg/protocol/buffer.pyx":20 + * cdef class Memory: + * + * cdef as_bytes(self): # <<<<<<<<<<<<<< + * return cpython.PyBytes_FromStringAndSize(self.buf, self.length) + * + */ + +static PyObject *__pyx_f_7asyncpg_8protocol_8protocol_6Memory_as_bytes(struct __pyx_obj_7asyncpg_8protocol_8protocol_Memory *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + __Pyx_RefNannySetupContext("as_bytes", 0); + + /* "asyncpg/protocol/buffer.pyx":21 + * + * cdef as_bytes(self): + * return cpython.PyBytes_FromStringAndSize(self.buf, self.length) # <<<<<<<<<<<<<< + * + * @staticmethod + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = PyBytes_FromStringAndSize(__pyx_v_self->buf, __pyx_v_self->length); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 21, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "asyncpg/protocol/buffer.pyx":20 + * cdef class Memory: + * + * cdef as_bytes(self): # <<<<<<<<<<<<<< + * return cpython.PyBytes_FromStringAndSize(self.buf, self.length) + * + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("asyncpg.protocol.protocol.Memory.as_bytes", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "asyncpg/protocol/buffer.pyx":24 + * + * @staticmethod + * cdef inline Memory new(char* buf, object owner, ssize_t length): # <<<<<<<<<<<<<< + * cdef Memory mem + * mem = Memory.__new__(Memory) + */ + +static CYTHON_INLINE struct __pyx_obj_7asyncpg_8protocol_8protocol_Memory *__pyx_f_7asyncpg_8protocol_8protocol_6Memory_new(char *__pyx_v_buf, PyObject *__pyx_v_owner, Py_ssize_t __pyx_v_length) { + struct __pyx_obj_7asyncpg_8protocol_8protocol_Memory *__pyx_v_mem = 0; + struct __pyx_obj_7asyncpg_8protocol_8protocol_Memory *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + __Pyx_RefNannySetupContext("new", 0); + + /* "asyncpg/protocol/buffer.pyx":26 + * cdef inline Memory new(char* buf, object owner, ssize_t length): + * cdef Memory mem + * mem = Memory.__new__(Memory) # <<<<<<<<<<<<<< + * mem.buf = buf + * mem.owner = owner + */ + __pyx_t_1 = __pyx_tp_new_7asyncpg_8protocol_8protocol_Memory(((PyTypeObject *)__pyx_ptype_7asyncpg_8protocol_8protocol_Memory), __pyx_empty_tuple, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 26, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (!(likely(__Pyx_TypeTest(__pyx_t_1, __pyx_ptype_7asyncpg_8protocol_8protocol_Memory)))) __PYX_ERR(1, 26, __pyx_L1_error) + __pyx_v_mem = ((struct __pyx_obj_7asyncpg_8protocol_8protocol_Memory *)__pyx_t_1); + __pyx_t_1 = 0; + + /* "asyncpg/protocol/buffer.pyx":27 + * cdef Memory mem + * mem = Memory.__new__(Memory) + * mem.buf = buf # <<<<<<<<<<<<<< + * mem.owner = owner + * mem.length = length + */ + __pyx_v_mem->buf = __pyx_v_buf; + + /* "asyncpg/protocol/buffer.pyx":28 + * mem = Memory.__new__(Memory) + * mem.buf = buf + * mem.owner = owner # <<<<<<<<<<<<<< + * mem.length = length + * return mem + */ + __Pyx_INCREF(__pyx_v_owner); + __Pyx_GIVEREF(__pyx_v_owner); + __Pyx_GOTREF(__pyx_v_mem->owner); + __Pyx_DECREF(__pyx_v_mem->owner); + __pyx_v_mem->owner = __pyx_v_owner; + + /* "asyncpg/protocol/buffer.pyx":29 + * mem.buf = buf + * mem.owner = owner + * mem.length = length # <<<<<<<<<<<<<< + * return mem + * + */ + __pyx_v_mem->length = __pyx_v_length; + + /* "asyncpg/protocol/buffer.pyx":30 + * mem.owner = owner + * mem.length = length + * return mem # <<<<<<<<<<<<<< + * + * + */ + __Pyx_XDECREF(((PyObject *)__pyx_r)); + __Pyx_INCREF(((PyObject *)__pyx_v_mem)); + __pyx_r = __pyx_v_mem; + goto __pyx_L0; + + /* "asyncpg/protocol/buffer.pyx":24 + * + * @staticmethod + * cdef inline Memory new(char* buf, object owner, ssize_t length): # <<<<<<<<<<<<<< + * cdef Memory mem + * mem = Memory.__new__(Memory) + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("asyncpg.protocol.protocol.Memory.new", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XDECREF((PyObject *)__pyx_v_mem); + __Pyx_XGIVEREF((PyObject *)__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "asyncpg/protocol/buffer.pyx":38 + * cdef class WriteBuffer: + * + * def __cinit__(self): # <<<<<<<<<<<<<< + * self._smallbuf_inuse = True + * self._buf = self._smallbuf + */ + +/* Python wrapper */ +static int __pyx_pw_7asyncpg_8protocol_8protocol_11WriteBuffer_1__cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ +static int __pyx_pw_7asyncpg_8protocol_8protocol_11WriteBuffer_1__cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__cinit__ (wrapper)", 0); + if (unlikely(PyTuple_GET_SIZE(__pyx_args) > 0)) { + __Pyx_RaiseArgtupleInvalid("__cinit__", 1, 0, 0, PyTuple_GET_SIZE(__pyx_args)); return -1;} + if (unlikely(__pyx_kwds) && unlikely(PyDict_Size(__pyx_kwds) > 0) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "__cinit__", 0))) return -1; + __pyx_r = __pyx_pf_7asyncpg_8protocol_8protocol_11WriteBuffer___cinit__(((struct __pyx_obj_7asyncpg_8protocol_8protocol_WriteBuffer *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_7asyncpg_8protocol_8protocol_11WriteBuffer___cinit__(struct __pyx_obj_7asyncpg_8protocol_8protocol_WriteBuffer *__pyx_v_self) { + int __pyx_r; + __Pyx_RefNannyDeclarations + char *__pyx_t_1; + __Pyx_RefNannySetupContext("__cinit__", 0); + + /* "asyncpg/protocol/buffer.pyx":39 + * + * def __cinit__(self): + * self._smallbuf_inuse = True # <<<<<<<<<<<<<< + * self._buf = self._smallbuf + * self._size = _BUFFER_INITIAL_SIZE + */ + __pyx_v_self->_smallbuf_inuse = 1; + + /* "asyncpg/protocol/buffer.pyx":40 + * def __cinit__(self): + * self._smallbuf_inuse = True + * self._buf = self._smallbuf # <<<<<<<<<<<<<< + * self._size = _BUFFER_INITIAL_SIZE + * self._length = 0 + */ + __pyx_t_1 = __pyx_v_self->_smallbuf; + __pyx_v_self->_buf = __pyx_t_1; + + /* "asyncpg/protocol/buffer.pyx":41 + * self._smallbuf_inuse = True + * self._buf = self._smallbuf + * self._size = _BUFFER_INITIAL_SIZE # <<<<<<<<<<<<<< + * self._length = 0 + * self._message_mode = 0 + */ + __pyx_v_self->_size = 0x400; + + /* "asyncpg/protocol/buffer.pyx":42 + * self._buf = self._smallbuf + * self._size = _BUFFER_INITIAL_SIZE + * self._length = 0 # <<<<<<<<<<<<<< + * self._message_mode = 0 + * + */ + __pyx_v_self->_length = 0; + + /* "asyncpg/protocol/buffer.pyx":43 + * self._size = _BUFFER_INITIAL_SIZE + * self._length = 0 + * self._message_mode = 0 # <<<<<<<<<<<<<< + * + * def __dealloc__(self): + */ + __pyx_v_self->_message_mode = 0; + + /* "asyncpg/protocol/buffer.pyx":38 + * cdef class WriteBuffer: + * + * def __cinit__(self): # <<<<<<<<<<<<<< + * self._smallbuf_inuse = True + * self._buf = self._smallbuf + */ + + /* function exit code */ + __pyx_r = 0; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "asyncpg/protocol/buffer.pyx":45 + * self._message_mode = 0 + * + * def __dealloc__(self): # <<<<<<<<<<<<<< + * if self._buf is not NULL and not self._smallbuf_inuse: + * PyMem_Free(self._buf) + */ + +/* Python wrapper */ +static void __pyx_pw_7asyncpg_8protocol_8protocol_11WriteBuffer_3__dealloc__(PyObject *__pyx_v_self); /*proto*/ +static void __pyx_pw_7asyncpg_8protocol_8protocol_11WriteBuffer_3__dealloc__(PyObject *__pyx_v_self) { + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__dealloc__ (wrapper)", 0); + __pyx_pf_7asyncpg_8protocol_8protocol_11WriteBuffer_2__dealloc__(((struct __pyx_obj_7asyncpg_8protocol_8protocol_WriteBuffer *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); +} + +static void __pyx_pf_7asyncpg_8protocol_8protocol_11WriteBuffer_2__dealloc__(struct __pyx_obj_7asyncpg_8protocol_8protocol_WriteBuffer *__pyx_v_self) { + __Pyx_RefNannyDeclarations + int __pyx_t_1; + int __pyx_t_2; + PyObject *__pyx_t_3 = NULL; + __Pyx_RefNannySetupContext("__dealloc__", 0); + + /* "asyncpg/protocol/buffer.pyx":46 + * + * def __dealloc__(self): + * if self._buf is not NULL and not self._smallbuf_inuse: # <<<<<<<<<<<<<< + * PyMem_Free(self._buf) + * self._buf = NULL + */ + __pyx_t_2 = ((__pyx_v_self->_buf != NULL) != 0); + if (__pyx_t_2) { + } else { + __pyx_t_1 = __pyx_t_2; + goto __pyx_L4_bool_binop_done; + } + __pyx_t_2 = ((!(__pyx_v_self->_smallbuf_inuse != 0)) != 0); + __pyx_t_1 = __pyx_t_2; + __pyx_L4_bool_binop_done:; + if (__pyx_t_1) { + + /* "asyncpg/protocol/buffer.pyx":47 + * def __dealloc__(self): + * if self._buf is not NULL and not self._smallbuf_inuse: + * PyMem_Free(self._buf) # <<<<<<<<<<<<<< + * self._buf = NULL + * self._size = 0 + */ + PyMem_Free(__pyx_v_self->_buf); + + /* "asyncpg/protocol/buffer.pyx":48 + * if self._buf is not NULL and not self._smallbuf_inuse: + * PyMem_Free(self._buf) + * self._buf = NULL # <<<<<<<<<<<<<< + * self._size = 0 + * + */ + __pyx_v_self->_buf = NULL; + + /* "asyncpg/protocol/buffer.pyx":49 + * PyMem_Free(self._buf) + * self._buf = NULL + * self._size = 0 # <<<<<<<<<<<<<< + * + * if self._view_count: + */ + __pyx_v_self->_size = 0; + + /* "asyncpg/protocol/buffer.pyx":46 + * + * def __dealloc__(self): + * if self._buf is not NULL and not self._smallbuf_inuse: # <<<<<<<<<<<<<< + * PyMem_Free(self._buf) + * self._buf = NULL + */ + } + + /* "asyncpg/protocol/buffer.pyx":51 + * self._size = 0 + * + * if self._view_count: # <<<<<<<<<<<<<< + * raise RuntimeError( + * 'Deallocating buffer with attached memoryviews') + */ + __pyx_t_1 = (__pyx_v_self->_view_count != 0); + if (__pyx_t_1) { + + /* "asyncpg/protocol/buffer.pyx":52 + * + * if self._view_count: + * raise RuntimeError( # <<<<<<<<<<<<<< + * 'Deallocating buffer with attached memoryviews') + * + */ + __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_RuntimeError, __pyx_tuple__5, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 52, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_Raise(__pyx_t_3, 0, 0, 0); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __PYX_ERR(1, 52, __pyx_L1_error) + + /* "asyncpg/protocol/buffer.pyx":51 + * self._size = 0 + * + * if self._view_count: # <<<<<<<<<<<<<< + * raise RuntimeError( + * 'Deallocating buffer with attached memoryviews') + */ + } + + /* "asyncpg/protocol/buffer.pyx":45 + * self._message_mode = 0 + * + * def __dealloc__(self): # <<<<<<<<<<<<<< + * if self._buf is not NULL and not self._smallbuf_inuse: + * PyMem_Free(self._buf) + */ + + /* function exit code */ + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_3); + __Pyx_WriteUnraisable("asyncpg.protocol.protocol.WriteBuffer.__dealloc__", __pyx_clineno, __pyx_lineno, __pyx_filename, 0, 0); + __pyx_L0:; + __Pyx_RefNannyFinishContext(); +} + +/* "asyncpg/protocol/buffer.pyx":55 + * 'Deallocating buffer with attached memoryviews') + * + * def __getbuffer__(self, Py_buffer *buffer, int flags): # <<<<<<<<<<<<<< + * self._view_count += 1 + * + */ + +/* Python wrapper */ +static CYTHON_UNUSED int __pyx_pw_7asyncpg_8protocol_8protocol_11WriteBuffer_5__getbuffer__(PyObject *__pyx_v_self, Py_buffer *__pyx_v_buffer, int __pyx_v_flags); /*proto*/ +static CYTHON_UNUSED int __pyx_pw_7asyncpg_8protocol_8protocol_11WriteBuffer_5__getbuffer__(PyObject *__pyx_v_self, Py_buffer *__pyx_v_buffer, int __pyx_v_flags) { + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__getbuffer__ (wrapper)", 0); + __pyx_r = __pyx_pf_7asyncpg_8protocol_8protocol_11WriteBuffer_4__getbuffer__(((struct __pyx_obj_7asyncpg_8protocol_8protocol_WriteBuffer *)__pyx_v_self), ((Py_buffer *)__pyx_v_buffer), ((int)__pyx_v_flags)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_7asyncpg_8protocol_8protocol_11WriteBuffer_4__getbuffer__(struct __pyx_obj_7asyncpg_8protocol_8protocol_WriteBuffer *__pyx_v_self, Py_buffer *__pyx_v_buffer, int __pyx_v_flags) { + int __pyx_r; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + __Pyx_RefNannySetupContext("__getbuffer__", 0); + if (__pyx_v_buffer != NULL) { + __pyx_v_buffer->obj = Py_None; __Pyx_INCREF(Py_None); + __Pyx_GIVEREF(__pyx_v_buffer->obj); + } + + /* "asyncpg/protocol/buffer.pyx":56 + * + * def __getbuffer__(self, Py_buffer *buffer, int flags): + * self._view_count += 1 # <<<<<<<<<<<<<< + * + * PyBuffer_FillInfo( + */ + __pyx_v_self->_view_count = (__pyx_v_self->_view_count + 1); + + /* "asyncpg/protocol/buffer.pyx":58 + * self._view_count += 1 + * + * PyBuffer_FillInfo( # <<<<<<<<<<<<<< + * buffer, self, self._buf, self._length, + * 1, # read-only + */ + __pyx_t_1 = PyBuffer_FillInfo(__pyx_v_buffer, ((PyObject *)__pyx_v_self), __pyx_v_self->_buf, __pyx_v_self->_length, 1, __pyx_v_flags); if (unlikely(__pyx_t_1 == -1)) __PYX_ERR(1, 58, __pyx_L1_error) + + /* "asyncpg/protocol/buffer.pyx":55 + * 'Deallocating buffer with attached memoryviews') + * + * def __getbuffer__(self, Py_buffer *buffer, int flags): # <<<<<<<<<<<<<< + * self._view_count += 1 + * + */ + + /* function exit code */ + __pyx_r = 0; + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_AddTraceback("asyncpg.protocol.protocol.WriteBuffer.__getbuffer__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = -1; + if (__pyx_v_buffer != NULL && __pyx_v_buffer->obj != NULL) { + __Pyx_GOTREF(__pyx_v_buffer->obj); + __Pyx_DECREF(__pyx_v_buffer->obj); __pyx_v_buffer->obj = NULL; + } + goto __pyx_L2; + __pyx_L0:; + if (__pyx_v_buffer != NULL && __pyx_v_buffer->obj == Py_None) { + __Pyx_GOTREF(Py_None); + __Pyx_DECREF(Py_None); __pyx_v_buffer->obj = NULL; + } + __pyx_L2:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "asyncpg/protocol/buffer.pyx":63 + * flags) + * + * def __releasebuffer__(self, Py_buffer *buffer): # <<<<<<<<<<<<<< + * self._view_count -= 1 + * + */ + +/* Python wrapper */ +static CYTHON_UNUSED void __pyx_pw_7asyncpg_8protocol_8protocol_11WriteBuffer_7__releasebuffer__(PyObject *__pyx_v_self, Py_buffer *__pyx_v_buffer); /*proto*/ +static CYTHON_UNUSED void __pyx_pw_7asyncpg_8protocol_8protocol_11WriteBuffer_7__releasebuffer__(PyObject *__pyx_v_self, Py_buffer *__pyx_v_buffer) { + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__releasebuffer__ (wrapper)", 0); + __pyx_pf_7asyncpg_8protocol_8protocol_11WriteBuffer_6__releasebuffer__(((struct __pyx_obj_7asyncpg_8protocol_8protocol_WriteBuffer *)__pyx_v_self), ((Py_buffer *)__pyx_v_buffer)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); +} + +static void __pyx_pf_7asyncpg_8protocol_8protocol_11WriteBuffer_6__releasebuffer__(struct __pyx_obj_7asyncpg_8protocol_8protocol_WriteBuffer *__pyx_v_self, CYTHON_UNUSED Py_buffer *__pyx_v_buffer) { + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__releasebuffer__", 0); + + /* "asyncpg/protocol/buffer.pyx":64 + * + * def __releasebuffer__(self, Py_buffer *buffer): + * self._view_count -= 1 # <<<<<<<<<<<<<< + * + * cdef inline _check_readonly(self): + */ + __pyx_v_self->_view_count = (__pyx_v_self->_view_count - 1); + + /* "asyncpg/protocol/buffer.pyx":63 + * flags) + * + * def __releasebuffer__(self, Py_buffer *buffer): # <<<<<<<<<<<<<< + * self._view_count -= 1 + * + */ + + /* function exit code */ + __Pyx_RefNannyFinishContext(); +} + +/* "asyncpg/protocol/buffer.pyx":66 + * self._view_count -= 1 + * + * cdef inline _check_readonly(self): # <<<<<<<<<<<<<< + * if self._view_count: + * raise BufferError('the buffer is in read-only mode') + */ + +static CYTHON_INLINE PyObject *__pyx_f_7asyncpg_8protocol_8protocol_11WriteBuffer__check_readonly(struct __pyx_obj_7asyncpg_8protocol_8protocol_WriteBuffer *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + __Pyx_RefNannySetupContext("_check_readonly", 0); + + /* "asyncpg/protocol/buffer.pyx":67 + * + * cdef inline _check_readonly(self): + * if self._view_count: # <<<<<<<<<<<<<< + * raise BufferError('the buffer is in read-only mode') + * + */ + __pyx_t_1 = (__pyx_v_self->_view_count != 0); + if (__pyx_t_1) { + + /* "asyncpg/protocol/buffer.pyx":68 + * cdef inline _check_readonly(self): + * if self._view_count: + * raise BufferError('the buffer is in read-only mode') # <<<<<<<<<<<<<< + * + * cdef inline len(self): + */ + __pyx_t_2 = __Pyx_GetModuleGlobalName(__pyx_n_s_BufferError); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 68, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_tuple__6, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 68, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_Raise(__pyx_t_3, 0, 0, 0); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __PYX_ERR(1, 68, __pyx_L1_error) + + /* "asyncpg/protocol/buffer.pyx":67 + * + * cdef inline _check_readonly(self): + * if self._view_count: # <<<<<<<<<<<<<< + * raise BufferError('the buffer is in read-only mode') + * + */ + } + + /* "asyncpg/protocol/buffer.pyx":66 + * self._view_count -= 1 + * + * cdef inline _check_readonly(self): # <<<<<<<<<<<<<< + * if self._view_count: + * raise BufferError('the buffer is in read-only mode') + */ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_AddTraceback("asyncpg.protocol.protocol.WriteBuffer._check_readonly", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "asyncpg/protocol/buffer.pyx":70 + * raise BufferError('the buffer is in read-only mode') + * + * cdef inline len(self): # <<<<<<<<<<<<<< + * return self._length + * + */ + +static CYTHON_INLINE PyObject *__pyx_f_7asyncpg_8protocol_8protocol_11WriteBuffer_len(struct __pyx_obj_7asyncpg_8protocol_8protocol_WriteBuffer *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + __Pyx_RefNannySetupContext("len", 0); + + /* "asyncpg/protocol/buffer.pyx":71 + * + * cdef inline len(self): + * return self._length # <<<<<<<<<<<<<< + * + * cdef inline _ensure_alloced(self, ssize_t extra_length): + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = PyInt_FromSsize_t(__pyx_v_self->_length); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 71, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "asyncpg/protocol/buffer.pyx":70 + * raise BufferError('the buffer is in read-only mode') + * + * cdef inline len(self): # <<<<<<<<<<<<<< + * return self._length + * + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("asyncpg.protocol.protocol.WriteBuffer.len", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "asyncpg/protocol/buffer.pyx":73 + * return self._length + * + * cdef inline _ensure_alloced(self, ssize_t extra_length): # <<<<<<<<<<<<<< + * cdef ssize_t new_size = extra_length + self._length + * + */ + +static CYTHON_INLINE PyObject *__pyx_f_7asyncpg_8protocol_8protocol_11WriteBuffer__ensure_alloced(struct __pyx_obj_7asyncpg_8protocol_8protocol_WriteBuffer *__pyx_v_self, Py_ssize_t __pyx_v_extra_length) { + Py_ssize_t __pyx_v_new_size; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + PyObject *__pyx_t_2 = NULL; + __Pyx_RefNannySetupContext("_ensure_alloced", 0); + + /* "asyncpg/protocol/buffer.pyx":74 + * + * cdef inline _ensure_alloced(self, ssize_t extra_length): + * cdef ssize_t new_size = extra_length + self._length # <<<<<<<<<<<<<< + * + * if new_size > self._size: + */ + __pyx_v_new_size = (__pyx_v_extra_length + __pyx_v_self->_length); + + /* "asyncpg/protocol/buffer.pyx":76 + * cdef ssize_t new_size = extra_length + self._length + * + * if new_size > self._size: # <<<<<<<<<<<<<< + * self._reallocate(new_size) + * + */ + __pyx_t_1 = ((__pyx_v_new_size > __pyx_v_self->_size) != 0); + if (__pyx_t_1) { + + /* "asyncpg/protocol/buffer.pyx":77 + * + * if new_size > self._size: + * self._reallocate(new_size) # <<<<<<<<<<<<<< + * + * cdef _reallocate(self, ssize_t new_size): + */ + __pyx_t_2 = __pyx_f_7asyncpg_8protocol_8protocol_11WriteBuffer__reallocate(__pyx_v_self, __pyx_v_new_size); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 77, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "asyncpg/protocol/buffer.pyx":76 + * cdef ssize_t new_size = extra_length + self._length + * + * if new_size > self._size: # <<<<<<<<<<<<<< + * self._reallocate(new_size) + * + */ + } + + /* "asyncpg/protocol/buffer.pyx":73 + * return self._length + * + * cdef inline _ensure_alloced(self, ssize_t extra_length): # <<<<<<<<<<<<<< + * cdef ssize_t new_size = extra_length + self._length + * + */ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_2); + __Pyx_AddTraceback("asyncpg.protocol.protocol.WriteBuffer._ensure_alloced", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "asyncpg/protocol/buffer.pyx":79 + * self._reallocate(new_size) + * + * cdef _reallocate(self, ssize_t new_size): # <<<<<<<<<<<<<< + * cdef char *new_buf + * + */ + +static PyObject *__pyx_f_7asyncpg_8protocol_8protocol_11WriteBuffer__reallocate(struct __pyx_obj_7asyncpg_8protocol_8protocol_WriteBuffer *__pyx_v_self, Py_ssize_t __pyx_v_new_size) { + char *__pyx_v_new_buf; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + __Pyx_RefNannySetupContext("_reallocate", 0); + + /* "asyncpg/protocol/buffer.pyx":82 + * cdef char *new_buf + * + * if new_size < _BUFFER_MAX_GROW: # <<<<<<<<<<<<<< + * new_size = _BUFFER_MAX_GROW + * else: + */ + __pyx_t_1 = ((__pyx_v_new_size < 0x10000) != 0); + if (__pyx_t_1) { + + /* "asyncpg/protocol/buffer.pyx":83 + * + * if new_size < _BUFFER_MAX_GROW: + * new_size = _BUFFER_MAX_GROW # <<<<<<<<<<<<<< + * else: + * # Add a little extra + */ + __pyx_v_new_size = 0x10000; + + /* "asyncpg/protocol/buffer.pyx":82 + * cdef char *new_buf + * + * if new_size < _BUFFER_MAX_GROW: # <<<<<<<<<<<<<< + * new_size = _BUFFER_MAX_GROW + * else: + */ + goto __pyx_L3; + } + + /* "asyncpg/protocol/buffer.pyx":86 + * else: + * # Add a little extra + * new_size += _BUFFER_INITIAL_SIZE # <<<<<<<<<<<<<< + * + * if self._smallbuf_inuse: + */ + /*else*/ { + __pyx_v_new_size = (__pyx_v_new_size + 0x400); + } + __pyx_L3:; + + /* "asyncpg/protocol/buffer.pyx":88 + * new_size += _BUFFER_INITIAL_SIZE + * + * if self._smallbuf_inuse: # <<<<<<<<<<<<<< + * new_buf = PyMem_Malloc(sizeof(char) * new_size) + * if new_buf is NULL: + */ + __pyx_t_1 = (__pyx_v_self->_smallbuf_inuse != 0); + if (__pyx_t_1) { + + /* "asyncpg/protocol/buffer.pyx":89 + * + * if self._smallbuf_inuse: + * new_buf = PyMem_Malloc(sizeof(char) * new_size) # <<<<<<<<<<<<<< + * if new_buf is NULL: + * self._buf = NULL + */ + __pyx_v_new_buf = ((char *)PyMem_Malloc(((sizeof(char)) * ((size_t)__pyx_v_new_size)))); + + /* "asyncpg/protocol/buffer.pyx":90 + * if self._smallbuf_inuse: + * new_buf = PyMem_Malloc(sizeof(char) * new_size) + * if new_buf is NULL: # <<<<<<<<<<<<<< + * self._buf = NULL + * self._size = 0 + */ + __pyx_t_1 = ((__pyx_v_new_buf == NULL) != 0); + if (__pyx_t_1) { + + /* "asyncpg/protocol/buffer.pyx":91 + * new_buf = PyMem_Malloc(sizeof(char) * new_size) + * if new_buf is NULL: + * self._buf = NULL # <<<<<<<<<<<<<< + * self._size = 0 + * self._length = 0 + */ + __pyx_v_self->_buf = NULL; + + /* "asyncpg/protocol/buffer.pyx":92 + * if new_buf is NULL: + * self._buf = NULL + * self._size = 0 # <<<<<<<<<<<<<< + * self._length = 0 + * raise MemoryError + */ + __pyx_v_self->_size = 0; + + /* "asyncpg/protocol/buffer.pyx":93 + * self._buf = NULL + * self._size = 0 + * self._length = 0 # <<<<<<<<<<<<<< + * raise MemoryError + * memcpy(new_buf, self._buf, self._size) + */ + __pyx_v_self->_length = 0; + + /* "asyncpg/protocol/buffer.pyx":94 + * self._size = 0 + * self._length = 0 + * raise MemoryError # <<<<<<<<<<<<<< + * memcpy(new_buf, self._buf, self._size) + * self._size = new_size + */ + PyErr_NoMemory(); __PYX_ERR(1, 94, __pyx_L1_error) + + /* "asyncpg/protocol/buffer.pyx":90 + * if self._smallbuf_inuse: + * new_buf = PyMem_Malloc(sizeof(char) * new_size) + * if new_buf is NULL: # <<<<<<<<<<<<<< + * self._buf = NULL + * self._size = 0 + */ + } + + /* "asyncpg/protocol/buffer.pyx":95 + * self._length = 0 + * raise MemoryError + * memcpy(new_buf, self._buf, self._size) # <<<<<<<<<<<<<< + * self._size = new_size + * self._buf = new_buf + */ + memcpy(__pyx_v_new_buf, __pyx_v_self->_buf, ((size_t)__pyx_v_self->_size)); + + /* "asyncpg/protocol/buffer.pyx":96 + * raise MemoryError + * memcpy(new_buf, self._buf, self._size) + * self._size = new_size # <<<<<<<<<<<<<< + * self._buf = new_buf + * self._smallbuf_inuse = False + */ + __pyx_v_self->_size = __pyx_v_new_size; + + /* "asyncpg/protocol/buffer.pyx":97 + * memcpy(new_buf, self._buf, self._size) + * self._size = new_size + * self._buf = new_buf # <<<<<<<<<<<<<< + * self._smallbuf_inuse = False + * else: + */ + __pyx_v_self->_buf = __pyx_v_new_buf; + + /* "asyncpg/protocol/buffer.pyx":98 + * self._size = new_size + * self._buf = new_buf + * self._smallbuf_inuse = False # <<<<<<<<<<<<<< + * else: + * new_buf = PyMem_Realloc(self._buf, new_size) + */ + __pyx_v_self->_smallbuf_inuse = 0; + + /* "asyncpg/protocol/buffer.pyx":88 + * new_size += _BUFFER_INITIAL_SIZE + * + * if self._smallbuf_inuse: # <<<<<<<<<<<<<< + * new_buf = PyMem_Malloc(sizeof(char) * new_size) + * if new_buf is NULL: + */ + goto __pyx_L4; + } + + /* "asyncpg/protocol/buffer.pyx":100 + * self._smallbuf_inuse = False + * else: + * new_buf = PyMem_Realloc(self._buf, new_size) # <<<<<<<<<<<<<< + * if new_buf is NULL: + * PyMem_Free(self._buf) + */ + /*else*/ { + __pyx_v_new_buf = ((char *)PyMem_Realloc(((void *)__pyx_v_self->_buf), ((size_t)__pyx_v_new_size))); + + /* "asyncpg/protocol/buffer.pyx":101 + * else: + * new_buf = PyMem_Realloc(self._buf, new_size) + * if new_buf is NULL: # <<<<<<<<<<<<<< + * PyMem_Free(self._buf) + * self._buf = NULL + */ + __pyx_t_1 = ((__pyx_v_new_buf == NULL) != 0); + if (__pyx_t_1) { + + /* "asyncpg/protocol/buffer.pyx":102 + * new_buf = PyMem_Realloc(self._buf, new_size) + * if new_buf is NULL: + * PyMem_Free(self._buf) # <<<<<<<<<<<<<< + * self._buf = NULL + * self._size = 0 + */ + PyMem_Free(__pyx_v_self->_buf); + + /* "asyncpg/protocol/buffer.pyx":103 + * if new_buf is NULL: + * PyMem_Free(self._buf) + * self._buf = NULL # <<<<<<<<<<<<<< + * self._size = 0 + * self._length = 0 + */ + __pyx_v_self->_buf = NULL; + + /* "asyncpg/protocol/buffer.pyx":104 + * PyMem_Free(self._buf) + * self._buf = NULL + * self._size = 0 # <<<<<<<<<<<<<< + * self._length = 0 + * raise MemoryError + */ + __pyx_v_self->_size = 0; + + /* "asyncpg/protocol/buffer.pyx":105 + * self._buf = NULL + * self._size = 0 + * self._length = 0 # <<<<<<<<<<<<<< + * raise MemoryError + * self._buf = new_buf + */ + __pyx_v_self->_length = 0; + + /* "asyncpg/protocol/buffer.pyx":106 + * self._size = 0 + * self._length = 0 + * raise MemoryError # <<<<<<<<<<<<<< + * self._buf = new_buf + * self._size = new_size + */ + PyErr_NoMemory(); __PYX_ERR(1, 106, __pyx_L1_error) + + /* "asyncpg/protocol/buffer.pyx":101 + * else: + * new_buf = PyMem_Realloc(self._buf, new_size) + * if new_buf is NULL: # <<<<<<<<<<<<<< + * PyMem_Free(self._buf) + * self._buf = NULL + */ + } + + /* "asyncpg/protocol/buffer.pyx":107 + * self._length = 0 + * raise MemoryError + * self._buf = new_buf # <<<<<<<<<<<<<< + * self._size = new_size + * + */ + __pyx_v_self->_buf = __pyx_v_new_buf; + + /* "asyncpg/protocol/buffer.pyx":108 + * raise MemoryError + * self._buf = new_buf + * self._size = new_size # <<<<<<<<<<<<<< + * + * cdef inline start_message(self, char type): + */ + __pyx_v_self->_size = __pyx_v_new_size; + } + __pyx_L4:; + + /* "asyncpg/protocol/buffer.pyx":79 + * self._reallocate(new_size) + * + * cdef _reallocate(self, ssize_t new_size): # <<<<<<<<<<<<<< + * cdef char *new_buf + * + */ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_AddTraceback("asyncpg.protocol.protocol.WriteBuffer._reallocate", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "asyncpg/protocol/buffer.pyx":110 + * self._size = new_size + * + * cdef inline start_message(self, char type): # <<<<<<<<<<<<<< + * if self._length != 0: + * raise BufferError('cannot start_message for a non-empty buffer') + */ + +static CYTHON_INLINE PyObject *__pyx_f_7asyncpg_8protocol_8protocol_11WriteBuffer_start_message(struct __pyx_obj_7asyncpg_8protocol_8protocol_WriteBuffer *__pyx_v_self, char __pyx_v_type) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + __Pyx_RefNannySetupContext("start_message", 0); + + /* "asyncpg/protocol/buffer.pyx":111 + * + * cdef inline start_message(self, char type): + * if self._length != 0: # <<<<<<<<<<<<<< + * raise BufferError('cannot start_message for a non-empty buffer') + * self._ensure_alloced(5) + */ + __pyx_t_1 = ((__pyx_v_self->_length != 0) != 0); + if (__pyx_t_1) { + + /* "asyncpg/protocol/buffer.pyx":112 + * cdef inline start_message(self, char type): + * if self._length != 0: + * raise BufferError('cannot start_message for a non-empty buffer') # <<<<<<<<<<<<<< + * self._ensure_alloced(5) + * self._message_mode = 1 + */ + __pyx_t_2 = __Pyx_GetModuleGlobalName(__pyx_n_s_BufferError); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 112, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_tuple__7, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 112, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_Raise(__pyx_t_3, 0, 0, 0); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __PYX_ERR(1, 112, __pyx_L1_error) + + /* "asyncpg/protocol/buffer.pyx":111 + * + * cdef inline start_message(self, char type): + * if self._length != 0: # <<<<<<<<<<<<<< + * raise BufferError('cannot start_message for a non-empty buffer') + * self._ensure_alloced(5) + */ + } + + /* "asyncpg/protocol/buffer.pyx":113 + * if self._length != 0: + * raise BufferError('cannot start_message for a non-empty buffer') + * self._ensure_alloced(5) # <<<<<<<<<<<<<< + * self._message_mode = 1 + * self._buf[0] = type + */ + __pyx_t_3 = __pyx_f_7asyncpg_8protocol_8protocol_11WriteBuffer__ensure_alloced(__pyx_v_self, 5); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 113, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + + /* "asyncpg/protocol/buffer.pyx":114 + * raise BufferError('cannot start_message for a non-empty buffer') + * self._ensure_alloced(5) + * self._message_mode = 1 # <<<<<<<<<<<<<< + * self._buf[0] = type + * self._length = 5 + */ + __pyx_v_self->_message_mode = 1; + + /* "asyncpg/protocol/buffer.pyx":115 + * self._ensure_alloced(5) + * self._message_mode = 1 + * self._buf[0] = type # <<<<<<<<<<<<<< + * self._length = 5 + * + */ + (__pyx_v_self->_buf[0]) = __pyx_v_type; + + /* "asyncpg/protocol/buffer.pyx":116 + * self._message_mode = 1 + * self._buf[0] = type + * self._length = 5 # <<<<<<<<<<<<<< + * + * cdef inline end_message(self): + */ + __pyx_v_self->_length = 5; + + /* "asyncpg/protocol/buffer.pyx":110 + * self._size = new_size + * + * cdef inline start_message(self, char type): # <<<<<<<<<<<<<< + * if self._length != 0: + * raise BufferError('cannot start_message for a non-empty buffer') + */ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_AddTraceback("asyncpg.protocol.protocol.WriteBuffer.start_message", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "asyncpg/protocol/buffer.pyx":118 + * self._length = 5 + * + * cdef inline end_message(self): # <<<<<<<<<<<<<< + * # "length-1" to exclude the message type byte + * cdef ssize_t mlen = self._length - 1 + */ + +static CYTHON_INLINE PyObject *__pyx_f_7asyncpg_8protocol_8protocol_11WriteBuffer_end_message(struct __pyx_obj_7asyncpg_8protocol_8protocol_WriteBuffer *__pyx_v_self) { + Py_ssize_t __pyx_v_mlen; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_t_2; + PyObject *__pyx_t_3 = NULL; + __Pyx_RefNannySetupContext("end_message", 0); + + /* "asyncpg/protocol/buffer.pyx":120 + * cdef inline end_message(self): + * # "length-1" to exclude the message type byte + * cdef ssize_t mlen = self._length - 1 # <<<<<<<<<<<<<< + * + * self._check_readonly() + */ + __pyx_v_mlen = (__pyx_v_self->_length - 1); + + /* "asyncpg/protocol/buffer.pyx":122 + * cdef ssize_t mlen = self._length - 1 + * + * self._check_readonly() # <<<<<<<<<<<<<< + * if not self._message_mode: + * raise BufferError( + */ + __pyx_t_1 = __pyx_f_7asyncpg_8protocol_8protocol_11WriteBuffer__check_readonly(__pyx_v_self); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 122, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "asyncpg/protocol/buffer.pyx":123 + * + * self._check_readonly() + * if not self._message_mode: # <<<<<<<<<<<<<< + * raise BufferError( + * 'end_message can only be called with start_message') + */ + __pyx_t_2 = ((!(__pyx_v_self->_message_mode != 0)) != 0); + if (__pyx_t_2) { + + /* "asyncpg/protocol/buffer.pyx":124 + * self._check_readonly() + * if not self._message_mode: + * raise BufferError( # <<<<<<<<<<<<<< + * 'end_message can only be called with start_message') + * if self._length < 5: + */ + __pyx_t_1 = __Pyx_GetModuleGlobalName(__pyx_n_s_BufferError); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 124, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_tuple__8, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 124, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_Raise(__pyx_t_3, 0, 0, 0); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __PYX_ERR(1, 124, __pyx_L1_error) + + /* "asyncpg/protocol/buffer.pyx":123 + * + * self._check_readonly() + * if not self._message_mode: # <<<<<<<<<<<<<< + * raise BufferError( + * 'end_message can only be called with start_message') + */ + } + + /* "asyncpg/protocol/buffer.pyx":126 + * raise BufferError( + * 'end_message can only be called with start_message') + * if self._length < 5: # <<<<<<<<<<<<<< + * raise BufferError('end_message: buffer is too small') + * if mlen > _MAXINT32: + */ + __pyx_t_2 = ((__pyx_v_self->_length < 5) != 0); + if (__pyx_t_2) { + + /* "asyncpg/protocol/buffer.pyx":127 + * 'end_message can only be called with start_message') + * if self._length < 5: + * raise BufferError('end_message: buffer is too small') # <<<<<<<<<<<<<< + * if mlen > _MAXINT32: + * raise BufferError('end_message: message is too large') + */ + __pyx_t_3 = __Pyx_GetModuleGlobalName(__pyx_n_s_BufferError); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 127, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_tuple__9, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 127, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_Raise(__pyx_t_1, 0, 0, 0); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __PYX_ERR(1, 127, __pyx_L1_error) + + /* "asyncpg/protocol/buffer.pyx":126 + * raise BufferError( + * 'end_message can only be called with start_message') + * if self._length < 5: # <<<<<<<<<<<<<< + * raise BufferError('end_message: buffer is too small') + * if mlen > _MAXINT32: + */ + } + + /* "asyncpg/protocol/buffer.pyx":128 + * if self._length < 5: + * raise BufferError('end_message: buffer is too small') + * if mlen > _MAXINT32: # <<<<<<<<<<<<<< + * raise BufferError('end_message: message is too large') + * + */ + __pyx_t_2 = ((__pyx_v_mlen > 0x7FFFFFFF) != 0); + if (__pyx_t_2) { + + /* "asyncpg/protocol/buffer.pyx":129 + * raise BufferError('end_message: buffer is too small') + * if mlen > _MAXINT32: + * raise BufferError('end_message: message is too large') # <<<<<<<<<<<<<< + * + * hton.pack_int32(&self._buf[1], mlen) + */ + __pyx_t_1 = __Pyx_GetModuleGlobalName(__pyx_n_s_BufferError); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 129, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_tuple__10, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 129, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_Raise(__pyx_t_3, 0, 0, 0); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __PYX_ERR(1, 129, __pyx_L1_error) + + /* "asyncpg/protocol/buffer.pyx":128 + * if self._length < 5: + * raise BufferError('end_message: buffer is too small') + * if mlen > _MAXINT32: # <<<<<<<<<<<<<< + * raise BufferError('end_message: message is too large') + * + */ + } + + /* "asyncpg/protocol/buffer.pyx":131 + * raise BufferError('end_message: message is too large') + * + * hton.pack_int32(&self._buf[1], mlen) # <<<<<<<<<<<<<< + * return self + * + */ + __pyx_f_7asyncpg_8protocol_4hton_pack_int32((&(__pyx_v_self->_buf[1])), ((int32_t)__pyx_v_mlen)); + + /* "asyncpg/protocol/buffer.pyx":132 + * + * hton.pack_int32(&self._buf[1], mlen) + * return self # <<<<<<<<<<<<<< + * + * cdef write_buffer(self, WriteBuffer buf): + */ + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(((PyObject *)__pyx_v_self)); + __pyx_r = ((PyObject *)__pyx_v_self); + goto __pyx_L0; + + /* "asyncpg/protocol/buffer.pyx":118 + * self._length = 5 + * + * cdef inline end_message(self): # <<<<<<<<<<<<<< + * # "length-1" to exclude the message type byte + * cdef ssize_t mlen = self._length - 1 + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_AddTraceback("asyncpg.protocol.protocol.WriteBuffer.end_message", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "asyncpg/protocol/buffer.pyx":134 + * return self + * + * cdef write_buffer(self, WriteBuffer buf): # <<<<<<<<<<<<<< + * self._check_readonly() + * + */ + +static PyObject *__pyx_f_7asyncpg_8protocol_8protocol_11WriteBuffer_write_buffer(struct __pyx_obj_7asyncpg_8protocol_8protocol_WriteBuffer *__pyx_v_self, struct __pyx_obj_7asyncpg_8protocol_8protocol_WriteBuffer *__pyx_v_buf) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_t_2; + __Pyx_RefNannySetupContext("write_buffer", 0); + + /* "asyncpg/protocol/buffer.pyx":135 + * + * cdef write_buffer(self, WriteBuffer buf): + * self._check_readonly() # <<<<<<<<<<<<<< + * + * if not buf._length: + */ + __pyx_t_1 = __pyx_f_7asyncpg_8protocol_8protocol_11WriteBuffer__check_readonly(__pyx_v_self); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 135, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "asyncpg/protocol/buffer.pyx":137 + * self._check_readonly() + * + * if not buf._length: # <<<<<<<<<<<<<< + * return + * + */ + __pyx_t_2 = ((!(__pyx_v_buf->_length != 0)) != 0); + if (__pyx_t_2) { + + /* "asyncpg/protocol/buffer.pyx":138 + * + * if not buf._length: + * return # <<<<<<<<<<<<<< + * + * self._ensure_alloced(buf._length) + */ + __Pyx_XDECREF(__pyx_r); + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + + /* "asyncpg/protocol/buffer.pyx":137 + * self._check_readonly() + * + * if not buf._length: # <<<<<<<<<<<<<< + * return + * + */ + } + + /* "asyncpg/protocol/buffer.pyx":140 + * return + * + * self._ensure_alloced(buf._length) # <<<<<<<<<<<<<< + * memcpy(self._buf + self._length, + * buf._buf, + */ + __pyx_t_1 = __pyx_f_7asyncpg_8protocol_8protocol_11WriteBuffer__ensure_alloced(__pyx_v_self, __pyx_v_buf->_length); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 140, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "asyncpg/protocol/buffer.pyx":141 + * + * self._ensure_alloced(buf._length) + * memcpy(self._buf + self._length, # <<<<<<<<<<<<<< + * buf._buf, + * buf._length) + */ + memcpy((__pyx_v_self->_buf + __pyx_v_self->_length), ((void *)__pyx_v_buf->_buf), ((size_t)__pyx_v_buf->_length)); + + /* "asyncpg/protocol/buffer.pyx":144 + * buf._buf, + * buf._length) + * self._length += buf._length # <<<<<<<<<<<<<< + * + * cdef write_byte(self, char b): + */ + __pyx_v_self->_length = (__pyx_v_self->_length + __pyx_v_buf->_length); + + /* "asyncpg/protocol/buffer.pyx":134 + * return self + * + * cdef write_buffer(self, WriteBuffer buf): # <<<<<<<<<<<<<< + * self._check_readonly() + * + */ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("asyncpg.protocol.protocol.WriteBuffer.write_buffer", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "asyncpg/protocol/buffer.pyx":146 + * self._length += buf._length + * + * cdef write_byte(self, char b): # <<<<<<<<<<<<<< + * self._check_readonly() + * + */ + +static PyObject *__pyx_f_7asyncpg_8protocol_8protocol_11WriteBuffer_write_byte(struct __pyx_obj_7asyncpg_8protocol_8protocol_WriteBuffer *__pyx_v_self, char __pyx_v_b) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + __Pyx_RefNannySetupContext("write_byte", 0); + + /* "asyncpg/protocol/buffer.pyx":147 + * + * cdef write_byte(self, char b): + * self._check_readonly() # <<<<<<<<<<<<<< + * + * self._ensure_alloced(1) + */ + __pyx_t_1 = __pyx_f_7asyncpg_8protocol_8protocol_11WriteBuffer__check_readonly(__pyx_v_self); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 147, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "asyncpg/protocol/buffer.pyx":149 + * self._check_readonly() + * + * self._ensure_alloced(1) # <<<<<<<<<<<<<< + * self._buf[self._length] = b + * self._length += 1 + */ + __pyx_t_1 = __pyx_f_7asyncpg_8protocol_8protocol_11WriteBuffer__ensure_alloced(__pyx_v_self, 1); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 149, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "asyncpg/protocol/buffer.pyx":150 + * + * self._ensure_alloced(1) + * self._buf[self._length] = b # <<<<<<<<<<<<<< + * self._length += 1 + * + */ + (__pyx_v_self->_buf[__pyx_v_self->_length]) = __pyx_v_b; + + /* "asyncpg/protocol/buffer.pyx":151 + * self._ensure_alloced(1) + * self._buf[self._length] = b + * self._length += 1 # <<<<<<<<<<<<<< + * + * cdef write_bytes(self, bytes data): + */ + __pyx_v_self->_length = (__pyx_v_self->_length + 1); + + /* "asyncpg/protocol/buffer.pyx":146 + * self._length += buf._length + * + * cdef write_byte(self, char b): # <<<<<<<<<<<<<< + * self._check_readonly() + * + */ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("asyncpg.protocol.protocol.WriteBuffer.write_byte", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "asyncpg/protocol/buffer.pyx":153 + * self._length += 1 + * + * cdef write_bytes(self, bytes data): # <<<<<<<<<<<<<< + * cdef char* buf + * cdef ssize_t len + */ + +static PyObject *__pyx_f_7asyncpg_8protocol_8protocol_11WriteBuffer_write_bytes(struct __pyx_obj_7asyncpg_8protocol_8protocol_WriteBuffer *__pyx_v_self, PyObject *__pyx_v_data) { + char *__pyx_v_buf; + Py_ssize_t __pyx_v_len; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + PyObject *__pyx_t_2 = NULL; + __Pyx_RefNannySetupContext("write_bytes", 0); + + /* "asyncpg/protocol/buffer.pyx":157 + * cdef ssize_t len + * + * cpython.PyBytes_AsStringAndSize(data, &buf, &len) # <<<<<<<<<<<<<< + * self.write_cstr(buf, len) + * + */ + __pyx_t_1 = PyBytes_AsStringAndSize(__pyx_v_data, (&__pyx_v_buf), ((Py_ssize_t *)(&__pyx_v_len))); if (unlikely(__pyx_t_1 == -1)) __PYX_ERR(1, 157, __pyx_L1_error) + + /* "asyncpg/protocol/buffer.pyx":158 + * + * cpython.PyBytes_AsStringAndSize(data, &buf, &len) + * self.write_cstr(buf, len) # <<<<<<<<<<<<<< + * + * cdef write_bytestring(self, bytes string): + */ + __pyx_t_2 = __pyx_f_7asyncpg_8protocol_8protocol_11WriteBuffer_write_cstr(__pyx_v_self, __pyx_v_buf, __pyx_v_len); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 158, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "asyncpg/protocol/buffer.pyx":153 + * self._length += 1 + * + * cdef write_bytes(self, bytes data): # <<<<<<<<<<<<<< + * cdef char* buf + * cdef ssize_t len + */ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_2); + __Pyx_AddTraceback("asyncpg.protocol.protocol.WriteBuffer.write_bytes", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "asyncpg/protocol/buffer.pyx":160 + * self.write_cstr(buf, len) + * + * cdef write_bytestring(self, bytes string): # <<<<<<<<<<<<<< + * cdef char* buf + * cdef ssize_t len + */ + +static PyObject *__pyx_f_7asyncpg_8protocol_8protocol_11WriteBuffer_write_bytestring(struct __pyx_obj_7asyncpg_8protocol_8protocol_WriteBuffer *__pyx_v_self, PyObject *__pyx_v_string) { + char *__pyx_v_buf; + Py_ssize_t __pyx_v_len; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + PyObject *__pyx_t_2 = NULL; + __Pyx_RefNannySetupContext("write_bytestring", 0); + + /* "asyncpg/protocol/buffer.pyx":164 + * cdef ssize_t len + * + * cpython.PyBytes_AsStringAndSize(string, &buf, &len) # <<<<<<<<<<<<<< + * # PyBytes_AsStringAndSize returns a null-terminated buffer, + * # but the null byte is not counted in len. hence the + 1 + */ + __pyx_t_1 = PyBytes_AsStringAndSize(__pyx_v_string, (&__pyx_v_buf), ((Py_ssize_t *)(&__pyx_v_len))); if (unlikely(__pyx_t_1 == -1)) __PYX_ERR(1, 164, __pyx_L1_error) + + /* "asyncpg/protocol/buffer.pyx":167 + * # PyBytes_AsStringAndSize returns a null-terminated buffer, + * # but the null byte is not counted in len. hence the + 1 + * self.write_cstr(buf, len + 1) # <<<<<<<<<<<<<< + * + * cdef write_str(self, str string, str encoding): + */ + __pyx_t_2 = __pyx_f_7asyncpg_8protocol_8protocol_11WriteBuffer_write_cstr(__pyx_v_self, __pyx_v_buf, (__pyx_v_len + 1)); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 167, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "asyncpg/protocol/buffer.pyx":160 + * self.write_cstr(buf, len) + * + * cdef write_bytestring(self, bytes string): # <<<<<<<<<<<<<< + * cdef char* buf + * cdef ssize_t len + */ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_2); + __Pyx_AddTraceback("asyncpg.protocol.protocol.WriteBuffer.write_bytestring", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "asyncpg/protocol/buffer.pyx":169 + * self.write_cstr(buf, len + 1) + * + * cdef write_str(self, str string, str encoding): # <<<<<<<<<<<<<< + * self.write_bytestring(string.encode(encoding)) + * + */ + +static PyObject *__pyx_f_7asyncpg_8protocol_8protocol_11WriteBuffer_write_str(struct __pyx_obj_7asyncpg_8protocol_8protocol_WriteBuffer *__pyx_v_self, PyObject *__pyx_v_string, PyObject *__pyx_v_encoding) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + __Pyx_RefNannySetupContext("write_str", 0); + + /* "asyncpg/protocol/buffer.pyx":170 + * + * cdef write_str(self, str string, str encoding): + * self.write_bytestring(string.encode(encoding)) # <<<<<<<<<<<<<< + * + * cdef write_cstr(self, char *data, ssize_t len): + */ + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_string, __pyx_n_s_encode); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 170, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = NULL; + if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_3)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_3); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + } + } + if (!__pyx_t_3) { + __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_v_encoding); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 170, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + } else { + #if CYTHON_FAST_PYCALL + if (PyFunction_Check(__pyx_t_2)) { + PyObject *__pyx_temp[2] = {__pyx_t_3, __pyx_v_encoding}; + __pyx_t_1 = __Pyx_PyFunction_FastCall(__pyx_t_2, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 170, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_GOTREF(__pyx_t_1); + } else + #endif + #if CYTHON_FAST_PYCCALL + if (__Pyx_PyFastCFunction_Check(__pyx_t_2)) { + PyObject *__pyx_temp[2] = {__pyx_t_3, __pyx_v_encoding}; + __pyx_t_1 = __Pyx_PyCFunction_FastCall(__pyx_t_2, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 170, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_GOTREF(__pyx_t_1); + } else + #endif + { + __pyx_t_4 = PyTuple_New(1+1); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 170, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_GIVEREF(__pyx_t_3); PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_3); __pyx_t_3 = NULL; + __Pyx_INCREF(__pyx_v_encoding); + __Pyx_GIVEREF(__pyx_v_encoding); + PyTuple_SET_ITEM(__pyx_t_4, 0+1, __pyx_v_encoding); + __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_t_4, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 170, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + } + } + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + if (!(likely(PyBytes_CheckExact(__pyx_t_1))||((__pyx_t_1) == Py_None)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "bytes", Py_TYPE(__pyx_t_1)->tp_name), 0))) __PYX_ERR(1, 170, __pyx_L1_error) + __pyx_t_2 = __pyx_f_7asyncpg_8protocol_8protocol_11WriteBuffer_write_bytestring(__pyx_v_self, ((PyObject*)__pyx_t_1)); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 170, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "asyncpg/protocol/buffer.pyx":169 + * self.write_cstr(buf, len + 1) + * + * cdef write_str(self, str string, str encoding): # <<<<<<<<<<<<<< + * self.write_bytestring(string.encode(encoding)) + * + */ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_AddTraceback("asyncpg.protocol.protocol.WriteBuffer.write_str", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "asyncpg/protocol/buffer.pyx":172 + * self.write_bytestring(string.encode(encoding)) + * + * cdef write_cstr(self, char *data, ssize_t len): # <<<<<<<<<<<<<< + * self._check_readonly() + * self._ensure_alloced(len) + */ + +static PyObject *__pyx_f_7asyncpg_8protocol_8protocol_11WriteBuffer_write_cstr(struct __pyx_obj_7asyncpg_8protocol_8protocol_WriteBuffer *__pyx_v_self, char *__pyx_v_data, Py_ssize_t __pyx_v_len) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + __Pyx_RefNannySetupContext("write_cstr", 0); + + /* "asyncpg/protocol/buffer.pyx":173 + * + * cdef write_cstr(self, char *data, ssize_t len): + * self._check_readonly() # <<<<<<<<<<<<<< + * self._ensure_alloced(len) + * + */ + __pyx_t_1 = __pyx_f_7asyncpg_8protocol_8protocol_11WriteBuffer__check_readonly(__pyx_v_self); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 173, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "asyncpg/protocol/buffer.pyx":174 + * cdef write_cstr(self, char *data, ssize_t len): + * self._check_readonly() + * self._ensure_alloced(len) # <<<<<<<<<<<<<< + * + * memcpy(self._buf + self._length, data, len) + */ + __pyx_t_1 = __pyx_f_7asyncpg_8protocol_8protocol_11WriteBuffer__ensure_alloced(__pyx_v_self, __pyx_v_len); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 174, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "asyncpg/protocol/buffer.pyx":176 + * self._ensure_alloced(len) + * + * memcpy(self._buf + self._length, data, len) # <<<<<<<<<<<<<< + * self._length += len + * + */ + memcpy((__pyx_v_self->_buf + __pyx_v_self->_length), ((void *)__pyx_v_data), ((size_t)__pyx_v_len)); + + /* "asyncpg/protocol/buffer.pyx":177 + * + * memcpy(self._buf + self._length, data, len) + * self._length += len # <<<<<<<<<<<<<< + * + * cdef write_int16(self, int16_t i): + */ + __pyx_v_self->_length = (__pyx_v_self->_length + __pyx_v_len); + + /* "asyncpg/protocol/buffer.pyx":172 + * self.write_bytestring(string.encode(encoding)) + * + * cdef write_cstr(self, char *data, ssize_t len): # <<<<<<<<<<<<<< + * self._check_readonly() + * self._ensure_alloced(len) + */ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("asyncpg.protocol.protocol.WriteBuffer.write_cstr", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "asyncpg/protocol/buffer.pyx":179 + * self._length += len + * + * cdef write_int16(self, int16_t i): # <<<<<<<<<<<<<< + * self._check_readonly() + * self._ensure_alloced(2) + */ + +static PyObject *__pyx_f_7asyncpg_8protocol_8protocol_11WriteBuffer_write_int16(struct __pyx_obj_7asyncpg_8protocol_8protocol_WriteBuffer *__pyx_v_self, int16_t __pyx_v_i) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + __Pyx_RefNannySetupContext("write_int16", 0); + + /* "asyncpg/protocol/buffer.pyx":180 + * + * cdef write_int16(self, int16_t i): + * self._check_readonly() # <<<<<<<<<<<<<< + * self._ensure_alloced(2) + * + */ + __pyx_t_1 = __pyx_f_7asyncpg_8protocol_8protocol_11WriteBuffer__check_readonly(__pyx_v_self); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 180, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "asyncpg/protocol/buffer.pyx":181 + * cdef write_int16(self, int16_t i): + * self._check_readonly() + * self._ensure_alloced(2) # <<<<<<<<<<<<<< + * + * hton.pack_int16(&self._buf[self._length], i) + */ + __pyx_t_1 = __pyx_f_7asyncpg_8protocol_8protocol_11WriteBuffer__ensure_alloced(__pyx_v_self, 2); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 181, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "asyncpg/protocol/buffer.pyx":183 + * self._ensure_alloced(2) + * + * hton.pack_int16(&self._buf[self._length], i) # <<<<<<<<<<<<<< + * self._length += 2 + * + */ + __pyx_f_7asyncpg_8protocol_4hton_pack_int16((&(__pyx_v_self->_buf[__pyx_v_self->_length])), __pyx_v_i); + + /* "asyncpg/protocol/buffer.pyx":184 + * + * hton.pack_int16(&self._buf[self._length], i) + * self._length += 2 # <<<<<<<<<<<<<< + * + * cdef write_int32(self, int32_t i): + */ + __pyx_v_self->_length = (__pyx_v_self->_length + 2); + + /* "asyncpg/protocol/buffer.pyx":179 + * self._length += len + * + * cdef write_int16(self, int16_t i): # <<<<<<<<<<<<<< + * self._check_readonly() + * self._ensure_alloced(2) + */ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("asyncpg.protocol.protocol.WriteBuffer.write_int16", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "asyncpg/protocol/buffer.pyx":186 + * self._length += 2 + * + * cdef write_int32(self, int32_t i): # <<<<<<<<<<<<<< + * self._check_readonly() + * self._ensure_alloced(4) + */ + +static PyObject *__pyx_f_7asyncpg_8protocol_8protocol_11WriteBuffer_write_int32(struct __pyx_obj_7asyncpg_8protocol_8protocol_WriteBuffer *__pyx_v_self, int32_t __pyx_v_i) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + __Pyx_RefNannySetupContext("write_int32", 0); + + /* "asyncpg/protocol/buffer.pyx":187 + * + * cdef write_int32(self, int32_t i): + * self._check_readonly() # <<<<<<<<<<<<<< + * self._ensure_alloced(4) + * + */ + __pyx_t_1 = __pyx_f_7asyncpg_8protocol_8protocol_11WriteBuffer__check_readonly(__pyx_v_self); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 187, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "asyncpg/protocol/buffer.pyx":188 + * cdef write_int32(self, int32_t i): + * self._check_readonly() + * self._ensure_alloced(4) # <<<<<<<<<<<<<< + * + * hton.pack_int32(&self._buf[self._length], i) + */ + __pyx_t_1 = __pyx_f_7asyncpg_8protocol_8protocol_11WriteBuffer__ensure_alloced(__pyx_v_self, 4); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 188, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "asyncpg/protocol/buffer.pyx":190 + * self._ensure_alloced(4) + * + * hton.pack_int32(&self._buf[self._length], i) # <<<<<<<<<<<<<< + * self._length += 4 + * + */ + __pyx_f_7asyncpg_8protocol_4hton_pack_int32((&(__pyx_v_self->_buf[__pyx_v_self->_length])), __pyx_v_i); + + /* "asyncpg/protocol/buffer.pyx":191 + * + * hton.pack_int32(&self._buf[self._length], i) + * self._length += 4 # <<<<<<<<<<<<<< + * + * cdef write_int64(self, int64_t i): + */ + __pyx_v_self->_length = (__pyx_v_self->_length + 4); + + /* "asyncpg/protocol/buffer.pyx":186 + * self._length += 2 + * + * cdef write_int32(self, int32_t i): # <<<<<<<<<<<<<< + * self._check_readonly() + * self._ensure_alloced(4) + */ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("asyncpg.protocol.protocol.WriteBuffer.write_int32", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "asyncpg/protocol/buffer.pyx":193 + * self._length += 4 + * + * cdef write_int64(self, int64_t i): # <<<<<<<<<<<<<< + * self._check_readonly() + * self._ensure_alloced(8) + */ + +static PyObject *__pyx_f_7asyncpg_8protocol_8protocol_11WriteBuffer_write_int64(struct __pyx_obj_7asyncpg_8protocol_8protocol_WriteBuffer *__pyx_v_self, int64_t __pyx_v_i) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + __Pyx_RefNannySetupContext("write_int64", 0); + + /* "asyncpg/protocol/buffer.pyx":194 + * + * cdef write_int64(self, int64_t i): + * self._check_readonly() # <<<<<<<<<<<<<< + * self._ensure_alloced(8) + * + */ + __pyx_t_1 = __pyx_f_7asyncpg_8protocol_8protocol_11WriteBuffer__check_readonly(__pyx_v_self); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 194, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "asyncpg/protocol/buffer.pyx":195 + * cdef write_int64(self, int64_t i): + * self._check_readonly() + * self._ensure_alloced(8) # <<<<<<<<<<<<<< + * + * hton.pack_int64(&self._buf[self._length], i) + */ + __pyx_t_1 = __pyx_f_7asyncpg_8protocol_8protocol_11WriteBuffer__ensure_alloced(__pyx_v_self, 8); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 195, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "asyncpg/protocol/buffer.pyx":197 + * self._ensure_alloced(8) + * + * hton.pack_int64(&self._buf[self._length], i) # <<<<<<<<<<<<<< + * self._length += 8 + * + */ + __pyx_f_7asyncpg_8protocol_4hton_pack_int64((&(__pyx_v_self->_buf[__pyx_v_self->_length])), __pyx_v_i); + + /* "asyncpg/protocol/buffer.pyx":198 + * + * hton.pack_int64(&self._buf[self._length], i) + * self._length += 8 # <<<<<<<<<<<<<< + * + * cdef write_float(self, float f): + */ + __pyx_v_self->_length = (__pyx_v_self->_length + 8); + + /* "asyncpg/protocol/buffer.pyx":193 + * self._length += 4 + * + * cdef write_int64(self, int64_t i): # <<<<<<<<<<<<<< + * self._check_readonly() + * self._ensure_alloced(8) + */ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("asyncpg.protocol.protocol.WriteBuffer.write_int64", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "asyncpg/protocol/buffer.pyx":200 + * self._length += 8 + * + * cdef write_float(self, float f): # <<<<<<<<<<<<<< + * self._check_readonly() + * self._ensure_alloced(4) + */ + +static PyObject *__pyx_f_7asyncpg_8protocol_8protocol_11WriteBuffer_write_float(struct __pyx_obj_7asyncpg_8protocol_8protocol_WriteBuffer *__pyx_v_self, float __pyx_v_f) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + __Pyx_RefNannySetupContext("write_float", 0); + + /* "asyncpg/protocol/buffer.pyx":201 + * + * cdef write_float(self, float f): + * self._check_readonly() # <<<<<<<<<<<<<< + * self._ensure_alloced(4) + * + */ + __pyx_t_1 = __pyx_f_7asyncpg_8protocol_8protocol_11WriteBuffer__check_readonly(__pyx_v_self); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 201, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "asyncpg/protocol/buffer.pyx":202 + * cdef write_float(self, float f): + * self._check_readonly() + * self._ensure_alloced(4) # <<<<<<<<<<<<<< + * + * hton.pack_float(&self._buf[self._length], f) + */ + __pyx_t_1 = __pyx_f_7asyncpg_8protocol_8protocol_11WriteBuffer__ensure_alloced(__pyx_v_self, 4); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 202, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "asyncpg/protocol/buffer.pyx":204 + * self._ensure_alloced(4) + * + * hton.pack_float(&self._buf[self._length], f) # <<<<<<<<<<<<<< + * self._length += 4 + * + */ + __pyx_f_7asyncpg_8protocol_4hton_pack_float((&(__pyx_v_self->_buf[__pyx_v_self->_length])), __pyx_v_f); + + /* "asyncpg/protocol/buffer.pyx":205 + * + * hton.pack_float(&self._buf[self._length], f) + * self._length += 4 # <<<<<<<<<<<<<< + * + * cdef write_double(self, double d): + */ + __pyx_v_self->_length = (__pyx_v_self->_length + 4); + + /* "asyncpg/protocol/buffer.pyx":200 + * self._length += 8 + * + * cdef write_float(self, float f): # <<<<<<<<<<<<<< + * self._check_readonly() + * self._ensure_alloced(4) + */ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("asyncpg.protocol.protocol.WriteBuffer.write_float", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "asyncpg/protocol/buffer.pyx":207 + * self._length += 4 + * + * cdef write_double(self, double d): # <<<<<<<<<<<<<< + * self._check_readonly() + * self._ensure_alloced(8) + */ + +static PyObject *__pyx_f_7asyncpg_8protocol_8protocol_11WriteBuffer_write_double(struct __pyx_obj_7asyncpg_8protocol_8protocol_WriteBuffer *__pyx_v_self, double __pyx_v_d) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + __Pyx_RefNannySetupContext("write_double", 0); + + /* "asyncpg/protocol/buffer.pyx":208 + * + * cdef write_double(self, double d): + * self._check_readonly() # <<<<<<<<<<<<<< + * self._ensure_alloced(8) + * + */ + __pyx_t_1 = __pyx_f_7asyncpg_8protocol_8protocol_11WriteBuffer__check_readonly(__pyx_v_self); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 208, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "asyncpg/protocol/buffer.pyx":209 + * cdef write_double(self, double d): + * self._check_readonly() + * self._ensure_alloced(8) # <<<<<<<<<<<<<< + * + * hton.pack_double(&self._buf[self._length], d) + */ + __pyx_t_1 = __pyx_f_7asyncpg_8protocol_8protocol_11WriteBuffer__ensure_alloced(__pyx_v_self, 8); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 209, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "asyncpg/protocol/buffer.pyx":211 + * self._ensure_alloced(8) + * + * hton.pack_double(&self._buf[self._length], d) # <<<<<<<<<<<<<< + * self._length += 8 + * + */ + __pyx_f_7asyncpg_8protocol_4hton_pack_double((&(__pyx_v_self->_buf[__pyx_v_self->_length])), __pyx_v_d); + + /* "asyncpg/protocol/buffer.pyx":212 + * + * hton.pack_double(&self._buf[self._length], d) + * self._length += 8 # <<<<<<<<<<<<<< + * + * @staticmethod + */ + __pyx_v_self->_length = (__pyx_v_self->_length + 8); + + /* "asyncpg/protocol/buffer.pyx":207 + * self._length += 4 + * + * cdef write_double(self, double d): # <<<<<<<<<<<<<< + * self._check_readonly() + * self._ensure_alloced(8) + */ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("asyncpg.protocol.protocol.WriteBuffer.write_double", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "asyncpg/protocol/buffer.pyx":215 + * + * @staticmethod + * cdef WriteBuffer new_message(char type): # <<<<<<<<<<<<<< + * cdef WriteBuffer buf + * buf = WriteBuffer.__new__(WriteBuffer) + */ + +static struct __pyx_obj_7asyncpg_8protocol_8protocol_WriteBuffer *__pyx_f_7asyncpg_8protocol_8protocol_11WriteBuffer_new_message(char __pyx_v_type) { + struct __pyx_obj_7asyncpg_8protocol_8protocol_WriteBuffer *__pyx_v_buf = 0; + struct __pyx_obj_7asyncpg_8protocol_8protocol_WriteBuffer *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + __Pyx_RefNannySetupContext("new_message", 0); + + /* "asyncpg/protocol/buffer.pyx":217 + * cdef WriteBuffer new_message(char type): + * cdef WriteBuffer buf + * buf = WriteBuffer.__new__(WriteBuffer) # <<<<<<<<<<<<<< + * buf.start_message(type) + * return buf + */ + __pyx_t_1 = __pyx_tp_new_7asyncpg_8protocol_8protocol_WriteBuffer(((PyTypeObject *)__pyx_ptype_7asyncpg_8protocol_8protocol_WriteBuffer), __pyx_empty_tuple, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 217, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (!(likely(__Pyx_TypeTest(__pyx_t_1, __pyx_ptype_7asyncpg_8protocol_8protocol_WriteBuffer)))) __PYX_ERR(1, 217, __pyx_L1_error) + __pyx_v_buf = ((struct __pyx_obj_7asyncpg_8protocol_8protocol_WriteBuffer *)__pyx_t_1); + __pyx_t_1 = 0; + + /* "asyncpg/protocol/buffer.pyx":218 + * cdef WriteBuffer buf + * buf = WriteBuffer.__new__(WriteBuffer) + * buf.start_message(type) # <<<<<<<<<<<<<< + * return buf + * + */ + __pyx_t_1 = __pyx_f_7asyncpg_8protocol_8protocol_11WriteBuffer_start_message(__pyx_v_buf, __pyx_v_type); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 218, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "asyncpg/protocol/buffer.pyx":219 + * buf = WriteBuffer.__new__(WriteBuffer) + * buf.start_message(type) + * return buf # <<<<<<<<<<<<<< + * + * @staticmethod + */ + __Pyx_XDECREF(((PyObject *)__pyx_r)); + __Pyx_INCREF(((PyObject *)__pyx_v_buf)); + __pyx_r = __pyx_v_buf; + goto __pyx_L0; + + /* "asyncpg/protocol/buffer.pyx":215 + * + * @staticmethod + * cdef WriteBuffer new_message(char type): # <<<<<<<<<<<<<< + * cdef WriteBuffer buf + * buf = WriteBuffer.__new__(WriteBuffer) + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("asyncpg.protocol.protocol.WriteBuffer.new_message", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XDECREF((PyObject *)__pyx_v_buf); + __Pyx_XGIVEREF((PyObject *)__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "asyncpg/protocol/buffer.pyx":222 + * + * @staticmethod + * cdef WriteBuffer new(): # <<<<<<<<<<<<<< + * cdef WriteBuffer buf + * buf = WriteBuffer.__new__(WriteBuffer) + */ + +static struct __pyx_obj_7asyncpg_8protocol_8protocol_WriteBuffer *__pyx_f_7asyncpg_8protocol_8protocol_11WriteBuffer_new(void) { + struct __pyx_obj_7asyncpg_8protocol_8protocol_WriteBuffer *__pyx_v_buf = 0; + struct __pyx_obj_7asyncpg_8protocol_8protocol_WriteBuffer *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + __Pyx_RefNannySetupContext("new", 0); + + /* "asyncpg/protocol/buffer.pyx":224 + * cdef WriteBuffer new(): + * cdef WriteBuffer buf + * buf = WriteBuffer.__new__(WriteBuffer) # <<<<<<<<<<<<<< + * return buf + * + */ + __pyx_t_1 = __pyx_tp_new_7asyncpg_8protocol_8protocol_WriteBuffer(((PyTypeObject *)__pyx_ptype_7asyncpg_8protocol_8protocol_WriteBuffer), __pyx_empty_tuple, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 224, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (!(likely(__Pyx_TypeTest(__pyx_t_1, __pyx_ptype_7asyncpg_8protocol_8protocol_WriteBuffer)))) __PYX_ERR(1, 224, __pyx_L1_error) + __pyx_v_buf = ((struct __pyx_obj_7asyncpg_8protocol_8protocol_WriteBuffer *)__pyx_t_1); + __pyx_t_1 = 0; + + /* "asyncpg/protocol/buffer.pyx":225 + * cdef WriteBuffer buf + * buf = WriteBuffer.__new__(WriteBuffer) + * return buf # <<<<<<<<<<<<<< + * + * + */ + __Pyx_XDECREF(((PyObject *)__pyx_r)); + __Pyx_INCREF(((PyObject *)__pyx_v_buf)); + __pyx_r = __pyx_v_buf; + goto __pyx_L0; + + /* "asyncpg/protocol/buffer.pyx":222 + * + * @staticmethod + * cdef WriteBuffer new(): # <<<<<<<<<<<<<< + * cdef WriteBuffer buf + * buf = WriteBuffer.__new__(WriteBuffer) + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("asyncpg.protocol.protocol.WriteBuffer.new", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XDECREF((PyObject *)__pyx_v_buf); + __Pyx_XGIVEREF((PyObject *)__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "asyncpg/protocol/buffer.pyx":233 + * cdef class ReadBuffer: + * + * def __cinit__(self): # <<<<<<<<<<<<<< + * self._bufs = collections.deque() + * self._bufs_append = self._bufs.append + */ + +/* Python wrapper */ +static int __pyx_pw_7asyncpg_8protocol_8protocol_10ReadBuffer_1__cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ +static int __pyx_pw_7asyncpg_8protocol_8protocol_10ReadBuffer_1__cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__cinit__ (wrapper)", 0); + if (unlikely(PyTuple_GET_SIZE(__pyx_args) > 0)) { + __Pyx_RaiseArgtupleInvalid("__cinit__", 1, 0, 0, PyTuple_GET_SIZE(__pyx_args)); return -1;} + if (unlikely(__pyx_kwds) && unlikely(PyDict_Size(__pyx_kwds) > 0) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "__cinit__", 0))) return -1; + __pyx_r = __pyx_pf_7asyncpg_8protocol_8protocol_10ReadBuffer___cinit__(((struct __pyx_obj_7asyncpg_8protocol_8protocol_ReadBuffer *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_7asyncpg_8protocol_8protocol_10ReadBuffer___cinit__(struct __pyx_obj_7asyncpg_8protocol_8protocol_ReadBuffer *__pyx_v_self) { + int __pyx_r; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + __Pyx_RefNannySetupContext("__cinit__", 0); + + /* "asyncpg/protocol/buffer.pyx":234 + * + * def __cinit__(self): + * self._bufs = collections.deque() # <<<<<<<<<<<<<< + * self._bufs_append = self._bufs.append + * self._bufs_popleft = self._bufs.popleft + */ + __pyx_t_2 = __Pyx_GetModuleGlobalName(__pyx_n_s_collections); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 234, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_deque); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 234, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_2 = NULL; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_3))) { + __pyx_t_2 = PyMethod_GET_SELF(__pyx_t_3); + if (likely(__pyx_t_2)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); + __Pyx_INCREF(__pyx_t_2); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_3, function); + } + } + if (__pyx_t_2) { + __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_2); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 234, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } else { + __pyx_t_1 = __Pyx_PyObject_CallNoArg(__pyx_t_3); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 234, __pyx_L1_error) + } + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_GIVEREF(__pyx_t_1); + __Pyx_GOTREF(__pyx_v_self->_bufs); + __Pyx_DECREF(__pyx_v_self->_bufs); + __pyx_v_self->_bufs = __pyx_t_1; + __pyx_t_1 = 0; + + /* "asyncpg/protocol/buffer.pyx":235 + * def __cinit__(self): + * self._bufs = collections.deque() + * self._bufs_append = self._bufs.append # <<<<<<<<<<<<<< + * self._bufs_popleft = self._bufs.popleft + * self._bufs_len = 0 + */ + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_self->_bufs, __pyx_n_s_append); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 235, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_GIVEREF(__pyx_t_1); + __Pyx_GOTREF(__pyx_v_self->_bufs_append); + __Pyx_DECREF(__pyx_v_self->_bufs_append); + __pyx_v_self->_bufs_append = __pyx_t_1; + __pyx_t_1 = 0; + + /* "asyncpg/protocol/buffer.pyx":236 + * self._bufs = collections.deque() + * self._bufs_append = self._bufs.append + * self._bufs_popleft = self._bufs.popleft # <<<<<<<<<<<<<< + * self._bufs_len = 0 + * self._buf0 = None + */ + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_self->_bufs, __pyx_n_s_popleft); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 236, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_GIVEREF(__pyx_t_1); + __Pyx_GOTREF(__pyx_v_self->_bufs_popleft); + __Pyx_DECREF(__pyx_v_self->_bufs_popleft); + __pyx_v_self->_bufs_popleft = __pyx_t_1; + __pyx_t_1 = 0; + + /* "asyncpg/protocol/buffer.pyx":237 + * self._bufs_append = self._bufs.append + * self._bufs_popleft = self._bufs.popleft + * self._bufs_len = 0 # <<<<<<<<<<<<<< + * self._buf0 = None + * self._buf0_prev = None + */ + __pyx_v_self->_bufs_len = 0; + + /* "asyncpg/protocol/buffer.pyx":238 + * self._bufs_popleft = self._bufs.popleft + * self._bufs_len = 0 + * self._buf0 = None # <<<<<<<<<<<<<< + * self._buf0_prev = None + * self._pos0 = 0 + */ + __Pyx_INCREF(Py_None); + __Pyx_GIVEREF(Py_None); + __Pyx_GOTREF(__pyx_v_self->_buf0); + __Pyx_DECREF(__pyx_v_self->_buf0); + __pyx_v_self->_buf0 = ((PyObject*)Py_None); + + /* "asyncpg/protocol/buffer.pyx":239 + * self._bufs_len = 0 + * self._buf0 = None + * self._buf0_prev = None # <<<<<<<<<<<<<< + * self._pos0 = 0 + * self._len0 = 0 + */ + __Pyx_INCREF(Py_None); + __Pyx_GIVEREF(Py_None); + __Pyx_GOTREF(__pyx_v_self->_buf0_prev); + __Pyx_DECREF(__pyx_v_self->_buf0_prev); + __pyx_v_self->_buf0_prev = ((PyObject*)Py_None); + + /* "asyncpg/protocol/buffer.pyx":240 + * self._buf0 = None + * self._buf0_prev = None + * self._pos0 = 0 # <<<<<<<<<<<<<< + * self._len0 = 0 + * self._length = 0 + */ + __pyx_v_self->_pos0 = 0; + + /* "asyncpg/protocol/buffer.pyx":241 + * self._buf0_prev = None + * self._pos0 = 0 + * self._len0 = 0 # <<<<<<<<<<<<<< + * self._length = 0 + * + */ + __pyx_v_self->_len0 = 0; + + /* "asyncpg/protocol/buffer.pyx":242 + * self._pos0 = 0 + * self._len0 = 0 + * self._length = 0 # <<<<<<<<<<<<<< + * + * self._current_message_type = 0 + */ + __pyx_v_self->_length = 0; + + /* "asyncpg/protocol/buffer.pyx":244 + * self._length = 0 + * + * self._current_message_type = 0 # <<<<<<<<<<<<<< + * self._current_message_len = 0 + * self._current_message_len_unread = 0 + */ + __pyx_v_self->_current_message_type = 0; + + /* "asyncpg/protocol/buffer.pyx":245 + * + * self._current_message_type = 0 + * self._current_message_len = 0 # <<<<<<<<<<<<<< + * self._current_message_len_unread = 0 + * self._current_message_ready = 0 + */ + __pyx_v_self->_current_message_len = 0; + + /* "asyncpg/protocol/buffer.pyx":246 + * self._current_message_type = 0 + * self._current_message_len = 0 + * self._current_message_len_unread = 0 # <<<<<<<<<<<<<< + * self._current_message_ready = 0 + * + */ + __pyx_v_self->_current_message_len_unread = 0; + + /* "asyncpg/protocol/buffer.pyx":247 + * self._current_message_len = 0 + * self._current_message_len_unread = 0 + * self._current_message_ready = 0 # <<<<<<<<<<<<<< + * + * cdef feed_data(self, data): + */ + __pyx_v_self->_current_message_ready = 0; + + /* "asyncpg/protocol/buffer.pyx":233 + * cdef class ReadBuffer: + * + * def __cinit__(self): # <<<<<<<<<<<<<< + * self._bufs = collections.deque() + * self._bufs_append = self._bufs.append + */ + + /* function exit code */ + __pyx_r = 0; + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_AddTraceback("asyncpg.protocol.protocol.ReadBuffer.__cinit__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = -1; + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "asyncpg/protocol/buffer.pyx":249 + * self._current_message_ready = 0 + * + * cdef feed_data(self, data): # <<<<<<<<<<<<<< + * cdef: + * ssize_t dlen + */ + +static PyObject *__pyx_f_7asyncpg_8protocol_8protocol_10ReadBuffer_feed_data(struct __pyx_obj_7asyncpg_8protocol_8protocol_ReadBuffer *__pyx_v_self, PyObject *__pyx_v_data) { + Py_ssize_t __pyx_v_dlen; + PyObject *__pyx_v_data_bytes = 0; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + PyObject *__pyx_t_5 = NULL; + __Pyx_RefNannySetupContext("feed_data", 0); + + /* "asyncpg/protocol/buffer.pyx":254 + * bytes data_bytes + * + * if not cpython.PyBytes_CheckExact(data): # <<<<<<<<<<<<<< + * raise BufferError('feed_data: bytes object expected') + * data_bytes = data + */ + __pyx_t_1 = ((!(PyBytes_CheckExact(__pyx_v_data) != 0)) != 0); + if (__pyx_t_1) { + + /* "asyncpg/protocol/buffer.pyx":255 + * + * if not cpython.PyBytes_CheckExact(data): + * raise BufferError('feed_data: bytes object expected') # <<<<<<<<<<<<<< + * data_bytes = data + * + */ + __pyx_t_2 = __Pyx_GetModuleGlobalName(__pyx_n_s_BufferError); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 255, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_tuple__11, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 255, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_Raise(__pyx_t_3, 0, 0, 0); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __PYX_ERR(1, 255, __pyx_L1_error) + + /* "asyncpg/protocol/buffer.pyx":254 + * bytes data_bytes + * + * if not cpython.PyBytes_CheckExact(data): # <<<<<<<<<<<<<< + * raise BufferError('feed_data: bytes object expected') + * data_bytes = data + */ + } + + /* "asyncpg/protocol/buffer.pyx":256 + * if not cpython.PyBytes_CheckExact(data): + * raise BufferError('feed_data: bytes object expected') + * data_bytes = data # <<<<<<<<<<<<<< + * + * dlen = cpython.Py_SIZE(data_bytes) + */ + __pyx_t_3 = __pyx_v_data; + __Pyx_INCREF(__pyx_t_3); + __pyx_v_data_bytes = ((PyObject*)__pyx_t_3); + __pyx_t_3 = 0; + + /* "asyncpg/protocol/buffer.pyx":258 + * data_bytes = data + * + * dlen = cpython.Py_SIZE(data_bytes) # <<<<<<<<<<<<<< + * if dlen == 0: + * # EOF? + */ + __pyx_v_dlen = Py_SIZE(__pyx_v_data_bytes); + + /* "asyncpg/protocol/buffer.pyx":259 + * + * dlen = cpython.Py_SIZE(data_bytes) + * if dlen == 0: # <<<<<<<<<<<<<< + * # EOF? + * return + */ + __pyx_t_1 = ((__pyx_v_dlen == 0) != 0); + if (__pyx_t_1) { + + /* "asyncpg/protocol/buffer.pyx":261 + * if dlen == 0: + * # EOF? + * return # <<<<<<<<<<<<<< + * + * self._bufs_append(data_bytes) + */ + __Pyx_XDECREF(__pyx_r); + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + + /* "asyncpg/protocol/buffer.pyx":259 + * + * dlen = cpython.Py_SIZE(data_bytes) + * if dlen == 0: # <<<<<<<<<<<<<< + * # EOF? + * return + */ + } + + /* "asyncpg/protocol/buffer.pyx":263 + * return + * + * self._bufs_append(data_bytes) # <<<<<<<<<<<<<< + * self._length += dlen + * + */ + __Pyx_INCREF(__pyx_v_self->_bufs_append); + __pyx_t_2 = __pyx_v_self->_bufs_append; __pyx_t_4 = NULL; + if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_4)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_4); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + } + } + if (!__pyx_t_4) { + __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_v_data_bytes); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 263, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + } else { + #if CYTHON_FAST_PYCALL + if (PyFunction_Check(__pyx_t_2)) { + PyObject *__pyx_temp[2] = {__pyx_t_4, __pyx_v_data_bytes}; + __pyx_t_3 = __Pyx_PyFunction_FastCall(__pyx_t_2, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 263, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_GOTREF(__pyx_t_3); + } else + #endif + #if CYTHON_FAST_PYCCALL + if (__Pyx_PyFastCFunction_Check(__pyx_t_2)) { + PyObject *__pyx_temp[2] = {__pyx_t_4, __pyx_v_data_bytes}; + __pyx_t_3 = __Pyx_PyCFunction_FastCall(__pyx_t_2, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 263, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_GOTREF(__pyx_t_3); + } else + #endif + { + __pyx_t_5 = PyTuple_New(1+1); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 263, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_GIVEREF(__pyx_t_4); PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_t_4); __pyx_t_4 = NULL; + __Pyx_INCREF(__pyx_v_data_bytes); + __Pyx_GIVEREF(__pyx_v_data_bytes); + PyTuple_SET_ITEM(__pyx_t_5, 0+1, __pyx_v_data_bytes); + __pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_t_5, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 263, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + } + } + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + + /* "asyncpg/protocol/buffer.pyx":264 + * + * self._bufs_append(data_bytes) + * self._length += dlen # <<<<<<<<<<<<<< + * + * if self._bufs_len == 0: + */ + __pyx_v_self->_length = (__pyx_v_self->_length + __pyx_v_dlen); + + /* "asyncpg/protocol/buffer.pyx":266 + * self._length += dlen + * + * if self._bufs_len == 0: # <<<<<<<<<<<<<< + * # First buffer + * self._len0 = dlen + */ + __pyx_t_1 = ((__pyx_v_self->_bufs_len == 0) != 0); + if (__pyx_t_1) { + + /* "asyncpg/protocol/buffer.pyx":268 + * if self._bufs_len == 0: + * # First buffer + * self._len0 = dlen # <<<<<<<<<<<<<< + * self._buf0 = data_bytes + * + */ + __pyx_v_self->_len0 = __pyx_v_dlen; + + /* "asyncpg/protocol/buffer.pyx":269 + * # First buffer + * self._len0 = dlen + * self._buf0 = data_bytes # <<<<<<<<<<<<<< + * + * self._bufs_len += 1 + */ + __Pyx_INCREF(__pyx_v_data_bytes); + __Pyx_GIVEREF(__pyx_v_data_bytes); + __Pyx_GOTREF(__pyx_v_self->_buf0); + __Pyx_DECREF(__pyx_v_self->_buf0); + __pyx_v_self->_buf0 = __pyx_v_data_bytes; + + /* "asyncpg/protocol/buffer.pyx":266 + * self._length += dlen + * + * if self._bufs_len == 0: # <<<<<<<<<<<<<< + * # First buffer + * self._len0 = dlen + */ + } + + /* "asyncpg/protocol/buffer.pyx":271 + * self._buf0 = data_bytes + * + * self._bufs_len += 1 # <<<<<<<<<<<<<< + * + * cdef inline _ensure_first_buf(self): + */ + __pyx_v_self->_bufs_len = (__pyx_v_self->_bufs_len + 1); + + /* "asyncpg/protocol/buffer.pyx":249 + * self._current_message_ready = 0 + * + * cdef feed_data(self, data): # <<<<<<<<<<<<<< + * cdef: + * ssize_t dlen + */ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_AddTraceback("asyncpg.protocol.protocol.ReadBuffer.feed_data", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XDECREF(__pyx_v_data_bytes); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "asyncpg/protocol/buffer.pyx":273 + * self._bufs_len += 1 + * + * cdef inline _ensure_first_buf(self): # <<<<<<<<<<<<<< + * if self._len0 == 0: + * raise BufferError('empty first buffer') + */ + +static CYTHON_INLINE PyObject *__pyx_f_7asyncpg_8protocol_8protocol_10ReadBuffer__ensure_first_buf(struct __pyx_obj_7asyncpg_8protocol_8protocol_ReadBuffer *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + __Pyx_RefNannySetupContext("_ensure_first_buf", 0); + + /* "asyncpg/protocol/buffer.pyx":274 + * + * cdef inline _ensure_first_buf(self): + * if self._len0 == 0: # <<<<<<<<<<<<<< + * raise BufferError('empty first buffer') + * + */ + __pyx_t_1 = ((__pyx_v_self->_len0 == 0) != 0); + if (__pyx_t_1) { + + /* "asyncpg/protocol/buffer.pyx":275 + * cdef inline _ensure_first_buf(self): + * if self._len0 == 0: + * raise BufferError('empty first buffer') # <<<<<<<<<<<<<< + * + * if self._pos0 == self._len0: + */ + __pyx_t_2 = __Pyx_GetModuleGlobalName(__pyx_n_s_BufferError); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 275, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_tuple__12, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 275, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_Raise(__pyx_t_3, 0, 0, 0); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __PYX_ERR(1, 275, __pyx_L1_error) + + /* "asyncpg/protocol/buffer.pyx":274 + * + * cdef inline _ensure_first_buf(self): + * if self._len0 == 0: # <<<<<<<<<<<<<< + * raise BufferError('empty first buffer') + * + */ + } + + /* "asyncpg/protocol/buffer.pyx":277 + * raise BufferError('empty first buffer') + * + * if self._pos0 == self._len0: # <<<<<<<<<<<<<< + * self._switch_to_next_buf() + * + */ + __pyx_t_1 = ((__pyx_v_self->_pos0 == __pyx_v_self->_len0) != 0); + if (__pyx_t_1) { + + /* "asyncpg/protocol/buffer.pyx":278 + * + * if self._pos0 == self._len0: + * self._switch_to_next_buf() # <<<<<<<<<<<<<< + * + * cdef _switch_to_next_buf(self): + */ + __pyx_t_3 = __pyx_f_7asyncpg_8protocol_8protocol_10ReadBuffer__switch_to_next_buf(__pyx_v_self); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 278, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + + /* "asyncpg/protocol/buffer.pyx":277 + * raise BufferError('empty first buffer') + * + * if self._pos0 == self._len0: # <<<<<<<<<<<<<< + * self._switch_to_next_buf() + * + */ + } + + /* "asyncpg/protocol/buffer.pyx":273 + * self._bufs_len += 1 + * + * cdef inline _ensure_first_buf(self): # <<<<<<<<<<<<<< + * if self._len0 == 0: + * raise BufferError('empty first buffer') + */ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_AddTraceback("asyncpg.protocol.protocol.ReadBuffer._ensure_first_buf", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "asyncpg/protocol/buffer.pyx":280 + * self._switch_to_next_buf() + * + * cdef _switch_to_next_buf(self): # <<<<<<<<<<<<<< + * # The first buffer is fully read, discard it + * self._bufs_popleft() + */ + +static PyObject *__pyx_f_7asyncpg_8protocol_8protocol_10ReadBuffer__switch_to_next_buf(struct __pyx_obj_7asyncpg_8protocol_8protocol_ReadBuffer *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + Py_ssize_t __pyx_t_4; + int __pyx_t_5; + __Pyx_RefNannySetupContext("_switch_to_next_buf", 0); + + /* "asyncpg/protocol/buffer.pyx":282 + * cdef _switch_to_next_buf(self): + * # The first buffer is fully read, discard it + * self._bufs_popleft() # <<<<<<<<<<<<<< + * self._bufs_len -= 1 + * + */ + __Pyx_INCREF(__pyx_v_self->_bufs_popleft); + __pyx_t_2 = __pyx_v_self->_bufs_popleft; __pyx_t_3 = NULL; + if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_3)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_3); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + } + } + if (__pyx_t_3) { + __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_3); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 282, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + } else { + __pyx_t_1 = __Pyx_PyObject_CallNoArg(__pyx_t_2); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 282, __pyx_L1_error) + } + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "asyncpg/protocol/buffer.pyx":283 + * # The first buffer is fully read, discard it + * self._bufs_popleft() + * self._bufs_len -= 1 # <<<<<<<<<<<<<< + * + * # Shouldn't fail, since we've checked that `_length >= 1` + */ + __pyx_v_self->_bufs_len = (__pyx_v_self->_bufs_len - 1); + + /* "asyncpg/protocol/buffer.pyx":287 + * # Shouldn't fail, since we've checked that `_length >= 1` + * # in _ensure_first_buf() + * self._buf0_prev = self._buf0 # <<<<<<<<<<<<<< + * self._buf0 = self._bufs[0] + * + */ + __pyx_t_1 = __pyx_v_self->_buf0; + __Pyx_INCREF(__pyx_t_1); + __Pyx_GIVEREF(__pyx_t_1); + __Pyx_GOTREF(__pyx_v_self->_buf0_prev); + __Pyx_DECREF(__pyx_v_self->_buf0_prev); + __pyx_v_self->_buf0_prev = ((PyObject*)__pyx_t_1); + __pyx_t_1 = 0; + + /* "asyncpg/protocol/buffer.pyx":288 + * # in _ensure_first_buf() + * self._buf0_prev = self._buf0 + * self._buf0 = self._bufs[0] # <<<<<<<<<<<<<< + * + * self._pos0 = 0 + */ + __pyx_t_1 = __Pyx_GetItemInt(__pyx_v_self->_bufs, 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 288, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = __pyx_t_1; + __Pyx_INCREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_GIVEREF(__pyx_t_2); + __Pyx_GOTREF(__pyx_v_self->_buf0); + __Pyx_DECREF(__pyx_v_self->_buf0); + __pyx_v_self->_buf0 = ((PyObject*)__pyx_t_2); + __pyx_t_2 = 0; + + /* "asyncpg/protocol/buffer.pyx":290 + * self._buf0 = self._bufs[0] + * + * self._pos0 = 0 # <<<<<<<<<<<<<< + * self._len0 = len(self._buf0) + * + */ + __pyx_v_self->_pos0 = 0; + + /* "asyncpg/protocol/buffer.pyx":291 + * + * self._pos0 = 0 + * self._len0 = len(self._buf0) # <<<<<<<<<<<<<< + * + * if ASYNCPG_DEBUG: + */ + __pyx_t_2 = __pyx_v_self->_buf0; + __Pyx_INCREF(__pyx_t_2); + if (unlikely(__pyx_t_2 == Py_None)) { + PyErr_SetString(PyExc_TypeError, "object of type 'NoneType' has no len()"); + __PYX_ERR(1, 291, __pyx_L1_error) + } + __pyx_t_4 = PyBytes_GET_SIZE(__pyx_t_2); if (unlikely(__pyx_t_4 == -1)) __PYX_ERR(1, 291, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_v_self->_len0 = __pyx_t_4; + + /* "asyncpg/protocol/buffer.pyx":293 + * self._len0 = len(self._buf0) + * + * if ASYNCPG_DEBUG: # <<<<<<<<<<<<<< + * if self._len0 < 1: + * raise RuntimeError( + */ + __pyx_t_5 = (ASYNCPG_DEBUG != 0); + if (__pyx_t_5) { + + /* "asyncpg/protocol/buffer.pyx":294 + * + * if ASYNCPG_DEBUG: + * if self._len0 < 1: # <<<<<<<<<<<<<< + * raise RuntimeError( + * 'debug: second buffer of ReadBuffer is empty') + */ + __pyx_t_5 = ((__pyx_v_self->_len0 < 1) != 0); + if (__pyx_t_5) { + + /* "asyncpg/protocol/buffer.pyx":295 + * if ASYNCPG_DEBUG: + * if self._len0 < 1: + * raise RuntimeError( # <<<<<<<<<<<<<< + * 'debug: second buffer of ReadBuffer is empty') + * + */ + __pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_RuntimeError, __pyx_tuple__13, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 295, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_Raise(__pyx_t_2, 0, 0, 0); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __PYX_ERR(1, 295, __pyx_L1_error) + + /* "asyncpg/protocol/buffer.pyx":294 + * + * if ASYNCPG_DEBUG: + * if self._len0 < 1: # <<<<<<<<<<<<<< + * raise RuntimeError( + * 'debug: second buffer of ReadBuffer is empty') + */ + } + + /* "asyncpg/protocol/buffer.pyx":293 + * self._len0 = len(self._buf0) + * + * if ASYNCPG_DEBUG: # <<<<<<<<<<<<<< + * if self._len0 < 1: + * raise RuntimeError( + */ + } + + /* "asyncpg/protocol/buffer.pyx":280 + * self._switch_to_next_buf() + * + * cdef _switch_to_next_buf(self): # <<<<<<<<<<<<<< + * # The first buffer is fully read, discard it + * self._bufs_popleft() + */ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_AddTraceback("asyncpg.protocol.protocol.ReadBuffer._switch_to_next_buf", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "asyncpg/protocol/buffer.pyx":298 + * 'debug: second buffer of ReadBuffer is empty') + * + * cdef inline char* _try_read_bytes(self, ssize_t nbytes): # <<<<<<<<<<<<<< + * # Important: caller must call _ensure_first_buf() prior + * # to calling try_read_bytes, and must not overread + */ + +static CYTHON_INLINE char *__pyx_f_7asyncpg_8protocol_8protocol_10ReadBuffer__try_read_bytes(struct __pyx_obj_7asyncpg_8protocol_8protocol_ReadBuffer *__pyx_v_self, Py_ssize_t __pyx_v_nbytes) { + char *__pyx_v_result; + char *__pyx_r; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + PyObject *__pyx_t_2 = NULL; + __Pyx_RefNannySetupContext("_try_read_bytes", 0); + + /* "asyncpg/protocol/buffer.pyx":305 + * char * result + * + * if ASYNCPG_DEBUG: # <<<<<<<<<<<<<< + * if nbytes > self._length: + * return NULL + */ + __pyx_t_1 = (ASYNCPG_DEBUG != 0); + if (__pyx_t_1) { + + /* "asyncpg/protocol/buffer.pyx":306 + * + * if ASYNCPG_DEBUG: + * if nbytes > self._length: # <<<<<<<<<<<<<< + * return NULL + * + */ + __pyx_t_1 = ((__pyx_v_nbytes > __pyx_v_self->_length) != 0); + if (__pyx_t_1) { + + /* "asyncpg/protocol/buffer.pyx":307 + * if ASYNCPG_DEBUG: + * if nbytes > self._length: + * return NULL # <<<<<<<<<<<<<< + * + * if self._current_message_ready: + */ + __pyx_r = NULL; + goto __pyx_L0; + + /* "asyncpg/protocol/buffer.pyx":306 + * + * if ASYNCPG_DEBUG: + * if nbytes > self._length: # <<<<<<<<<<<<<< + * return NULL + * + */ + } + + /* "asyncpg/protocol/buffer.pyx":305 + * char * result + * + * if ASYNCPG_DEBUG: # <<<<<<<<<<<<<< + * if nbytes > self._length: + * return NULL + */ + } + + /* "asyncpg/protocol/buffer.pyx":309 + * return NULL + * + * if self._current_message_ready: # <<<<<<<<<<<<<< + * if self._current_message_len_unread < nbytes: + * return NULL + */ + __pyx_t_1 = (__pyx_v_self->_current_message_ready != 0); + if (__pyx_t_1) { + + /* "asyncpg/protocol/buffer.pyx":310 + * + * if self._current_message_ready: + * if self._current_message_len_unread < nbytes: # <<<<<<<<<<<<<< + * return NULL + * + */ + __pyx_t_1 = ((__pyx_v_self->_current_message_len_unread < __pyx_v_nbytes) != 0); + if (__pyx_t_1) { + + /* "asyncpg/protocol/buffer.pyx":311 + * if self._current_message_ready: + * if self._current_message_len_unread < nbytes: + * return NULL # <<<<<<<<<<<<<< + * + * if self._pos0 + nbytes <= self._len0: + */ + __pyx_r = NULL; + goto __pyx_L0; + + /* "asyncpg/protocol/buffer.pyx":310 + * + * if self._current_message_ready: + * if self._current_message_len_unread < nbytes: # <<<<<<<<<<<<<< + * return NULL + * + */ + } + + /* "asyncpg/protocol/buffer.pyx":309 + * return NULL + * + * if self._current_message_ready: # <<<<<<<<<<<<<< + * if self._current_message_len_unread < nbytes: + * return NULL + */ + } + + /* "asyncpg/protocol/buffer.pyx":313 + * return NULL + * + * if self._pos0 + nbytes <= self._len0: # <<<<<<<<<<<<<< + * result = cpython.PyBytes_AS_STRING(self._buf0) + * result += self._pos0 + */ + __pyx_t_1 = (((__pyx_v_self->_pos0 + __pyx_v_nbytes) <= __pyx_v_self->_len0) != 0); + if (__pyx_t_1) { + + /* "asyncpg/protocol/buffer.pyx":314 + * + * if self._pos0 + nbytes <= self._len0: + * result = cpython.PyBytes_AS_STRING(self._buf0) # <<<<<<<<<<<<<< + * result += self._pos0 + * self._pos0 += nbytes + */ + __pyx_t_2 = __pyx_v_self->_buf0; + __Pyx_INCREF(__pyx_t_2); + __pyx_v_result = PyBytes_AS_STRING(__pyx_t_2); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "asyncpg/protocol/buffer.pyx":315 + * if self._pos0 + nbytes <= self._len0: + * result = cpython.PyBytes_AS_STRING(self._buf0) + * result += self._pos0 # <<<<<<<<<<<<<< + * self._pos0 += nbytes + * self._length -= nbytes + */ + __pyx_v_result = (__pyx_v_result + __pyx_v_self->_pos0); + + /* "asyncpg/protocol/buffer.pyx":316 + * result = cpython.PyBytes_AS_STRING(self._buf0) + * result += self._pos0 + * self._pos0 += nbytes # <<<<<<<<<<<<<< + * self._length -= nbytes + * if self._current_message_ready: + */ + __pyx_v_self->_pos0 = (__pyx_v_self->_pos0 + __pyx_v_nbytes); + + /* "asyncpg/protocol/buffer.pyx":317 + * result += self._pos0 + * self._pos0 += nbytes + * self._length -= nbytes # <<<<<<<<<<<<<< + * if self._current_message_ready: + * self._current_message_len_unread -= nbytes + */ + __pyx_v_self->_length = (__pyx_v_self->_length - __pyx_v_nbytes); + + /* "asyncpg/protocol/buffer.pyx":318 + * self._pos0 += nbytes + * self._length -= nbytes + * if self._current_message_ready: # <<<<<<<<<<<<<< + * self._current_message_len_unread -= nbytes + * return result + */ + __pyx_t_1 = (__pyx_v_self->_current_message_ready != 0); + if (__pyx_t_1) { + + /* "asyncpg/protocol/buffer.pyx":319 + * self._length -= nbytes + * if self._current_message_ready: + * self._current_message_len_unread -= nbytes # <<<<<<<<<<<<<< + * return result + * else: + */ + __pyx_v_self->_current_message_len_unread = (__pyx_v_self->_current_message_len_unread - __pyx_v_nbytes); + + /* "asyncpg/protocol/buffer.pyx":318 + * self._pos0 += nbytes + * self._length -= nbytes + * if self._current_message_ready: # <<<<<<<<<<<<<< + * self._current_message_len_unread -= nbytes + * return result + */ + } + + /* "asyncpg/protocol/buffer.pyx":320 + * if self._current_message_ready: + * self._current_message_len_unread -= nbytes + * return result # <<<<<<<<<<<<<< + * else: + * return NULL + */ + __pyx_r = __pyx_v_result; + goto __pyx_L0; + + /* "asyncpg/protocol/buffer.pyx":313 + * return NULL + * + * if self._pos0 + nbytes <= self._len0: # <<<<<<<<<<<<<< + * result = cpython.PyBytes_AS_STRING(self._buf0) + * result += self._pos0 + */ + } + + /* "asyncpg/protocol/buffer.pyx":322 + * return result + * else: + * return NULL # <<<<<<<<<<<<<< + * + * cdef inline read(self, ssize_t nbytes): + */ + /*else*/ { + __pyx_r = NULL; + goto __pyx_L0; + } + + /* "asyncpg/protocol/buffer.pyx":298 + * 'debug: second buffer of ReadBuffer is empty') + * + * cdef inline char* _try_read_bytes(self, ssize_t nbytes): # <<<<<<<<<<<<<< + * # Important: caller must call _ensure_first_buf() prior + * # to calling try_read_bytes, and must not overread + */ + + /* function exit code */ + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "asyncpg/protocol/buffer.pyx":324 + * return NULL + * + * cdef inline read(self, ssize_t nbytes): # <<<<<<<<<<<<<< + * cdef: + * object result + */ + +static CYTHON_INLINE PyObject *__pyx_f_7asyncpg_8protocol_8protocol_10ReadBuffer_read(struct __pyx_obj_7asyncpg_8protocol_8protocol_ReadBuffer *__pyx_v_self, Py_ssize_t __pyx_v_nbytes) { + PyObject *__pyx_v_result = 0; + Py_ssize_t __pyx_v_nread; + char *__pyx_v_buf; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_t_2; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + PyObject *__pyx_t_5 = NULL; + PyObject *__pyx_t_6 = NULL; + PyObject *__pyx_t_7 = NULL; + PyObject *__pyx_t_8 = NULL; + Py_ssize_t __pyx_t_9; + Py_ssize_t __pyx_t_10; + __Pyx_RefNannySetupContext("read", 0); + + /* "asyncpg/protocol/buffer.pyx":330 + * char *buf + * + * self._ensure_first_buf() # <<<<<<<<<<<<<< + * buf = self._try_read_bytes(nbytes) + * if buf != NULL: + */ + __pyx_t_1 = __pyx_f_7asyncpg_8protocol_8protocol_10ReadBuffer__ensure_first_buf(__pyx_v_self); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 330, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "asyncpg/protocol/buffer.pyx":331 + * + * self._ensure_first_buf() + * buf = self._try_read_bytes(nbytes) # <<<<<<<<<<<<<< + * if buf != NULL: + * return Memory.new(buf, self._buf0, nbytes) + */ + __pyx_v_buf = __pyx_f_7asyncpg_8protocol_8protocol_10ReadBuffer__try_read_bytes(__pyx_v_self, __pyx_v_nbytes); + + /* "asyncpg/protocol/buffer.pyx":332 + * self._ensure_first_buf() + * buf = self._try_read_bytes(nbytes) + * if buf != NULL: # <<<<<<<<<<<<<< + * return Memory.new(buf, self._buf0, nbytes) + * + */ + __pyx_t_2 = ((__pyx_v_buf != NULL) != 0); + if (__pyx_t_2) { + + /* "asyncpg/protocol/buffer.pyx":333 + * buf = self._try_read_bytes(nbytes) + * if buf != NULL: + * return Memory.new(buf, self._buf0, nbytes) # <<<<<<<<<<<<<< + * + * if nbytes > self._length: + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __pyx_v_self->_buf0; + __Pyx_INCREF(__pyx_t_1); + __pyx_t_3 = ((PyObject *)__pyx_f_7asyncpg_8protocol_8protocol_6Memory_new(__pyx_v_buf, __pyx_t_1, __pyx_v_nbytes)); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 333, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_r = __pyx_t_3; + __pyx_t_3 = 0; + goto __pyx_L0; + + /* "asyncpg/protocol/buffer.pyx":332 + * self._ensure_first_buf() + * buf = self._try_read_bytes(nbytes) + * if buf != NULL: # <<<<<<<<<<<<<< + * return Memory.new(buf, self._buf0, nbytes) + * + */ + } + + /* "asyncpg/protocol/buffer.pyx":335 + * return Memory.new(buf, self._buf0, nbytes) + * + * if nbytes > self._length: # <<<<<<<<<<<<<< + * raise BufferError( + * 'not enough data to read {} bytes'.format(nbytes)) + */ + __pyx_t_2 = ((__pyx_v_nbytes > __pyx_v_self->_length) != 0); + if (__pyx_t_2) { + + /* "asyncpg/protocol/buffer.pyx":336 + * + * if nbytes > self._length: + * raise BufferError( # <<<<<<<<<<<<<< + * 'not enough data to read {} bytes'.format(nbytes)) + * + */ + __pyx_t_1 = __Pyx_GetModuleGlobalName(__pyx_n_s_BufferError); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 336, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + + /* "asyncpg/protocol/buffer.pyx":337 + * if nbytes > self._length: + * raise BufferError( + * 'not enough data to read {} bytes'.format(nbytes)) # <<<<<<<<<<<<<< + * + * if self._current_message_ready: + */ + __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_kp_u_not_enough_data_to_read_bytes, __pyx_n_s_format); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 337, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_6 = PyInt_FromSsize_t(__pyx_v_nbytes); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 337, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_7 = NULL; + if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_5))) { + __pyx_t_7 = PyMethod_GET_SELF(__pyx_t_5); + if (likely(__pyx_t_7)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_5); + __Pyx_INCREF(__pyx_t_7); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_5, function); + } + } + if (!__pyx_t_7) { + __pyx_t_4 = __Pyx_PyObject_CallOneArg(__pyx_t_5, __pyx_t_6); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 337, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_GOTREF(__pyx_t_4); + } else { + #if CYTHON_FAST_PYCALL + if (PyFunction_Check(__pyx_t_5)) { + PyObject *__pyx_temp[2] = {__pyx_t_7, __pyx_t_6}; + __pyx_t_4 = __Pyx_PyFunction_FastCall(__pyx_t_5, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 337, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + } else + #endif + #if CYTHON_FAST_PYCCALL + if (__Pyx_PyFastCFunction_Check(__pyx_t_5)) { + PyObject *__pyx_temp[2] = {__pyx_t_7, __pyx_t_6}; + __pyx_t_4 = __Pyx_PyCFunction_FastCall(__pyx_t_5, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 337, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + } else + #endif + { + __pyx_t_8 = PyTuple_New(1+1); if (unlikely(!__pyx_t_8)) __PYX_ERR(1, 337, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __Pyx_GIVEREF(__pyx_t_7); PyTuple_SET_ITEM(__pyx_t_8, 0, __pyx_t_7); __pyx_t_7 = NULL; + __Pyx_GIVEREF(__pyx_t_6); + PyTuple_SET_ITEM(__pyx_t_8, 0+1, __pyx_t_6); + __pyx_t_6 = 0; + __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_5, __pyx_t_8, NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 337, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + } + } + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __pyx_t_5 = NULL; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_1))) { + __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_1); + if (likely(__pyx_t_5)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_1); + __Pyx_INCREF(__pyx_t_5); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_1, function); + } + } + if (!__pyx_t_5) { + __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_t_1, __pyx_t_4); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 336, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_GOTREF(__pyx_t_3); + } else { + #if CYTHON_FAST_PYCALL + if (PyFunction_Check(__pyx_t_1)) { + PyObject *__pyx_temp[2] = {__pyx_t_5, __pyx_t_4}; + __pyx_t_3 = __Pyx_PyFunction_FastCall(__pyx_t_1, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 336, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + } else + #endif + #if CYTHON_FAST_PYCCALL + if (__Pyx_PyFastCFunction_Check(__pyx_t_1)) { + PyObject *__pyx_temp[2] = {__pyx_t_5, __pyx_t_4}; + __pyx_t_3 = __Pyx_PyCFunction_FastCall(__pyx_t_1, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 336, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + } else + #endif + { + __pyx_t_8 = PyTuple_New(1+1); if (unlikely(!__pyx_t_8)) __PYX_ERR(1, 336, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __Pyx_GIVEREF(__pyx_t_5); PyTuple_SET_ITEM(__pyx_t_8, 0, __pyx_t_5); __pyx_t_5 = NULL; + __Pyx_GIVEREF(__pyx_t_4); + PyTuple_SET_ITEM(__pyx_t_8, 0+1, __pyx_t_4); + __pyx_t_4 = 0; + __pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_t_8, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 336, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + } + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_Raise(__pyx_t_3, 0, 0, 0); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __PYX_ERR(1, 336, __pyx_L1_error) + + /* "asyncpg/protocol/buffer.pyx":335 + * return Memory.new(buf, self._buf0, nbytes) + * + * if nbytes > self._length: # <<<<<<<<<<<<<< + * raise BufferError( + * 'not enough data to read {} bytes'.format(nbytes)) + */ + } + + /* "asyncpg/protocol/buffer.pyx":339 + * 'not enough data to read {} bytes'.format(nbytes)) + * + * if self._current_message_ready: # <<<<<<<<<<<<<< + * self._current_message_len_unread -= nbytes + * if self._current_message_len_unread < 0: + */ + __pyx_t_2 = (__pyx_v_self->_current_message_ready != 0); + if (__pyx_t_2) { + + /* "asyncpg/protocol/buffer.pyx":340 + * + * if self._current_message_ready: + * self._current_message_len_unread -= nbytes # <<<<<<<<<<<<<< + * if self._current_message_len_unread < 0: + * raise BufferError('buffer overread') + */ + __pyx_v_self->_current_message_len_unread = (__pyx_v_self->_current_message_len_unread - __pyx_v_nbytes); + + /* "asyncpg/protocol/buffer.pyx":341 + * if self._current_message_ready: + * self._current_message_len_unread -= nbytes + * if self._current_message_len_unread < 0: # <<<<<<<<<<<<<< + * raise BufferError('buffer overread') + * + */ + __pyx_t_2 = ((__pyx_v_self->_current_message_len_unread < 0) != 0); + if (__pyx_t_2) { + + /* "asyncpg/protocol/buffer.pyx":342 + * self._current_message_len_unread -= nbytes + * if self._current_message_len_unread < 0: + * raise BufferError('buffer overread') # <<<<<<<<<<<<<< + * + * result = bytearray() + */ + __pyx_t_3 = __Pyx_GetModuleGlobalName(__pyx_n_s_BufferError); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 342, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_tuple__14, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 342, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_Raise(__pyx_t_1, 0, 0, 0); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __PYX_ERR(1, 342, __pyx_L1_error) + + /* "asyncpg/protocol/buffer.pyx":341 + * if self._current_message_ready: + * self._current_message_len_unread -= nbytes + * if self._current_message_len_unread < 0: # <<<<<<<<<<<<<< + * raise BufferError('buffer overread') + * + */ + } + + /* "asyncpg/protocol/buffer.pyx":339 + * 'not enough data to read {} bytes'.format(nbytes)) + * + * if self._current_message_ready: # <<<<<<<<<<<<<< + * self._current_message_len_unread -= nbytes + * if self._current_message_len_unread < 0: + */ + } + + /* "asyncpg/protocol/buffer.pyx":344 + * raise BufferError('buffer overread') + * + * result = bytearray() # <<<<<<<<<<<<<< + * while True: + * if self._pos0 + nbytes > self._len0: + */ + __pyx_t_1 = __Pyx_PyObject_Call(((PyObject *)(&PyByteArray_Type)), __pyx_empty_tuple, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 344, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_v_result = __pyx_t_1; + __pyx_t_1 = 0; + + /* "asyncpg/protocol/buffer.pyx":345 + * + * result = bytearray() + * while True: # <<<<<<<<<<<<<< + * if self._pos0 + nbytes > self._len0: + * result.extend(self._buf0[self._pos0:]) + */ + while (1) { + + /* "asyncpg/protocol/buffer.pyx":346 + * result = bytearray() + * while True: + * if self._pos0 + nbytes > self._len0: # <<<<<<<<<<<<<< + * result.extend(self._buf0[self._pos0:]) + * nread = self._len0 - self._pos0 + */ + __pyx_t_2 = (((__pyx_v_self->_pos0 + __pyx_v_nbytes) > __pyx_v_self->_len0) != 0); + if (__pyx_t_2) { + + /* "asyncpg/protocol/buffer.pyx":347 + * while True: + * if self._pos0 + nbytes > self._len0: + * result.extend(self._buf0[self._pos0:]) # <<<<<<<<<<<<<< + * nread = self._len0 - self._pos0 + * self._pos0 = self._len0 + */ + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_result, __pyx_n_s_extend); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 347, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + if (unlikely(__pyx_v_self->_buf0 == Py_None)) { + PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable"); + __PYX_ERR(1, 347, __pyx_L1_error) + } + __pyx_t_8 = PySequence_GetSlice(__pyx_v_self->_buf0, __pyx_v_self->_pos0, PY_SSIZE_T_MAX); if (unlikely(!__pyx_t_8)) __PYX_ERR(1, 347, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __pyx_t_4 = NULL; + if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_3))) { + __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_3); + if (likely(__pyx_t_4)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); + __Pyx_INCREF(__pyx_t_4); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_3, function); + } + } + if (!__pyx_t_4) { + __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_8); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 347, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + __Pyx_GOTREF(__pyx_t_1); + } else { + #if CYTHON_FAST_PYCALL + if (PyFunction_Check(__pyx_t_3)) { + PyObject *__pyx_temp[2] = {__pyx_t_4, __pyx_t_8}; + __pyx_t_1 = __Pyx_PyFunction_FastCall(__pyx_t_3, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 347, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + } else + #endif + #if CYTHON_FAST_PYCCALL + if (__Pyx_PyFastCFunction_Check(__pyx_t_3)) { + PyObject *__pyx_temp[2] = {__pyx_t_4, __pyx_t_8}; + __pyx_t_1 = __Pyx_PyCFunction_FastCall(__pyx_t_3, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 347, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + } else + #endif + { + __pyx_t_5 = PyTuple_New(1+1); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 347, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_GIVEREF(__pyx_t_4); PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_t_4); __pyx_t_4 = NULL; + __Pyx_GIVEREF(__pyx_t_8); + PyTuple_SET_ITEM(__pyx_t_5, 0+1, __pyx_t_8); + __pyx_t_8 = 0; + __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_t_5, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 347, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + } + } + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "asyncpg/protocol/buffer.pyx":348 + * if self._pos0 + nbytes > self._len0: + * result.extend(self._buf0[self._pos0:]) + * nread = self._len0 - self._pos0 # <<<<<<<<<<<<<< + * self._pos0 = self._len0 + * self._length -= nread + */ + __pyx_v_nread = (__pyx_v_self->_len0 - __pyx_v_self->_pos0); + + /* "asyncpg/protocol/buffer.pyx":349 + * result.extend(self._buf0[self._pos0:]) + * nread = self._len0 - self._pos0 + * self._pos0 = self._len0 # <<<<<<<<<<<<<< + * self._length -= nread + * nbytes -= nread + */ + __pyx_t_9 = __pyx_v_self->_len0; + __pyx_v_self->_pos0 = __pyx_t_9; + + /* "asyncpg/protocol/buffer.pyx":350 + * nread = self._len0 - self._pos0 + * self._pos0 = self._len0 + * self._length -= nread # <<<<<<<<<<<<<< + * nbytes -= nread + * self._ensure_first_buf() + */ + __pyx_v_self->_length = (__pyx_v_self->_length - __pyx_v_nread); + + /* "asyncpg/protocol/buffer.pyx":351 + * self._pos0 = self._len0 + * self._length -= nread + * nbytes -= nread # <<<<<<<<<<<<<< + * self._ensure_first_buf() + * + */ + __pyx_v_nbytes = (__pyx_v_nbytes - __pyx_v_nread); + + /* "asyncpg/protocol/buffer.pyx":352 + * self._length -= nread + * nbytes -= nread + * self._ensure_first_buf() # <<<<<<<<<<<<<< + * + * else: + */ + __pyx_t_1 = __pyx_f_7asyncpg_8protocol_8protocol_10ReadBuffer__ensure_first_buf(__pyx_v_self); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 352, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "asyncpg/protocol/buffer.pyx":346 + * result = bytearray() + * while True: + * if self._pos0 + nbytes > self._len0: # <<<<<<<<<<<<<< + * result.extend(self._buf0[self._pos0:]) + * nread = self._len0 - self._pos0 + */ + goto __pyx_L9; + } + + /* "asyncpg/protocol/buffer.pyx":355 + * + * else: + * result.extend(self._buf0[self._pos0:self._pos0 + nbytes]) # <<<<<<<<<<<<<< + * self._pos0 += nbytes + * self._length -= nbytes + */ + /*else*/ { + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_result, __pyx_n_s_extend); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 355, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + if (unlikely(__pyx_v_self->_buf0 == Py_None)) { + PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable"); + __PYX_ERR(1, 355, __pyx_L1_error) + } + __pyx_t_5 = PySequence_GetSlice(__pyx_v_self->_buf0, __pyx_v_self->_pos0, (__pyx_v_self->_pos0 + __pyx_v_nbytes)); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 355, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_8 = NULL; + if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_3))) { + __pyx_t_8 = PyMethod_GET_SELF(__pyx_t_3); + if (likely(__pyx_t_8)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); + __Pyx_INCREF(__pyx_t_8); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_3, function); + } + } + if (!__pyx_t_8) { + __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_5); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 355, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_GOTREF(__pyx_t_1); + } else { + #if CYTHON_FAST_PYCALL + if (PyFunction_Check(__pyx_t_3)) { + PyObject *__pyx_temp[2] = {__pyx_t_8, __pyx_t_5}; + __pyx_t_1 = __Pyx_PyFunction_FastCall(__pyx_t_3, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 355, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + } else + #endif + #if CYTHON_FAST_PYCCALL + if (__Pyx_PyFastCFunction_Check(__pyx_t_3)) { + PyObject *__pyx_temp[2] = {__pyx_t_8, __pyx_t_5}; + __pyx_t_1 = __Pyx_PyCFunction_FastCall(__pyx_t_3, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 355, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + } else + #endif + { + __pyx_t_4 = PyTuple_New(1+1); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 355, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_GIVEREF(__pyx_t_8); PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_8); __pyx_t_8 = NULL; + __Pyx_GIVEREF(__pyx_t_5); + PyTuple_SET_ITEM(__pyx_t_4, 0+1, __pyx_t_5); + __pyx_t_5 = 0; + __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_t_4, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 355, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + } + } + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "asyncpg/protocol/buffer.pyx":356 + * else: + * result.extend(self._buf0[self._pos0:self._pos0 + nbytes]) + * self._pos0 += nbytes # <<<<<<<<<<<<<< + * self._length -= nbytes + * return Memory.new( + */ + __pyx_v_self->_pos0 = (__pyx_v_self->_pos0 + __pyx_v_nbytes); + + /* "asyncpg/protocol/buffer.pyx":357 + * result.extend(self._buf0[self._pos0:self._pos0 + nbytes]) + * self._pos0 += nbytes + * self._length -= nbytes # <<<<<<<<<<<<<< + * return Memory.new( + * PyByteArray_AsString(result), + */ + __pyx_v_self->_length = (__pyx_v_self->_length - __pyx_v_nbytes); + + /* "asyncpg/protocol/buffer.pyx":358 + * self._pos0 += nbytes + * self._length -= nbytes + * return Memory.new( # <<<<<<<<<<<<<< + * PyByteArray_AsString(result), + * result, + */ + __Pyx_XDECREF(__pyx_r); + + /* "asyncpg/protocol/buffer.pyx":361 + * PyByteArray_AsString(result), + * result, + * len(result)) # <<<<<<<<<<<<<< + * + * cdef inline read_byte(self): + */ + __pyx_t_10 = PyObject_Length(__pyx_v_result); if (unlikely(__pyx_t_10 == -1)) __PYX_ERR(1, 361, __pyx_L1_error) + + /* "asyncpg/protocol/buffer.pyx":358 + * self._pos0 += nbytes + * self._length -= nbytes + * return Memory.new( # <<<<<<<<<<<<<< + * PyByteArray_AsString(result), + * result, + */ + __pyx_t_1 = ((PyObject *)__pyx_f_7asyncpg_8protocol_8protocol_6Memory_new(PyByteArray_AsString(__pyx_v_result), __pyx_v_result, __pyx_t_10)); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 358, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + } + __pyx_L9:; + } + + /* "asyncpg/protocol/buffer.pyx":324 + * return NULL + * + * cdef inline read(self, ssize_t nbytes): # <<<<<<<<<<<<<< + * cdef: + * object result + */ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_XDECREF(__pyx_t_6); + __Pyx_XDECREF(__pyx_t_7); + __Pyx_XDECREF(__pyx_t_8); + __Pyx_AddTraceback("asyncpg.protocol.protocol.ReadBuffer.read", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XDECREF(__pyx_v_result); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "asyncpg/protocol/buffer.pyx":363 + * len(result)) + * + * cdef inline read_byte(self): # <<<<<<<<<<<<<< + * cdef char* first_byte + * + */ + +static CYTHON_INLINE PyObject *__pyx_f_7asyncpg_8protocol_8protocol_10ReadBuffer_read_byte(struct __pyx_obj_7asyncpg_8protocol_8protocol_ReadBuffer *__pyx_v_self) { + char *__pyx_v_first_byte; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + int __pyx_t_2; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + __Pyx_RefNannySetupContext("read_byte", 0); + + /* "asyncpg/protocol/buffer.pyx":366 + * cdef char* first_byte + * + * if ASYNCPG_DEBUG: # <<<<<<<<<<<<<< + * if not self._buf0: + * raise RuntimeError( + */ + __pyx_t_1 = (ASYNCPG_DEBUG != 0); + if (__pyx_t_1) { + + /* "asyncpg/protocol/buffer.pyx":367 + * + * if ASYNCPG_DEBUG: + * if not self._buf0: # <<<<<<<<<<<<<< + * raise RuntimeError( + * 'debug: first buffer of ReadBuffer is empty') + */ + __pyx_t_1 = (__pyx_v_self->_buf0 != Py_None) && (PyBytes_GET_SIZE(__pyx_v_self->_buf0) != 0); + __pyx_t_2 = ((!__pyx_t_1) != 0); + if (__pyx_t_2) { + + /* "asyncpg/protocol/buffer.pyx":368 + * if ASYNCPG_DEBUG: + * if not self._buf0: + * raise RuntimeError( # <<<<<<<<<<<<<< + * 'debug: first buffer of ReadBuffer is empty') + * + */ + __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_RuntimeError, __pyx_tuple__15, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 368, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_Raise(__pyx_t_3, 0, 0, 0); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __PYX_ERR(1, 368, __pyx_L1_error) + + /* "asyncpg/protocol/buffer.pyx":367 + * + * if ASYNCPG_DEBUG: + * if not self._buf0: # <<<<<<<<<<<<<< + * raise RuntimeError( + * 'debug: first buffer of ReadBuffer is empty') + */ + } + + /* "asyncpg/protocol/buffer.pyx":366 + * cdef char* first_byte + * + * if ASYNCPG_DEBUG: # <<<<<<<<<<<<<< + * if not self._buf0: + * raise RuntimeError( + */ + } + + /* "asyncpg/protocol/buffer.pyx":371 + * 'debug: first buffer of ReadBuffer is empty') + * + * self._ensure_first_buf() # <<<<<<<<<<<<<< + * first_byte = self._try_read_bytes(1) + * if first_byte is NULL: + */ + __pyx_t_3 = __pyx_f_7asyncpg_8protocol_8protocol_10ReadBuffer__ensure_first_buf(__pyx_v_self); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 371, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + + /* "asyncpg/protocol/buffer.pyx":372 + * + * self._ensure_first_buf() + * first_byte = self._try_read_bytes(1) # <<<<<<<<<<<<<< + * if first_byte is NULL: + * raise BufferError('not enough data to read one byte') + */ + __pyx_v_first_byte = __pyx_f_7asyncpg_8protocol_8protocol_10ReadBuffer__try_read_bytes(__pyx_v_self, 1); + + /* "asyncpg/protocol/buffer.pyx":373 + * self._ensure_first_buf() + * first_byte = self._try_read_bytes(1) + * if first_byte is NULL: # <<<<<<<<<<<<<< + * raise BufferError('not enough data to read one byte') + * + */ + __pyx_t_2 = ((__pyx_v_first_byte == NULL) != 0); + if (__pyx_t_2) { + + /* "asyncpg/protocol/buffer.pyx":374 + * first_byte = self._try_read_bytes(1) + * if first_byte is NULL: + * raise BufferError('not enough data to read one byte') # <<<<<<<<<<<<<< + * + * return first_byte[0] + */ + __pyx_t_3 = __Pyx_GetModuleGlobalName(__pyx_n_s_BufferError); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 374, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_tuple__16, NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 374, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_Raise(__pyx_t_4, 0, 0, 0); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __PYX_ERR(1, 374, __pyx_L1_error) + + /* "asyncpg/protocol/buffer.pyx":373 + * self._ensure_first_buf() + * first_byte = self._try_read_bytes(1) + * if first_byte is NULL: # <<<<<<<<<<<<<< + * raise BufferError('not enough data to read one byte') + * + */ + } + + /* "asyncpg/protocol/buffer.pyx":376 + * raise BufferError('not enough data to read one byte') + * + * return first_byte[0] # <<<<<<<<<<<<<< + * + * cdef inline read_bytes(self, ssize_t n): + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_4 = __Pyx_PyInt_From_char((__pyx_v_first_byte[0])); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 376, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_r = __pyx_t_4; + __pyx_t_4 = 0; + goto __pyx_L0; + + /* "asyncpg/protocol/buffer.pyx":363 + * len(result)) + * + * cdef inline read_byte(self): # <<<<<<<<<<<<<< + * cdef char* first_byte + * + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_AddTraceback("asyncpg.protocol.protocol.ReadBuffer.read_byte", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "asyncpg/protocol/buffer.pyx":378 + * return first_byte[0] + * + * cdef inline read_bytes(self, ssize_t n): # <<<<<<<<<<<<<< + * cdef: + * Memory mem + */ + +static CYTHON_INLINE PyObject *__pyx_f_7asyncpg_8protocol_8protocol_10ReadBuffer_read_bytes(struct __pyx_obj_7asyncpg_8protocol_8protocol_ReadBuffer *__pyx_v_self, Py_ssize_t __pyx_v_n) { + struct __pyx_obj_7asyncpg_8protocol_8protocol_Memory *__pyx_v_mem = 0; + char *__pyx_v_cbuf; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_t_2; + PyObject *__pyx_t_3 = NULL; + __Pyx_RefNannySetupContext("read_bytes", 0); + + /* "asyncpg/protocol/buffer.pyx":383 + * char *cbuf + * + * self._ensure_first_buf() # <<<<<<<<<<<<<< + * cbuf = self._try_read_bytes(n) + * if cbuf != NULL: + */ + __pyx_t_1 = __pyx_f_7asyncpg_8protocol_8protocol_10ReadBuffer__ensure_first_buf(__pyx_v_self); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 383, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "asyncpg/protocol/buffer.pyx":384 + * + * self._ensure_first_buf() + * cbuf = self._try_read_bytes(n) # <<<<<<<<<<<<<< + * if cbuf != NULL: + * return cbuf + */ + __pyx_v_cbuf = __pyx_f_7asyncpg_8protocol_8protocol_10ReadBuffer__try_read_bytes(__pyx_v_self, __pyx_v_n); + + /* "asyncpg/protocol/buffer.pyx":385 + * self._ensure_first_buf() + * cbuf = self._try_read_bytes(n) + * if cbuf != NULL: # <<<<<<<<<<<<<< + * return cbuf + * else: + */ + __pyx_t_2 = ((__pyx_v_cbuf != NULL) != 0); + if (__pyx_t_2) { + + /* "asyncpg/protocol/buffer.pyx":386 + * cbuf = self._try_read_bytes(n) + * if cbuf != NULL: + * return cbuf # <<<<<<<<<<<<<< + * else: + * mem = (self.read(n)) + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyBytes_FromString(__pyx_v_cbuf); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 386, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "asyncpg/protocol/buffer.pyx":385 + * self._ensure_first_buf() + * cbuf = self._try_read_bytes(n) + * if cbuf != NULL: # <<<<<<<<<<<<<< + * return cbuf + * else: + */ + } + + /* "asyncpg/protocol/buffer.pyx":388 + * return cbuf + * else: + * mem = (self.read(n)) # <<<<<<<<<<<<<< + * return mem.buf + * + */ + /*else*/ { + __pyx_t_1 = __pyx_f_7asyncpg_8protocol_8protocol_10ReadBuffer_read(__pyx_v_self, __pyx_v_n); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 388, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_3 = __pyx_t_1; + __Pyx_INCREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_v_mem = ((struct __pyx_obj_7asyncpg_8protocol_8protocol_Memory *)__pyx_t_3); + __pyx_t_3 = 0; + + /* "asyncpg/protocol/buffer.pyx":389 + * else: + * mem = (self.read(n)) + * return mem.buf # <<<<<<<<<<<<<< + * + * cdef inline read_int32(self): + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_3 = __Pyx_PyBytes_FromString(__pyx_v_mem->buf); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 389, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_r = __pyx_t_3; + __pyx_t_3 = 0; + goto __pyx_L0; + } + + /* "asyncpg/protocol/buffer.pyx":378 + * return first_byte[0] + * + * cdef inline read_bytes(self, ssize_t n): # <<<<<<<<<<<<<< + * cdef: + * Memory mem + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_AddTraceback("asyncpg.protocol.protocol.ReadBuffer.read_bytes", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XDECREF((PyObject *)__pyx_v_mem); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "asyncpg/protocol/buffer.pyx":391 + * return mem.buf + * + * cdef inline read_int32(self): # <<<<<<<<<<<<<< + * cdef: + * Memory mem + */ + +static CYTHON_INLINE PyObject *__pyx_f_7asyncpg_8protocol_8protocol_10ReadBuffer_read_int32(struct __pyx_obj_7asyncpg_8protocol_8protocol_ReadBuffer *__pyx_v_self) { + struct __pyx_obj_7asyncpg_8protocol_8protocol_Memory *__pyx_v_mem = 0; + char *__pyx_v_cbuf; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_t_2; + PyObject *__pyx_t_3 = NULL; + __Pyx_RefNannySetupContext("read_int32", 0); + + /* "asyncpg/protocol/buffer.pyx":396 + * char *cbuf + * + * self._ensure_first_buf() # <<<<<<<<<<<<<< + * cbuf = self._try_read_bytes(4) + * if cbuf != NULL: + */ + __pyx_t_1 = __pyx_f_7asyncpg_8protocol_8protocol_10ReadBuffer__ensure_first_buf(__pyx_v_self); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 396, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "asyncpg/protocol/buffer.pyx":397 + * + * self._ensure_first_buf() + * cbuf = self._try_read_bytes(4) # <<<<<<<<<<<<<< + * if cbuf != NULL: + * return hton.unpack_int32(cbuf) + */ + __pyx_v_cbuf = __pyx_f_7asyncpg_8protocol_8protocol_10ReadBuffer__try_read_bytes(__pyx_v_self, 4); + + /* "asyncpg/protocol/buffer.pyx":398 + * self._ensure_first_buf() + * cbuf = self._try_read_bytes(4) + * if cbuf != NULL: # <<<<<<<<<<<<<< + * return hton.unpack_int32(cbuf) + * else: + */ + __pyx_t_2 = ((__pyx_v_cbuf != NULL) != 0); + if (__pyx_t_2) { + + /* "asyncpg/protocol/buffer.pyx":399 + * cbuf = self._try_read_bytes(4) + * if cbuf != NULL: + * return hton.unpack_int32(cbuf) # <<<<<<<<<<<<<< + * else: + * mem = (self.read(4)) + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyInt_From_int32_t(__pyx_f_7asyncpg_8protocol_4hton_unpack_int32(__pyx_v_cbuf)); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 399, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "asyncpg/protocol/buffer.pyx":398 + * self._ensure_first_buf() + * cbuf = self._try_read_bytes(4) + * if cbuf != NULL: # <<<<<<<<<<<<<< + * return hton.unpack_int32(cbuf) + * else: + */ + } + + /* "asyncpg/protocol/buffer.pyx":401 + * return hton.unpack_int32(cbuf) + * else: + * mem = (self.read(4)) # <<<<<<<<<<<<<< + * return hton.unpack_int32(mem.buf) + * + */ + /*else*/ { + __pyx_t_1 = __pyx_f_7asyncpg_8protocol_8protocol_10ReadBuffer_read(__pyx_v_self, 4); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 401, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_3 = __pyx_t_1; + __Pyx_INCREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_v_mem = ((struct __pyx_obj_7asyncpg_8protocol_8protocol_Memory *)__pyx_t_3); + __pyx_t_3 = 0; + + /* "asyncpg/protocol/buffer.pyx":402 + * else: + * mem = (self.read(4)) + * return hton.unpack_int32(mem.buf) # <<<<<<<<<<<<<< + * + * cdef inline read_int16(self): + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_3 = __Pyx_PyInt_From_int32_t(__pyx_f_7asyncpg_8protocol_4hton_unpack_int32(__pyx_v_mem->buf)); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 402, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_r = __pyx_t_3; + __pyx_t_3 = 0; + goto __pyx_L0; + } + + /* "asyncpg/protocol/buffer.pyx":391 + * return mem.buf + * + * cdef inline read_int32(self): # <<<<<<<<<<<<<< + * cdef: + * Memory mem + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_AddTraceback("asyncpg.protocol.protocol.ReadBuffer.read_int32", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XDECREF((PyObject *)__pyx_v_mem); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "asyncpg/protocol/buffer.pyx":404 + * return hton.unpack_int32(mem.buf) + * + * cdef inline read_int16(self): # <<<<<<<<<<<<<< + * cdef: + * Memory mem + */ + +static CYTHON_INLINE PyObject *__pyx_f_7asyncpg_8protocol_8protocol_10ReadBuffer_read_int16(struct __pyx_obj_7asyncpg_8protocol_8protocol_ReadBuffer *__pyx_v_self) { + struct __pyx_obj_7asyncpg_8protocol_8protocol_Memory *__pyx_v_mem = 0; + char *__pyx_v_cbuf; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_t_2; + PyObject *__pyx_t_3 = NULL; + __Pyx_RefNannySetupContext("read_int16", 0); + + /* "asyncpg/protocol/buffer.pyx":409 + * char *cbuf + * + * self._ensure_first_buf() # <<<<<<<<<<<<<< + * cbuf = self._try_read_bytes(2) + * if cbuf != NULL: + */ + __pyx_t_1 = __pyx_f_7asyncpg_8protocol_8protocol_10ReadBuffer__ensure_first_buf(__pyx_v_self); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 409, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "asyncpg/protocol/buffer.pyx":410 + * + * self._ensure_first_buf() + * cbuf = self._try_read_bytes(2) # <<<<<<<<<<<<<< + * if cbuf != NULL: + * return hton.unpack_int16(cbuf) + */ + __pyx_v_cbuf = __pyx_f_7asyncpg_8protocol_8protocol_10ReadBuffer__try_read_bytes(__pyx_v_self, 2); + + /* "asyncpg/protocol/buffer.pyx":411 + * self._ensure_first_buf() + * cbuf = self._try_read_bytes(2) + * if cbuf != NULL: # <<<<<<<<<<<<<< + * return hton.unpack_int16(cbuf) + * else: + */ + __pyx_t_2 = ((__pyx_v_cbuf != NULL) != 0); + if (__pyx_t_2) { + + /* "asyncpg/protocol/buffer.pyx":412 + * cbuf = self._try_read_bytes(2) + * if cbuf != NULL: + * return hton.unpack_int16(cbuf) # <<<<<<<<<<<<<< + * else: + * mem = (self.read(2)) + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyInt_From_int16_t(__pyx_f_7asyncpg_8protocol_4hton_unpack_int16(__pyx_v_cbuf)); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 412, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "asyncpg/protocol/buffer.pyx":411 + * self._ensure_first_buf() + * cbuf = self._try_read_bytes(2) + * if cbuf != NULL: # <<<<<<<<<<<<<< + * return hton.unpack_int16(cbuf) + * else: + */ + } + + /* "asyncpg/protocol/buffer.pyx":414 + * return hton.unpack_int16(cbuf) + * else: + * mem = (self.read(2)) # <<<<<<<<<<<<<< + * return hton.unpack_int16(mem.buf) + * + */ + /*else*/ { + __pyx_t_1 = __pyx_f_7asyncpg_8protocol_8protocol_10ReadBuffer_read(__pyx_v_self, 2); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 414, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_3 = __pyx_t_1; + __Pyx_INCREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_v_mem = ((struct __pyx_obj_7asyncpg_8protocol_8protocol_Memory *)__pyx_t_3); + __pyx_t_3 = 0; + + /* "asyncpg/protocol/buffer.pyx":415 + * else: + * mem = (self.read(2)) + * return hton.unpack_int16(mem.buf) # <<<<<<<<<<<<<< + * + * cdef inline read_cstr(self): + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_3 = __Pyx_PyInt_From_int16_t(__pyx_f_7asyncpg_8protocol_4hton_unpack_int16(__pyx_v_mem->buf)); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 415, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_r = __pyx_t_3; + __pyx_t_3 = 0; + goto __pyx_L0; + } + + /* "asyncpg/protocol/buffer.pyx":404 + * return hton.unpack_int32(mem.buf) + * + * cdef inline read_int16(self): # <<<<<<<<<<<<<< + * cdef: + * Memory mem + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_AddTraceback("asyncpg.protocol.protocol.ReadBuffer.read_int16", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XDECREF((PyObject *)__pyx_v_mem); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "asyncpg/protocol/buffer.pyx":417 + * return hton.unpack_int16(mem.buf) + * + * cdef inline read_cstr(self): # <<<<<<<<<<<<<< + * if not self._current_message_ready: + * raise BufferError( + */ + +static CYTHON_INLINE PyObject *__pyx_f_7asyncpg_8protocol_8protocol_10ReadBuffer_read_cstr(struct __pyx_obj_7asyncpg_8protocol_8protocol_ReadBuffer *__pyx_v_self) { + Py_ssize_t __pyx_v_pos; + Py_ssize_t __pyx_v_nread; + PyObject *__pyx_v_result = 0; + char *__pyx_v_buf; + char *__pyx_v_buf_start; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + PyObject *__pyx_t_5 = NULL; + int __pyx_t_6; + PyObject *__pyx_t_7 = NULL; + Py_ssize_t __pyx_t_8; + __Pyx_RefNannySetupContext("read_cstr", 0); + + /* "asyncpg/protocol/buffer.pyx":418 + * + * cdef inline read_cstr(self): + * if not self._current_message_ready: # <<<<<<<<<<<<<< + * raise BufferError( + * 'read_cstr only works when the message guaranteed ' + */ + __pyx_t_1 = ((!(__pyx_v_self->_current_message_ready != 0)) != 0); + if (__pyx_t_1) { + + /* "asyncpg/protocol/buffer.pyx":419 + * cdef inline read_cstr(self): + * if not self._current_message_ready: + * raise BufferError( # <<<<<<<<<<<<<< + * 'read_cstr only works when the message guaranteed ' + * 'to be in the buffer') + */ + __pyx_t_2 = __Pyx_GetModuleGlobalName(__pyx_n_s_BufferError); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 419, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_tuple__17, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 419, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_Raise(__pyx_t_3, 0, 0, 0); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __PYX_ERR(1, 419, __pyx_L1_error) + + /* "asyncpg/protocol/buffer.pyx":418 + * + * cdef inline read_cstr(self): + * if not self._current_message_ready: # <<<<<<<<<<<<<< + * raise BufferError( + * 'read_cstr only works when the message guaranteed ' + */ + } + + /* "asyncpg/protocol/buffer.pyx":430 + * char* buf_start + * + * self._ensure_first_buf() # <<<<<<<<<<<<<< + * + * buf_start = cpython.PyBytes_AS_STRING(self._buf0) + */ + __pyx_t_3 = __pyx_f_7asyncpg_8protocol_8protocol_10ReadBuffer__ensure_first_buf(__pyx_v_self); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 430, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + + /* "asyncpg/protocol/buffer.pyx":432 + * self._ensure_first_buf() + * + * buf_start = cpython.PyBytes_AS_STRING(self._buf0) # <<<<<<<<<<<<<< + * buf = buf_start + self._pos0 + * while buf - buf_start < self._len0: + */ + __pyx_t_3 = __pyx_v_self->_buf0; + __Pyx_INCREF(__pyx_t_3); + __pyx_v_buf_start = PyBytes_AS_STRING(__pyx_t_3); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + + /* "asyncpg/protocol/buffer.pyx":433 + * + * buf_start = cpython.PyBytes_AS_STRING(self._buf0) + * buf = buf_start + self._pos0 # <<<<<<<<<<<<<< + * while buf - buf_start < self._len0: + * if buf[0] == 0: + */ + __pyx_v_buf = (__pyx_v_buf_start + __pyx_v_self->_pos0); + + /* "asyncpg/protocol/buffer.pyx":434 + * buf_start = cpython.PyBytes_AS_STRING(self._buf0) + * buf = buf_start + self._pos0 + * while buf - buf_start < self._len0: # <<<<<<<<<<<<<< + * if buf[0] == 0: + * pos = buf - buf_start + */ + while (1) { + __pyx_t_1 = (((__pyx_v_buf - __pyx_v_buf_start) < __pyx_v_self->_len0) != 0); + if (!__pyx_t_1) break; + + /* "asyncpg/protocol/buffer.pyx":435 + * buf = buf_start + self._pos0 + * while buf - buf_start < self._len0: + * if buf[0] == 0: # <<<<<<<<<<<<<< + * pos = buf - buf_start + * nread = pos - self._pos0 + */ + __pyx_t_1 = (((__pyx_v_buf[0]) == 0) != 0); + if (__pyx_t_1) { + + /* "asyncpg/protocol/buffer.pyx":436 + * while buf - buf_start < self._len0: + * if buf[0] == 0: + * pos = buf - buf_start # <<<<<<<<<<<<<< + * nread = pos - self._pos0 + * buf = self._try_read_bytes(nread + 1) + */ + __pyx_v_pos = (__pyx_v_buf - __pyx_v_buf_start); + + /* "asyncpg/protocol/buffer.pyx":437 + * if buf[0] == 0: + * pos = buf - buf_start + * nread = pos - self._pos0 # <<<<<<<<<<<<<< + * buf = self._try_read_bytes(nread + 1) + * if buf != NULL: + */ + __pyx_v_nread = (__pyx_v_pos - __pyx_v_self->_pos0); + + /* "asyncpg/protocol/buffer.pyx":438 + * pos = buf - buf_start + * nread = pos - self._pos0 + * buf = self._try_read_bytes(nread + 1) # <<<<<<<<<<<<<< + * if buf != NULL: + * return cpython.PyBytes_FromStringAndSize(buf, nread) + */ + __pyx_v_buf = __pyx_f_7asyncpg_8protocol_8protocol_10ReadBuffer__try_read_bytes(__pyx_v_self, (__pyx_v_nread + 1)); + + /* "asyncpg/protocol/buffer.pyx":439 + * nread = pos - self._pos0 + * buf = self._try_read_bytes(nread + 1) + * if buf != NULL: # <<<<<<<<<<<<<< + * return cpython.PyBytes_FromStringAndSize(buf, nread) + * else: + */ + __pyx_t_1 = ((__pyx_v_buf != NULL) != 0); + if (__pyx_t_1) { + + /* "asyncpg/protocol/buffer.pyx":440 + * buf = self._try_read_bytes(nread + 1) + * if buf != NULL: + * return cpython.PyBytes_FromStringAndSize(buf, nread) # <<<<<<<<<<<<<< + * else: + * break + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_3 = PyBytes_FromStringAndSize(__pyx_v_buf, __pyx_v_nread); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 440, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_r = __pyx_t_3; + __pyx_t_3 = 0; + goto __pyx_L0; + + /* "asyncpg/protocol/buffer.pyx":439 + * nread = pos - self._pos0 + * buf = self._try_read_bytes(nread + 1) + * if buf != NULL: # <<<<<<<<<<<<<< + * return cpython.PyBytes_FromStringAndSize(buf, nread) + * else: + */ + } + + /* "asyncpg/protocol/buffer.pyx":442 + * return cpython.PyBytes_FromStringAndSize(buf, nread) + * else: + * break # <<<<<<<<<<<<<< + * else: + * buf += 1 + */ + /*else*/ { + goto __pyx_L5_break; + } + + /* "asyncpg/protocol/buffer.pyx":435 + * buf = buf_start + self._pos0 + * while buf - buf_start < self._len0: + * if buf[0] == 0: # <<<<<<<<<<<<<< + * pos = buf - buf_start + * nread = pos - self._pos0 + */ + } + + /* "asyncpg/protocol/buffer.pyx":444 + * break + * else: + * buf += 1 # <<<<<<<<<<<<<< + * + * result = b'' + */ + /*else*/ { + __pyx_v_buf = (__pyx_v_buf + 1); + } + } + __pyx_L5_break:; + + /* "asyncpg/protocol/buffer.pyx":446 + * buf += 1 + * + * result = b'' # <<<<<<<<<<<<<< + * while True: + * pos = self._buf0.find(b'\x00', self._pos0) + */ + __Pyx_INCREF(__pyx_kp_b__18); + __pyx_v_result = __pyx_kp_b__18; + + /* "asyncpg/protocol/buffer.pyx":447 + * + * result = b'' + * while True: # <<<<<<<<<<<<<< + * pos = self._buf0.find(b'\x00', self._pos0) + * if pos >= 0: + */ + while (1) { + + /* "asyncpg/protocol/buffer.pyx":448 + * result = b'' + * while True: + * pos = self._buf0.find(b'\x00', self._pos0) # <<<<<<<<<<<<<< + * if pos >= 0: + * result += self._buf0[self._pos0 : pos] + */ + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_self->_buf0, __pyx_n_s_find); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 448, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_4 = PyInt_FromSsize_t(__pyx_v_self->_pos0); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 448, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_5 = NULL; + __pyx_t_6 = 0; + if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_5)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_5); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + __pyx_t_6 = 1; + } + } + #if CYTHON_FAST_PYCALL + if (PyFunction_Check(__pyx_t_2)) { + PyObject *__pyx_temp[3] = {__pyx_t_5, __pyx_kp_b__19, __pyx_t_4}; + __pyx_t_3 = __Pyx_PyFunction_FastCall(__pyx_t_2, __pyx_temp+1-__pyx_t_6, 2+__pyx_t_6); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 448, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + } else + #endif + #if CYTHON_FAST_PYCCALL + if (__Pyx_PyFastCFunction_Check(__pyx_t_2)) { + PyObject *__pyx_temp[3] = {__pyx_t_5, __pyx_kp_b__19, __pyx_t_4}; + __pyx_t_3 = __Pyx_PyCFunction_FastCall(__pyx_t_2, __pyx_temp+1-__pyx_t_6, 2+__pyx_t_6); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 448, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + } else + #endif + { + __pyx_t_7 = PyTuple_New(2+__pyx_t_6); if (unlikely(!__pyx_t_7)) __PYX_ERR(1, 448, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + if (__pyx_t_5) { + __Pyx_GIVEREF(__pyx_t_5); PyTuple_SET_ITEM(__pyx_t_7, 0, __pyx_t_5); __pyx_t_5 = NULL; + } + __Pyx_INCREF(__pyx_kp_b__19); + __Pyx_GIVEREF(__pyx_kp_b__19); + PyTuple_SET_ITEM(__pyx_t_7, 0+__pyx_t_6, __pyx_kp_b__19); + __Pyx_GIVEREF(__pyx_t_4); + PyTuple_SET_ITEM(__pyx_t_7, 1+__pyx_t_6, __pyx_t_4); + __pyx_t_4 = 0; + __pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_t_7, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 448, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + } + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_8 = PyInt_AsSsize_t(__pyx_t_3); if (unlikely((__pyx_t_8 == (Py_ssize_t)-1) && PyErr_Occurred())) __PYX_ERR(1, 448, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_v_pos = __pyx_t_8; + + /* "asyncpg/protocol/buffer.pyx":449 + * while True: + * pos = self._buf0.find(b'\x00', self._pos0) + * if pos >= 0: # <<<<<<<<<<<<<< + * result += self._buf0[self._pos0 : pos] + * nread = pos - self._pos0 + 1 + */ + __pyx_t_1 = ((__pyx_v_pos >= 0) != 0); + if (__pyx_t_1) { + + /* "asyncpg/protocol/buffer.pyx":450 + * pos = self._buf0.find(b'\x00', self._pos0) + * if pos >= 0: + * result += self._buf0[self._pos0 : pos] # <<<<<<<<<<<<<< + * nread = pos - self._pos0 + 1 + * self._pos0 = pos + 1 + */ + if (unlikely(__pyx_v_self->_buf0 == Py_None)) { + PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable"); + __PYX_ERR(1, 450, __pyx_L1_error) + } + __pyx_t_3 = PySequence_GetSlice(__pyx_v_self->_buf0, __pyx_v_self->_pos0, __pyx_v_pos); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 450, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_2 = PyNumber_InPlaceAdd(__pyx_v_result, __pyx_t_3); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 450, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_DECREF_SET(__pyx_v_result, ((PyObject*)__pyx_t_2)); + __pyx_t_2 = 0; + + /* "asyncpg/protocol/buffer.pyx":451 + * if pos >= 0: + * result += self._buf0[self._pos0 : pos] + * nread = pos - self._pos0 + 1 # <<<<<<<<<<<<<< + * self._pos0 = pos + 1 + * self._length -= nread + */ + __pyx_v_nread = ((__pyx_v_pos - __pyx_v_self->_pos0) + 1); + + /* "asyncpg/protocol/buffer.pyx":452 + * result += self._buf0[self._pos0 : pos] + * nread = pos - self._pos0 + 1 + * self._pos0 = pos + 1 # <<<<<<<<<<<<<< + * self._length -= nread + * + */ + __pyx_v_self->_pos0 = (__pyx_v_pos + 1); + + /* "asyncpg/protocol/buffer.pyx":453 + * nread = pos - self._pos0 + 1 + * self._pos0 = pos + 1 + * self._length -= nread # <<<<<<<<<<<<<< + * + * self._current_message_len_unread -= nread + */ + __pyx_v_self->_length = (__pyx_v_self->_length - __pyx_v_nread); + + /* "asyncpg/protocol/buffer.pyx":455 + * self._length -= nread + * + * self._current_message_len_unread -= nread # <<<<<<<<<<<<<< + * if self._current_message_len_unread < 0: + * raise BufferError('read_cstr: buffer overread') + */ + __pyx_v_self->_current_message_len_unread = (__pyx_v_self->_current_message_len_unread - __pyx_v_nread); + + /* "asyncpg/protocol/buffer.pyx":456 + * + * self._current_message_len_unread -= nread + * if self._current_message_len_unread < 0: # <<<<<<<<<<<<<< + * raise BufferError('read_cstr: buffer overread') + * + */ + __pyx_t_1 = ((__pyx_v_self->_current_message_len_unread < 0) != 0); + if (__pyx_t_1) { + + /* "asyncpg/protocol/buffer.pyx":457 + * self._current_message_len_unread -= nread + * if self._current_message_len_unread < 0: + * raise BufferError('read_cstr: buffer overread') # <<<<<<<<<<<<<< + * + * return result + */ + __pyx_t_2 = __Pyx_GetModuleGlobalName(__pyx_n_s_BufferError); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 457, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_tuple__20, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 457, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_Raise(__pyx_t_3, 0, 0, 0); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __PYX_ERR(1, 457, __pyx_L1_error) + + /* "asyncpg/protocol/buffer.pyx":456 + * + * self._current_message_len_unread -= nread + * if self._current_message_len_unread < 0: # <<<<<<<<<<<<<< + * raise BufferError('read_cstr: buffer overread') + * + */ + } + + /* "asyncpg/protocol/buffer.pyx":459 + * raise BufferError('read_cstr: buffer overread') + * + * return result # <<<<<<<<<<<<<< + * + * else: + */ + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(__pyx_v_result); + __pyx_r = __pyx_v_result; + goto __pyx_L0; + + /* "asyncpg/protocol/buffer.pyx":449 + * while True: + * pos = self._buf0.find(b'\x00', self._pos0) + * if pos >= 0: # <<<<<<<<<<<<<< + * result += self._buf0[self._pos0 : pos] + * nread = pos - self._pos0 + 1 + */ + } + + /* "asyncpg/protocol/buffer.pyx":462 + * + * else: + * result += self._buf0[self._pos0:] # <<<<<<<<<<<<<< + * nread = self._len0 - self._pos0 + * self._pos0 = self._len0 + */ + /*else*/ { + if (unlikely(__pyx_v_self->_buf0 == Py_None)) { + PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable"); + __PYX_ERR(1, 462, __pyx_L1_error) + } + __pyx_t_3 = PySequence_GetSlice(__pyx_v_self->_buf0, __pyx_v_self->_pos0, PY_SSIZE_T_MAX); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 462, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_2 = PyNumber_InPlaceAdd(__pyx_v_result, __pyx_t_3); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 462, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_DECREF_SET(__pyx_v_result, ((PyObject*)__pyx_t_2)); + __pyx_t_2 = 0; + + /* "asyncpg/protocol/buffer.pyx":463 + * else: + * result += self._buf0[self._pos0:] + * nread = self._len0 - self._pos0 # <<<<<<<<<<<<<< + * self._pos0 = self._len0 + * self._length -= nread + */ + __pyx_v_nread = (__pyx_v_self->_len0 - __pyx_v_self->_pos0); + + /* "asyncpg/protocol/buffer.pyx":464 + * result += self._buf0[self._pos0:] + * nread = self._len0 - self._pos0 + * self._pos0 = self._len0 # <<<<<<<<<<<<<< + * self._length -= nread + * + */ + __pyx_t_8 = __pyx_v_self->_len0; + __pyx_v_self->_pos0 = __pyx_t_8; + + /* "asyncpg/protocol/buffer.pyx":465 + * nread = self._len0 - self._pos0 + * self._pos0 = self._len0 + * self._length -= nread # <<<<<<<<<<<<<< + * + * self._current_message_len_unread -= nread + */ + __pyx_v_self->_length = (__pyx_v_self->_length - __pyx_v_nread); + + /* "asyncpg/protocol/buffer.pyx":467 + * self._length -= nread + * + * self._current_message_len_unread -= nread # <<<<<<<<<<<<<< + * if self._current_message_len_unread < 0: + * raise BufferError('read_cstr: buffer overread') + */ + __pyx_v_self->_current_message_len_unread = (__pyx_v_self->_current_message_len_unread - __pyx_v_nread); + + /* "asyncpg/protocol/buffer.pyx":468 + * + * self._current_message_len_unread -= nread + * if self._current_message_len_unread < 0: # <<<<<<<<<<<<<< + * raise BufferError('read_cstr: buffer overread') + * + */ + __pyx_t_1 = ((__pyx_v_self->_current_message_len_unread < 0) != 0); + if (__pyx_t_1) { + + /* "asyncpg/protocol/buffer.pyx":469 + * self._current_message_len_unread -= nread + * if self._current_message_len_unread < 0: + * raise BufferError('read_cstr: buffer overread') # <<<<<<<<<<<<<< + * + * self._ensure_first_buf() + */ + __pyx_t_2 = __Pyx_GetModuleGlobalName(__pyx_n_s_BufferError); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 469, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_tuple__21, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 469, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_Raise(__pyx_t_3, 0, 0, 0); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __PYX_ERR(1, 469, __pyx_L1_error) + + /* "asyncpg/protocol/buffer.pyx":468 + * + * self._current_message_len_unread -= nread + * if self._current_message_len_unread < 0: # <<<<<<<<<<<<<< + * raise BufferError('read_cstr: buffer overread') + * + */ + } + + /* "asyncpg/protocol/buffer.pyx":471 + * raise BufferError('read_cstr: buffer overread') + * + * self._ensure_first_buf() # <<<<<<<<<<<<<< + * + * cdef int32_t has_message(self) except -1: + */ + __pyx_t_3 = __pyx_f_7asyncpg_8protocol_8protocol_10ReadBuffer__ensure_first_buf(__pyx_v_self); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 471, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + } + } + + /* "asyncpg/protocol/buffer.pyx":417 + * return hton.unpack_int16(mem.buf) + * + * cdef inline read_cstr(self): # <<<<<<<<<<<<<< + * if not self._current_message_ready: + * raise BufferError( + */ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_XDECREF(__pyx_t_7); + __Pyx_AddTraceback("asyncpg.protocol.protocol.ReadBuffer.read_cstr", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XDECREF(__pyx_v_result); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "asyncpg/protocol/buffer.pyx":473 + * self._ensure_first_buf() + * + * cdef int32_t has_message(self) except -1: # <<<<<<<<<<<<<< + * cdef: + * char* cbuf + */ + +static int32_t __pyx_f_7asyncpg_8protocol_8protocol_10ReadBuffer_has_message(struct __pyx_obj_7asyncpg_8protocol_8protocol_ReadBuffer *__pyx_v_self) { + char *__pyx_v_cbuf; + int32_t __pyx_r; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + int __pyx_t_4; + __Pyx_RefNannySetupContext("has_message", 0); + + /* "asyncpg/protocol/buffer.pyx":477 + * char* cbuf + * + * if self._current_message_ready: # <<<<<<<<<<<<<< + * return 1 + * + */ + __pyx_t_1 = (__pyx_v_self->_current_message_ready != 0); + if (__pyx_t_1) { + + /* "asyncpg/protocol/buffer.pyx":478 + * + * if self._current_message_ready: + * return 1 # <<<<<<<<<<<<<< + * + * if self._current_message_type == 0: + */ + __pyx_r = 1; + goto __pyx_L0; + + /* "asyncpg/protocol/buffer.pyx":477 + * char* cbuf + * + * if self._current_message_ready: # <<<<<<<<<<<<<< + * return 1 + * + */ + } + + /* "asyncpg/protocol/buffer.pyx":480 + * return 1 + * + * if self._current_message_type == 0: # <<<<<<<<<<<<<< + * if self._length < 1: + * return 0 + */ + __pyx_t_1 = ((__pyx_v_self->_current_message_type == 0) != 0); + if (__pyx_t_1) { + + /* "asyncpg/protocol/buffer.pyx":481 + * + * if self._current_message_type == 0: + * if self._length < 1: # <<<<<<<<<<<<<< + * return 0 + * self._ensure_first_buf() + */ + __pyx_t_1 = ((__pyx_v_self->_length < 1) != 0); + if (__pyx_t_1) { + + /* "asyncpg/protocol/buffer.pyx":482 + * if self._current_message_type == 0: + * if self._length < 1: + * return 0 # <<<<<<<<<<<<<< + * self._ensure_first_buf() + * cbuf = self._try_read_bytes(1) + */ + __pyx_r = 0; + goto __pyx_L0; + + /* "asyncpg/protocol/buffer.pyx":481 + * + * if self._current_message_type == 0: + * if self._length < 1: # <<<<<<<<<<<<<< + * return 0 + * self._ensure_first_buf() + */ + } + + /* "asyncpg/protocol/buffer.pyx":483 + * if self._length < 1: + * return 0 + * self._ensure_first_buf() # <<<<<<<<<<<<<< + * cbuf = self._try_read_bytes(1) + * if cbuf == NULL: + */ + __pyx_t_2 = __pyx_f_7asyncpg_8protocol_8protocol_10ReadBuffer__ensure_first_buf(__pyx_v_self); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 483, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "asyncpg/protocol/buffer.pyx":484 + * return 0 + * self._ensure_first_buf() + * cbuf = self._try_read_bytes(1) # <<<<<<<<<<<<<< + * if cbuf == NULL: + * raise BufferError( + */ + __pyx_v_cbuf = __pyx_f_7asyncpg_8protocol_8protocol_10ReadBuffer__try_read_bytes(__pyx_v_self, 1); + + /* "asyncpg/protocol/buffer.pyx":485 + * self._ensure_first_buf() + * cbuf = self._try_read_bytes(1) + * if cbuf == NULL: # <<<<<<<<<<<<<< + * raise BufferError( + * 'failed to read one byte on a non-empty buffer') + */ + __pyx_t_1 = ((__pyx_v_cbuf == NULL) != 0); + if (__pyx_t_1) { + + /* "asyncpg/protocol/buffer.pyx":486 + * cbuf = self._try_read_bytes(1) + * if cbuf == NULL: + * raise BufferError( # <<<<<<<<<<<<<< + * 'failed to read one byte on a non-empty buffer') + * self._current_message_type = cbuf[0] + */ + __pyx_t_2 = __Pyx_GetModuleGlobalName(__pyx_n_s_BufferError); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 486, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_tuple__22, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 486, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_Raise(__pyx_t_3, 0, 0, 0); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __PYX_ERR(1, 486, __pyx_L1_error) + + /* "asyncpg/protocol/buffer.pyx":485 + * self._ensure_first_buf() + * cbuf = self._try_read_bytes(1) + * if cbuf == NULL: # <<<<<<<<<<<<<< + * raise BufferError( + * 'failed to read one byte on a non-empty buffer') + */ + } + + /* "asyncpg/protocol/buffer.pyx":488 + * raise BufferError( + * 'failed to read one byte on a non-empty buffer') + * self._current_message_type = cbuf[0] # <<<<<<<<<<<<<< + * + * if self._current_message_len == 0: + */ + __pyx_v_self->_current_message_type = (__pyx_v_cbuf[0]); + + /* "asyncpg/protocol/buffer.pyx":480 + * return 1 + * + * if self._current_message_type == 0: # <<<<<<<<<<<<<< + * if self._length < 1: + * return 0 + */ + } + + /* "asyncpg/protocol/buffer.pyx":490 + * self._current_message_type = cbuf[0] + * + * if self._current_message_len == 0: # <<<<<<<<<<<<<< + * if self._length < 4: + * return 0 + */ + __pyx_t_1 = ((__pyx_v_self->_current_message_len == 0) != 0); + if (__pyx_t_1) { + + /* "asyncpg/protocol/buffer.pyx":491 + * + * if self._current_message_len == 0: + * if self._length < 4: # <<<<<<<<<<<<<< + * return 0 + * + */ + __pyx_t_1 = ((__pyx_v_self->_length < 4) != 0); + if (__pyx_t_1) { + + /* "asyncpg/protocol/buffer.pyx":492 + * if self._current_message_len == 0: + * if self._length < 4: + * return 0 # <<<<<<<<<<<<<< + * + * self._ensure_first_buf() + */ + __pyx_r = 0; + goto __pyx_L0; + + /* "asyncpg/protocol/buffer.pyx":491 + * + * if self._current_message_len == 0: + * if self._length < 4: # <<<<<<<<<<<<<< + * return 0 + * + */ + } + + /* "asyncpg/protocol/buffer.pyx":494 + * return 0 + * + * self._ensure_first_buf() # <<<<<<<<<<<<<< + * cbuf = self._try_read_bytes(4) + * if cbuf != NULL: + */ + __pyx_t_3 = __pyx_f_7asyncpg_8protocol_8protocol_10ReadBuffer__ensure_first_buf(__pyx_v_self); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 494, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + + /* "asyncpg/protocol/buffer.pyx":495 + * + * self._ensure_first_buf() + * cbuf = self._try_read_bytes(4) # <<<<<<<<<<<<<< + * if cbuf != NULL: + * self._current_message_len = hton.unpack_int32(cbuf) + */ + __pyx_v_cbuf = __pyx_f_7asyncpg_8protocol_8protocol_10ReadBuffer__try_read_bytes(__pyx_v_self, 4); + + /* "asyncpg/protocol/buffer.pyx":496 + * self._ensure_first_buf() + * cbuf = self._try_read_bytes(4) + * if cbuf != NULL: # <<<<<<<<<<<<<< + * self._current_message_len = hton.unpack_int32(cbuf) + * else: + */ + __pyx_t_1 = ((__pyx_v_cbuf != NULL) != 0); + if (__pyx_t_1) { + + /* "asyncpg/protocol/buffer.pyx":497 + * cbuf = self._try_read_bytes(4) + * if cbuf != NULL: + * self._current_message_len = hton.unpack_int32(cbuf) # <<<<<<<<<<<<<< + * else: + * self._current_message_len = self.read_int32() + */ + __pyx_v_self->_current_message_len = __pyx_f_7asyncpg_8protocol_4hton_unpack_int32(__pyx_v_cbuf); + + /* "asyncpg/protocol/buffer.pyx":496 + * self._ensure_first_buf() + * cbuf = self._try_read_bytes(4) + * if cbuf != NULL: # <<<<<<<<<<<<<< + * self._current_message_len = hton.unpack_int32(cbuf) + * else: + */ + goto __pyx_L9; + } + + /* "asyncpg/protocol/buffer.pyx":499 + * self._current_message_len = hton.unpack_int32(cbuf) + * else: + * self._current_message_len = self.read_int32() # <<<<<<<<<<<<<< + * + * self._current_message_len_unread = self._current_message_len - 4 + */ + /*else*/ { + __pyx_t_3 = __pyx_f_7asyncpg_8protocol_8protocol_10ReadBuffer_read_int32(__pyx_v_self); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 499, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = __Pyx_PyInt_As_int(__pyx_t_3); if (unlikely((__pyx_t_4 == (int)-1) && PyErr_Occurred())) __PYX_ERR(1, 499, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_v_self->_current_message_len = __pyx_t_4; + } + __pyx_L9:; + + /* "asyncpg/protocol/buffer.pyx":501 + * self._current_message_len = self.read_int32() + * + * self._current_message_len_unread = self._current_message_len - 4 # <<<<<<<<<<<<<< + * + * if self._length < self._current_message_len_unread: + */ + __pyx_v_self->_current_message_len_unread = (__pyx_v_self->_current_message_len - 4); + + /* "asyncpg/protocol/buffer.pyx":490 + * self._current_message_type = cbuf[0] + * + * if self._current_message_len == 0: # <<<<<<<<<<<<<< + * if self._length < 4: + * return 0 + */ + } + + /* "asyncpg/protocol/buffer.pyx":503 + * self._current_message_len_unread = self._current_message_len - 4 + * + * if self._length < self._current_message_len_unread: # <<<<<<<<<<<<<< + * return 0 + * + */ + __pyx_t_1 = ((__pyx_v_self->_length < __pyx_v_self->_current_message_len_unread) != 0); + if (__pyx_t_1) { + + /* "asyncpg/protocol/buffer.pyx":504 + * + * if self._length < self._current_message_len_unread: + * return 0 # <<<<<<<<<<<<<< + * + * self._current_message_ready = 1 + */ + __pyx_r = 0; + goto __pyx_L0; + + /* "asyncpg/protocol/buffer.pyx":503 + * self._current_message_len_unread = self._current_message_len - 4 + * + * if self._length < self._current_message_len_unread: # <<<<<<<<<<<<<< + * return 0 + * + */ + } + + /* "asyncpg/protocol/buffer.pyx":506 + * return 0 + * + * self._current_message_ready = 1 # <<<<<<<<<<<<<< + * return 1 + * + */ + __pyx_v_self->_current_message_ready = 1; + + /* "asyncpg/protocol/buffer.pyx":507 + * + * self._current_message_ready = 1 + * return 1 # <<<<<<<<<<<<<< + * + * cdef inline char* try_consume_message(self, ssize_t* len): + */ + __pyx_r = 1; + goto __pyx_L0; + + /* "asyncpg/protocol/buffer.pyx":473 + * self._ensure_first_buf() + * + * cdef int32_t has_message(self) except -1: # <<<<<<<<<<<<<< + * cdef: + * char* cbuf + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_AddTraceback("asyncpg.protocol.protocol.ReadBuffer.has_message", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = -1; + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "asyncpg/protocol/buffer.pyx":509 + * return 1 + * + * cdef inline char* try_consume_message(self, ssize_t* len): # <<<<<<<<<<<<<< + * cdef ssize_t buf_len + * + */ + +static CYTHON_INLINE char *__pyx_f_7asyncpg_8protocol_8protocol_10ReadBuffer_try_consume_message(struct __pyx_obj_7asyncpg_8protocol_8protocol_ReadBuffer *__pyx_v_self, Py_ssize_t *__pyx_v_len) { + Py_ssize_t __pyx_v_buf_len; + char *__pyx_v_buf; + char *__pyx_r; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + PyObject *__pyx_t_2 = NULL; + Py_ssize_t __pyx_t_3; + __Pyx_RefNannySetupContext("try_consume_message", 0); + + /* "asyncpg/protocol/buffer.pyx":512 + * cdef ssize_t buf_len + * + * if not self._current_message_ready: # <<<<<<<<<<<<<< + * return NULL + * + */ + __pyx_t_1 = ((!(__pyx_v_self->_current_message_ready != 0)) != 0); + if (__pyx_t_1) { + + /* "asyncpg/protocol/buffer.pyx":513 + * + * if not self._current_message_ready: + * return NULL # <<<<<<<<<<<<<< + * + * self._ensure_first_buf() + */ + __pyx_r = NULL; + goto __pyx_L0; + + /* "asyncpg/protocol/buffer.pyx":512 + * cdef ssize_t buf_len + * + * if not self._current_message_ready: # <<<<<<<<<<<<<< + * return NULL + * + */ + } + + /* "asyncpg/protocol/buffer.pyx":515 + * return NULL + * + * self._ensure_first_buf() # <<<<<<<<<<<<<< + * buf_len = self._current_message_len_unread + * buf = self._try_read_bytes(buf_len) + */ + __pyx_t_2 = __pyx_f_7asyncpg_8protocol_8protocol_10ReadBuffer__ensure_first_buf(__pyx_v_self); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 515, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "asyncpg/protocol/buffer.pyx":516 + * + * self._ensure_first_buf() + * buf_len = self._current_message_len_unread # <<<<<<<<<<<<<< + * buf = self._try_read_bytes(buf_len) + * if buf != NULL: + */ + __pyx_t_3 = __pyx_v_self->_current_message_len_unread; + __pyx_v_buf_len = __pyx_t_3; + + /* "asyncpg/protocol/buffer.pyx":517 + * self._ensure_first_buf() + * buf_len = self._current_message_len_unread + * buf = self._try_read_bytes(buf_len) # <<<<<<<<<<<<<< + * if buf != NULL: + * len[0] = buf_len + */ + __pyx_v_buf = __pyx_f_7asyncpg_8protocol_8protocol_10ReadBuffer__try_read_bytes(__pyx_v_self, __pyx_v_buf_len); + + /* "asyncpg/protocol/buffer.pyx":518 + * buf_len = self._current_message_len_unread + * buf = self._try_read_bytes(buf_len) + * if buf != NULL: # <<<<<<<<<<<<<< + * len[0] = buf_len + * self._discard_message() + */ + __pyx_t_1 = ((__pyx_v_buf != NULL) != 0); + if (__pyx_t_1) { + + /* "asyncpg/protocol/buffer.pyx":519 + * buf = self._try_read_bytes(buf_len) + * if buf != NULL: + * len[0] = buf_len # <<<<<<<<<<<<<< + * self._discard_message() + * return buf + */ + (__pyx_v_len[0]) = __pyx_v_buf_len; + + /* "asyncpg/protocol/buffer.pyx":520 + * if buf != NULL: + * len[0] = buf_len + * self._discard_message() # <<<<<<<<<<<<<< + * return buf + * + */ + __pyx_t_2 = __pyx_f_7asyncpg_8protocol_8protocol_10ReadBuffer__discard_message(__pyx_v_self); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 520, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "asyncpg/protocol/buffer.pyx":518 + * buf_len = self._current_message_len_unread + * buf = self._try_read_bytes(buf_len) + * if buf != NULL: # <<<<<<<<<<<<<< + * len[0] = buf_len + * self._discard_message() + */ + } + + /* "asyncpg/protocol/buffer.pyx":521 + * len[0] = buf_len + * self._discard_message() + * return buf # <<<<<<<<<<<<<< + * + * cdef Memory consume_message(self): + */ + __pyx_r = __pyx_v_buf; + goto __pyx_L0; + + /* "asyncpg/protocol/buffer.pyx":509 + * return 1 + * + * cdef inline char* try_consume_message(self, ssize_t* len): # <<<<<<<<<<<<<< + * cdef ssize_t buf_len + * + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_2); + __Pyx_WriteUnraisable("asyncpg.protocol.protocol.ReadBuffer.try_consume_message", __pyx_clineno, __pyx_lineno, __pyx_filename, 0, 0); + __pyx_r = 0; + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "asyncpg/protocol/buffer.pyx":523 + * return buf + * + * cdef Memory consume_message(self): # <<<<<<<<<<<<<< + * if not self._current_message_ready: + * raise BufferError('no message to consume') + */ + +static struct __pyx_obj_7asyncpg_8protocol_8protocol_Memory *__pyx_f_7asyncpg_8protocol_8protocol_10ReadBuffer_consume_message(struct __pyx_obj_7asyncpg_8protocol_8protocol_ReadBuffer *__pyx_v_self) { + PyObject *__pyx_v_mem = NULL; + struct __pyx_obj_7asyncpg_8protocol_8protocol_Memory *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + __Pyx_RefNannySetupContext("consume_message", 0); + + /* "asyncpg/protocol/buffer.pyx":524 + * + * cdef Memory consume_message(self): + * if not self._current_message_ready: # <<<<<<<<<<<<<< + * raise BufferError('no message to consume') + * if self._current_message_len_unread > 0: + */ + __pyx_t_1 = ((!(__pyx_v_self->_current_message_ready != 0)) != 0); + if (__pyx_t_1) { + + /* "asyncpg/protocol/buffer.pyx":525 + * cdef Memory consume_message(self): + * if not self._current_message_ready: + * raise BufferError('no message to consume') # <<<<<<<<<<<<<< + * if self._current_message_len_unread > 0: + * mem = self.read(self._current_message_len_unread) + */ + __pyx_t_2 = __Pyx_GetModuleGlobalName(__pyx_n_s_BufferError); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 525, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_tuple__23, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 525, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_Raise(__pyx_t_3, 0, 0, 0); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __PYX_ERR(1, 525, __pyx_L1_error) + + /* "asyncpg/protocol/buffer.pyx":524 + * + * cdef Memory consume_message(self): + * if not self._current_message_ready: # <<<<<<<<<<<<<< + * raise BufferError('no message to consume') + * if self._current_message_len_unread > 0: + */ + } + + /* "asyncpg/protocol/buffer.pyx":526 + * if not self._current_message_ready: + * raise BufferError('no message to consume') + * if self._current_message_len_unread > 0: # <<<<<<<<<<<<<< + * mem = self.read(self._current_message_len_unread) + * else: + */ + __pyx_t_1 = ((__pyx_v_self->_current_message_len_unread > 0) != 0); + if (__pyx_t_1) { + + /* "asyncpg/protocol/buffer.pyx":527 + * raise BufferError('no message to consume') + * if self._current_message_len_unread > 0: + * mem = self.read(self._current_message_len_unread) # <<<<<<<<<<<<<< + * else: + * mem = None + */ + __pyx_t_3 = __pyx_f_7asyncpg_8protocol_8protocol_10ReadBuffer_read(__pyx_v_self, __pyx_v_self->_current_message_len_unread); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 527, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_v_mem = __pyx_t_3; + __pyx_t_3 = 0; + + /* "asyncpg/protocol/buffer.pyx":526 + * if not self._current_message_ready: + * raise BufferError('no message to consume') + * if self._current_message_len_unread > 0: # <<<<<<<<<<<<<< + * mem = self.read(self._current_message_len_unread) + * else: + */ + goto __pyx_L4; + } + + /* "asyncpg/protocol/buffer.pyx":529 + * mem = self.read(self._current_message_len_unread) + * else: + * mem = None # <<<<<<<<<<<<<< + * self._discard_message() + * return mem + */ + /*else*/ { + __Pyx_INCREF(Py_None); + __pyx_v_mem = Py_None; + } + __pyx_L4:; + + /* "asyncpg/protocol/buffer.pyx":530 + * else: + * mem = None + * self._discard_message() # <<<<<<<<<<<<<< + * return mem + * + */ + __pyx_t_3 = __pyx_f_7asyncpg_8protocol_8protocol_10ReadBuffer__discard_message(__pyx_v_self); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 530, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + + /* "asyncpg/protocol/buffer.pyx":531 + * mem = None + * self._discard_message() + * return mem # <<<<<<<<<<<<<< + * + * cdef discard_message(self): + */ + __Pyx_XDECREF(((PyObject *)__pyx_r)); + if (!(likely(((__pyx_v_mem) == Py_None) || likely(__Pyx_TypeTest(__pyx_v_mem, __pyx_ptype_7asyncpg_8protocol_8protocol_Memory))))) __PYX_ERR(1, 531, __pyx_L1_error) + __Pyx_INCREF(__pyx_v_mem); + __pyx_r = ((struct __pyx_obj_7asyncpg_8protocol_8protocol_Memory *)__pyx_v_mem); + goto __pyx_L0; + + /* "asyncpg/protocol/buffer.pyx":523 + * return buf + * + * cdef Memory consume_message(self): # <<<<<<<<<<<<<< + * if not self._current_message_ready: + * raise BufferError('no message to consume') + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_AddTraceback("asyncpg.protocol.protocol.ReadBuffer.consume_message", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XDECREF(__pyx_v_mem); + __Pyx_XGIVEREF((PyObject *)__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "asyncpg/protocol/buffer.pyx":533 + * return mem + * + * cdef discard_message(self): # <<<<<<<<<<<<<< + * if self._current_message_type == 0: + * # Already discarded + */ + +static PyObject *__pyx_f_7asyncpg_8protocol_8protocol_10ReadBuffer_discard_message(struct __pyx_obj_7asyncpg_8protocol_8protocol_ReadBuffer *__pyx_v_self) { + PyObject *__pyx_v_mtype = NULL; + struct __pyx_obj_7asyncpg_8protocol_8protocol_Memory *__pyx_v_discarded = NULL; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + PyObject *__pyx_t_5 = NULL; + int __pyx_t_6; + PyObject *__pyx_t_7 = NULL; + __Pyx_RefNannySetupContext("discard_message", 0); + + /* "asyncpg/protocol/buffer.pyx":534 + * + * cdef discard_message(self): + * if self._current_message_type == 0: # <<<<<<<<<<<<<< + * # Already discarded + * return + */ + __pyx_t_1 = ((__pyx_v_self->_current_message_type == 0) != 0); + if (__pyx_t_1) { + + /* "asyncpg/protocol/buffer.pyx":536 + * if self._current_message_type == 0: + * # Already discarded + * return # <<<<<<<<<<<<<< + * + * if not self._current_message_ready: + */ + __Pyx_XDECREF(__pyx_r); + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + + /* "asyncpg/protocol/buffer.pyx":534 + * + * cdef discard_message(self): + * if self._current_message_type == 0: # <<<<<<<<<<<<<< + * # Already discarded + * return + */ + } + + /* "asyncpg/protocol/buffer.pyx":538 + * return + * + * if not self._current_message_ready: # <<<<<<<<<<<<<< + * raise BufferError('no message to discard') + * + */ + __pyx_t_1 = ((!(__pyx_v_self->_current_message_ready != 0)) != 0); + if (__pyx_t_1) { + + /* "asyncpg/protocol/buffer.pyx":539 + * + * if not self._current_message_ready: + * raise BufferError('no message to discard') # <<<<<<<<<<<<<< + * + * if self._current_message_len_unread: + */ + __pyx_t_2 = __Pyx_GetModuleGlobalName(__pyx_n_s_BufferError); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 539, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_tuple__24, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 539, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_Raise(__pyx_t_3, 0, 0, 0); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __PYX_ERR(1, 539, __pyx_L1_error) + + /* "asyncpg/protocol/buffer.pyx":538 + * return + * + * if not self._current_message_ready: # <<<<<<<<<<<<<< + * raise BufferError('no message to discard') + * + */ + } + + /* "asyncpg/protocol/buffer.pyx":541 + * raise BufferError('no message to discard') + * + * if self._current_message_len_unread: # <<<<<<<<<<<<<< + * if ASYNCPG_DEBUG: + * mtype = chr(self._current_message_type) + */ + __pyx_t_1 = (__pyx_v_self->_current_message_len_unread != 0); + if (__pyx_t_1) { + + /* "asyncpg/protocol/buffer.pyx":542 + * + * if self._current_message_len_unread: + * if ASYNCPG_DEBUG: # <<<<<<<<<<<<<< + * mtype = chr(self._current_message_type) + * + */ + __pyx_t_1 = (ASYNCPG_DEBUG != 0); + if (__pyx_t_1) { + + /* "asyncpg/protocol/buffer.pyx":543 + * if self._current_message_len_unread: + * if ASYNCPG_DEBUG: + * mtype = chr(self._current_message_type) # <<<<<<<<<<<<<< + * + * discarded = self.consume_message() + */ + __pyx_t_3 = __Pyx_PyInt_From_char(__pyx_v_self->_current_message_type); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 543, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_2 = PyTuple_New(1); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 543, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_GIVEREF(__pyx_t_3); + PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_t_3); + __pyx_t_3 = 0; + __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_chr, __pyx_t_2, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 543, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_v_mtype = __pyx_t_3; + __pyx_t_3 = 0; + + /* "asyncpg/protocol/buffer.pyx":542 + * + * if self._current_message_len_unread: + * if ASYNCPG_DEBUG: # <<<<<<<<<<<<<< + * mtype = chr(self._current_message_type) + * + */ + } + + /* "asyncpg/protocol/buffer.pyx":545 + * mtype = chr(self._current_message_type) + * + * discarded = self.consume_message() # <<<<<<<<<<<<<< + * + * if ASYNCPG_DEBUG: + */ + __pyx_t_3 = ((PyObject *)__pyx_f_7asyncpg_8protocol_8protocol_10ReadBuffer_consume_message(__pyx_v_self)); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 545, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_v_discarded = ((struct __pyx_obj_7asyncpg_8protocol_8protocol_Memory *)__pyx_t_3); + __pyx_t_3 = 0; + + /* "asyncpg/protocol/buffer.pyx":547 + * discarded = self.consume_message() + * + * if ASYNCPG_DEBUG: # <<<<<<<<<<<<<< + * print('!!! discarding message {!r} unread data: {!r}'.format( + * mtype, + */ + __pyx_t_1 = (ASYNCPG_DEBUG != 0); + if (__pyx_t_1) { + + /* "asyncpg/protocol/buffer.pyx":548 + * + * if ASYNCPG_DEBUG: + * print('!!! discarding message {!r} unread data: {!r}'.format( # <<<<<<<<<<<<<< + * mtype, + * (discarded).as_bytes())) + */ + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_kp_u_discarding_message_r_unread_dat, __pyx_n_s_format); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 548, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + + /* "asyncpg/protocol/buffer.pyx":549 + * if ASYNCPG_DEBUG: + * print('!!! discarding message {!r} unread data: {!r}'.format( + * mtype, # <<<<<<<<<<<<<< + * (discarded).as_bytes())) + * + */ + if (unlikely(!__pyx_v_mtype)) { __Pyx_RaiseUnboundLocalError("mtype"); __PYX_ERR(1, 549, __pyx_L1_error) } + + /* "asyncpg/protocol/buffer.pyx":550 + * print('!!! discarding message {!r} unread data: {!r}'.format( + * mtype, + * (discarded).as_bytes())) # <<<<<<<<<<<<<< + * + * self._discard_message() + */ + __pyx_t_4 = __pyx_f_7asyncpg_8protocol_8protocol_6Memory_as_bytes(((struct __pyx_obj_7asyncpg_8protocol_8protocol_Memory *)__pyx_v_discarded)); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 550, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_5 = NULL; + __pyx_t_6 = 0; + if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_5)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_5); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + __pyx_t_6 = 1; + } + } + #if CYTHON_FAST_PYCALL + if (PyFunction_Check(__pyx_t_2)) { + PyObject *__pyx_temp[3] = {__pyx_t_5, __pyx_v_mtype, __pyx_t_4}; + __pyx_t_3 = __Pyx_PyFunction_FastCall(__pyx_t_2, __pyx_temp+1-__pyx_t_6, 2+__pyx_t_6); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 548, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + } else + #endif + #if CYTHON_FAST_PYCCALL + if (__Pyx_PyFastCFunction_Check(__pyx_t_2)) { + PyObject *__pyx_temp[3] = {__pyx_t_5, __pyx_v_mtype, __pyx_t_4}; + __pyx_t_3 = __Pyx_PyCFunction_FastCall(__pyx_t_2, __pyx_temp+1-__pyx_t_6, 2+__pyx_t_6); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 548, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + } else + #endif + { + __pyx_t_7 = PyTuple_New(2+__pyx_t_6); if (unlikely(!__pyx_t_7)) __PYX_ERR(1, 548, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + if (__pyx_t_5) { + __Pyx_GIVEREF(__pyx_t_5); PyTuple_SET_ITEM(__pyx_t_7, 0, __pyx_t_5); __pyx_t_5 = NULL; + } + __Pyx_INCREF(__pyx_v_mtype); + __Pyx_GIVEREF(__pyx_v_mtype); + PyTuple_SET_ITEM(__pyx_t_7, 0+__pyx_t_6, __pyx_v_mtype); + __Pyx_GIVEREF(__pyx_t_4); + PyTuple_SET_ITEM(__pyx_t_7, 1+__pyx_t_6, __pyx_t_4); + __pyx_t_4 = 0; + __pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_t_7, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 548, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + } + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "asyncpg/protocol/buffer.pyx":548 + * + * if ASYNCPG_DEBUG: + * print('!!! discarding message {!r} unread data: {!r}'.format( # <<<<<<<<<<<<<< + * mtype, + * (discarded).as_bytes())) + */ + __pyx_t_2 = PyTuple_New(1); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 548, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_GIVEREF(__pyx_t_3); + PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_t_3); + __pyx_t_3 = 0; + __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_print, __pyx_t_2, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 548, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + + /* "asyncpg/protocol/buffer.pyx":547 + * discarded = self.consume_message() + * + * if ASYNCPG_DEBUG: # <<<<<<<<<<<<<< + * print('!!! discarding message {!r} unread data: {!r}'.format( + * mtype, + */ + } + + /* "asyncpg/protocol/buffer.pyx":541 + * raise BufferError('no message to discard') + * + * if self._current_message_len_unread: # <<<<<<<<<<<<<< + * if ASYNCPG_DEBUG: + * mtype = chr(self._current_message_type) + */ + } + + /* "asyncpg/protocol/buffer.pyx":552 + * (discarded).as_bytes())) + * + * self._discard_message() # <<<<<<<<<<<<<< + * + * cdef inline _discard_message(self): + */ + __pyx_t_3 = __pyx_f_7asyncpg_8protocol_8protocol_10ReadBuffer__discard_message(__pyx_v_self); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 552, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + + /* "asyncpg/protocol/buffer.pyx":533 + * return mem + * + * cdef discard_message(self): # <<<<<<<<<<<<<< + * if self._current_message_type == 0: + * # Already discarded + */ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_XDECREF(__pyx_t_7); + __Pyx_AddTraceback("asyncpg.protocol.protocol.ReadBuffer.discard_message", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XDECREF(__pyx_v_mtype); + __Pyx_XDECREF((PyObject *)__pyx_v_discarded); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "asyncpg/protocol/buffer.pyx":554 + * self._discard_message() + * + * cdef inline _discard_message(self): # <<<<<<<<<<<<<< + * self._current_message_type = 0 + * self._current_message_len = 0 + */ + +static CYTHON_INLINE PyObject *__pyx_f_7asyncpg_8protocol_8protocol_10ReadBuffer__discard_message(struct __pyx_obj_7asyncpg_8protocol_8protocol_ReadBuffer *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("_discard_message", 0); + + /* "asyncpg/protocol/buffer.pyx":555 + * + * cdef inline _discard_message(self): + * self._current_message_type = 0 # <<<<<<<<<<<<<< + * self._current_message_len = 0 + * self._current_message_ready = 0 + */ + __pyx_v_self->_current_message_type = 0; + + /* "asyncpg/protocol/buffer.pyx":556 + * cdef inline _discard_message(self): + * self._current_message_type = 0 + * self._current_message_len = 0 # <<<<<<<<<<<<<< + * self._current_message_ready = 0 + * self._current_message_len_unread = 0 + */ + __pyx_v_self->_current_message_len = 0; + + /* "asyncpg/protocol/buffer.pyx":557 + * self._current_message_type = 0 + * self._current_message_len = 0 + * self._current_message_ready = 0 # <<<<<<<<<<<<<< + * self._current_message_len_unread = 0 + * + */ + __pyx_v_self->_current_message_ready = 0; + + /* "asyncpg/protocol/buffer.pyx":558 + * self._current_message_len = 0 + * self._current_message_ready = 0 + * self._current_message_len_unread = 0 # <<<<<<<<<<<<<< + * + * cdef inline char get_message_type(self): + */ + __pyx_v_self->_current_message_len_unread = 0; + + /* "asyncpg/protocol/buffer.pyx":554 + * self._discard_message() + * + * cdef inline _discard_message(self): # <<<<<<<<<<<<<< + * self._current_message_type = 0 + * self._current_message_len = 0 + */ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "asyncpg/protocol/buffer.pyx":560 + * self._current_message_len_unread = 0 + * + * cdef inline char get_message_type(self): # <<<<<<<<<<<<<< + * return self._current_message_type + * + */ + +static CYTHON_INLINE char __pyx_f_7asyncpg_8protocol_8protocol_10ReadBuffer_get_message_type(struct __pyx_obj_7asyncpg_8protocol_8protocol_ReadBuffer *__pyx_v_self) { + char __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("get_message_type", 0); + + /* "asyncpg/protocol/buffer.pyx":561 + * + * cdef inline char get_message_type(self): + * return self._current_message_type # <<<<<<<<<<<<<< + * + * cdef inline int32_t get_message_length(self): + */ + __pyx_r = __pyx_v_self->_current_message_type; + goto __pyx_L0; + + /* "asyncpg/protocol/buffer.pyx":560 + * self._current_message_len_unread = 0 + * + * cdef inline char get_message_type(self): # <<<<<<<<<<<<<< + * return self._current_message_type + * + */ + + /* function exit code */ + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "asyncpg/protocol/buffer.pyx":563 + * return self._current_message_type + * + * cdef inline int32_t get_message_length(self): # <<<<<<<<<<<<<< + * return self._current_message_len + * + */ + +static CYTHON_INLINE int32_t __pyx_f_7asyncpg_8protocol_8protocol_10ReadBuffer_get_message_length(struct __pyx_obj_7asyncpg_8protocol_8protocol_ReadBuffer *__pyx_v_self) { + int32_t __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("get_message_length", 0); + + /* "asyncpg/protocol/buffer.pyx":564 + * + * cdef inline int32_t get_message_length(self): + * return self._current_message_len # <<<<<<<<<<<<<< + * + * @staticmethod + */ + __pyx_r = __pyx_v_self->_current_message_len; + goto __pyx_L0; + + /* "asyncpg/protocol/buffer.pyx":563 + * return self._current_message_type + * + * cdef inline int32_t get_message_length(self): # <<<<<<<<<<<<<< + * return self._current_message_len + * + */ + + /* function exit code */ + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "asyncpg/protocol/buffer.pyx":567 + * + * @staticmethod + * cdef ReadBuffer new_message_parser(object data): # <<<<<<<<<<<<<< + * cdef ReadBuffer buf + * + */ + +static struct __pyx_obj_7asyncpg_8protocol_8protocol_ReadBuffer *__pyx_f_7asyncpg_8protocol_8protocol_10ReadBuffer_new_message_parser(PyObject *__pyx_v_data) { + struct __pyx_obj_7asyncpg_8protocol_8protocol_ReadBuffer *__pyx_v_buf = 0; + struct __pyx_obj_7asyncpg_8protocol_8protocol_ReadBuffer *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + Py_ssize_t __pyx_t_2; + __Pyx_RefNannySetupContext("new_message_parser", 0); + + /* "asyncpg/protocol/buffer.pyx":570 + * cdef ReadBuffer buf + * + * buf = ReadBuffer.__new__(ReadBuffer) # <<<<<<<<<<<<<< + * buf.feed_data(data) + * + */ + __pyx_t_1 = __pyx_tp_new_7asyncpg_8protocol_8protocol_ReadBuffer(((PyTypeObject *)__pyx_ptype_7asyncpg_8protocol_8protocol_ReadBuffer), __pyx_empty_tuple, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 570, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (!(likely(__Pyx_TypeTest(__pyx_t_1, __pyx_ptype_7asyncpg_8protocol_8protocol_ReadBuffer)))) __PYX_ERR(1, 570, __pyx_L1_error) + __pyx_v_buf = ((struct __pyx_obj_7asyncpg_8protocol_8protocol_ReadBuffer *)__pyx_t_1); + __pyx_t_1 = 0; + + /* "asyncpg/protocol/buffer.pyx":571 + * + * buf = ReadBuffer.__new__(ReadBuffer) + * buf.feed_data(data) # <<<<<<<<<<<<<< + * + * buf._current_message_ready = 1 + */ + __pyx_t_1 = __pyx_f_7asyncpg_8protocol_8protocol_10ReadBuffer_feed_data(__pyx_v_buf, __pyx_v_data); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 571, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "asyncpg/protocol/buffer.pyx":573 + * buf.feed_data(data) + * + * buf._current_message_ready = 1 # <<<<<<<<<<<<<< + * buf._current_message_len_unread = buf._len0 + * + */ + __pyx_v_buf->_current_message_ready = 1; + + /* "asyncpg/protocol/buffer.pyx":574 + * + * buf._current_message_ready = 1 + * buf._current_message_len_unread = buf._len0 # <<<<<<<<<<<<<< + * + * return buf + */ + __pyx_t_2 = __pyx_v_buf->_len0; + __pyx_v_buf->_current_message_len_unread = __pyx_t_2; + + /* "asyncpg/protocol/buffer.pyx":576 + * buf._current_message_len_unread = buf._len0 + * + * return buf # <<<<<<<<<<<<<< + * + * + */ + __Pyx_XDECREF(((PyObject *)__pyx_r)); + __Pyx_INCREF(((PyObject *)__pyx_v_buf)); + __pyx_r = __pyx_v_buf; + goto __pyx_L0; + + /* "asyncpg/protocol/buffer.pyx":567 + * + * @staticmethod + * cdef ReadBuffer new_message_parser(object data): # <<<<<<<<<<<<<< + * cdef ReadBuffer buf + * + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("asyncpg.protocol.protocol.ReadBuffer.new_message_parser", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XDECREF((PyObject *)__pyx_v_buf); + __Pyx_XGIVEREF((PyObject *)__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "asyncpg/protocol/buffer.pyx":584 + * cdef class FastReadBuffer: + * + * cdef inline const char* read(self, ssize_t n) except NULL: # <<<<<<<<<<<<<< + * cdef const char *result + * + */ + +static CYTHON_INLINE char const *__pyx_f_7asyncpg_8protocol_8protocol_14FastReadBuffer_read(struct __pyx_obj_7asyncpg_8protocol_8protocol_FastReadBuffer *__pyx_v_self, Py_ssize_t __pyx_v_n) { + char const *__pyx_v_result; + char const *__pyx_r; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + PyObject *__pyx_t_2 = NULL; + char const *__pyx_t_3; + __Pyx_RefNannySetupContext("read", 0); + + /* "asyncpg/protocol/buffer.pyx":587 + * cdef const char *result + * + * if n > self.len: # <<<<<<<<<<<<<< + * self._raise_ins_err(n, self.len) + * + */ + __pyx_t_1 = ((__pyx_v_n > __pyx_v_self->len) != 0); + if (__pyx_t_1) { + + /* "asyncpg/protocol/buffer.pyx":588 + * + * if n > self.len: + * self._raise_ins_err(n, self.len) # <<<<<<<<<<<<<< + * + * result = self.buf + */ + __pyx_t_2 = __pyx_f_7asyncpg_8protocol_8protocol_14FastReadBuffer__raise_ins_err(__pyx_v_self, __pyx_v_n, __pyx_v_self->len); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 588, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "asyncpg/protocol/buffer.pyx":587 + * cdef const char *result + * + * if n > self.len: # <<<<<<<<<<<<<< + * self._raise_ins_err(n, self.len) + * + */ + } + + /* "asyncpg/protocol/buffer.pyx":590 + * self._raise_ins_err(n, self.len) + * + * result = self.buf # <<<<<<<<<<<<<< + * self.buf += n + * self.len -= n + */ + __pyx_t_3 = __pyx_v_self->buf; + __pyx_v_result = __pyx_t_3; + + /* "asyncpg/protocol/buffer.pyx":591 + * + * result = self.buf + * self.buf += n # <<<<<<<<<<<<<< + * self.len -= n + * + */ + __pyx_v_self->buf = (__pyx_v_self->buf + __pyx_v_n); + + /* "asyncpg/protocol/buffer.pyx":592 + * result = self.buf + * self.buf += n + * self.len -= n # <<<<<<<<<<<<<< + * + * return result + */ + __pyx_v_self->len = (__pyx_v_self->len - __pyx_v_n); + + /* "asyncpg/protocol/buffer.pyx":594 + * self.len -= n + * + * return result # <<<<<<<<<<<<<< + * + * cdef inline const char* read_all(self): + */ + __pyx_r = __pyx_v_result; + goto __pyx_L0; + + /* "asyncpg/protocol/buffer.pyx":584 + * cdef class FastReadBuffer: + * + * cdef inline const char* read(self, ssize_t n) except NULL: # <<<<<<<<<<<<<< + * cdef const char *result + * + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_2); + __Pyx_AddTraceback("asyncpg.protocol.protocol.FastReadBuffer.read", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "asyncpg/protocol/buffer.pyx":596 + * return result + * + * cdef inline const char* read_all(self): # <<<<<<<<<<<<<< + * cdef const char *result + * result = self.buf + */ + +static CYTHON_INLINE char const *__pyx_f_7asyncpg_8protocol_8protocol_14FastReadBuffer_read_all(struct __pyx_obj_7asyncpg_8protocol_8protocol_FastReadBuffer *__pyx_v_self) { + char const *__pyx_v_result; + char const *__pyx_r; + __Pyx_RefNannyDeclarations + char const *__pyx_t_1; + __Pyx_RefNannySetupContext("read_all", 0); + + /* "asyncpg/protocol/buffer.pyx":598 + * cdef inline const char* read_all(self): + * cdef const char *result + * result = self.buf # <<<<<<<<<<<<<< + * self.buf += self.len + * self.len = 0 + */ + __pyx_t_1 = __pyx_v_self->buf; + __pyx_v_result = __pyx_t_1; + + /* "asyncpg/protocol/buffer.pyx":599 + * cdef const char *result + * result = self.buf + * self.buf += self.len # <<<<<<<<<<<<<< + * self.len = 0 + * return result + */ + __pyx_v_self->buf = (__pyx_v_self->buf + __pyx_v_self->len); + + /* "asyncpg/protocol/buffer.pyx":600 + * result = self.buf + * self.buf += self.len + * self.len = 0 # <<<<<<<<<<<<<< + * return result + * + */ + __pyx_v_self->len = 0; + + /* "asyncpg/protocol/buffer.pyx":601 + * self.buf += self.len + * self.len = 0 + * return result # <<<<<<<<<<<<<< + * + * cdef inline FastReadBuffer slice_from(self, FastReadBuffer source, + */ + __pyx_r = __pyx_v_result; + goto __pyx_L0; + + /* "asyncpg/protocol/buffer.pyx":596 + * return result + * + * cdef inline const char* read_all(self): # <<<<<<<<<<<<<< + * cdef const char *result + * result = self.buf + */ + + /* function exit code */ + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "asyncpg/protocol/buffer.pyx":603 + * return result + * + * cdef inline FastReadBuffer slice_from(self, FastReadBuffer source, # <<<<<<<<<<<<<< + * ssize_t len): + * self.buf = source.read(len) + */ + +static CYTHON_INLINE struct __pyx_obj_7asyncpg_8protocol_8protocol_FastReadBuffer *__pyx_f_7asyncpg_8protocol_8protocol_14FastReadBuffer_slice_from(struct __pyx_obj_7asyncpg_8protocol_8protocol_FastReadBuffer *__pyx_v_self, struct __pyx_obj_7asyncpg_8protocol_8protocol_FastReadBuffer *__pyx_v_source, Py_ssize_t __pyx_v_len) { + struct __pyx_obj_7asyncpg_8protocol_8protocol_FastReadBuffer *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + char const *__pyx_t_1; + __Pyx_RefNannySetupContext("slice_from", 0); + + /* "asyncpg/protocol/buffer.pyx":605 + * cdef inline FastReadBuffer slice_from(self, FastReadBuffer source, + * ssize_t len): + * self.buf = source.read(len) # <<<<<<<<<<<<<< + * self.len = len + * return self + */ + __pyx_t_1 = __pyx_f_7asyncpg_8protocol_8protocol_14FastReadBuffer_read(__pyx_v_source, __pyx_v_len); if (unlikely(__pyx_t_1 == NULL)) __PYX_ERR(1, 605, __pyx_L1_error) + __pyx_v_self->buf = __pyx_t_1; + + /* "asyncpg/protocol/buffer.pyx":606 + * ssize_t len): + * self.buf = source.read(len) + * self.len = len # <<<<<<<<<<<<<< + * return self + * + */ + __pyx_v_self->len = __pyx_v_len; + + /* "asyncpg/protocol/buffer.pyx":607 + * self.buf = source.read(len) + * self.len = len + * return self # <<<<<<<<<<<<<< + * + * cdef _raise_ins_err(self, ssize_t n, ssize_t len): + */ + __Pyx_XDECREF(((PyObject *)__pyx_r)); + __Pyx_INCREF(((PyObject *)__pyx_v_self)); + __pyx_r = __pyx_v_self; + goto __pyx_L0; + + /* "asyncpg/protocol/buffer.pyx":603 + * return result + * + * cdef inline FastReadBuffer slice_from(self, FastReadBuffer source, # <<<<<<<<<<<<<< + * ssize_t len): + * self.buf = source.read(len) + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_AddTraceback("asyncpg.protocol.protocol.FastReadBuffer.slice_from", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XGIVEREF((PyObject *)__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "asyncpg/protocol/buffer.pyx":609 + * return self + * + * cdef _raise_ins_err(self, ssize_t n, ssize_t len): # <<<<<<<<<<<<<< + * raise BufferError( + * 'insufficient data in buffer: requested {}, remaining {}'. + */ + +static PyObject *__pyx_f_7asyncpg_8protocol_8protocol_14FastReadBuffer__raise_ins_err(struct __pyx_obj_7asyncpg_8protocol_8protocol_FastReadBuffer *__pyx_v_self, Py_ssize_t __pyx_v_n, CYTHON_UNUSED Py_ssize_t __pyx_v_len) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + PyObject *__pyx_t_5 = NULL; + PyObject *__pyx_t_6 = NULL; + PyObject *__pyx_t_7 = NULL; + int __pyx_t_8; + PyObject *__pyx_t_9 = NULL; + __Pyx_RefNannySetupContext("_raise_ins_err", 0); + + /* "asyncpg/protocol/buffer.pyx":610 + * + * cdef _raise_ins_err(self, ssize_t n, ssize_t len): + * raise BufferError( # <<<<<<<<<<<<<< + * 'insufficient data in buffer: requested {}, remaining {}'. + * format(n, self.len)) + */ + __pyx_t_2 = __Pyx_GetModuleGlobalName(__pyx_n_s_BufferError); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 610, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + + /* "asyncpg/protocol/buffer.pyx":611 + * cdef _raise_ins_err(self, ssize_t n, ssize_t len): + * raise BufferError( + * 'insufficient data in buffer: requested {}, remaining {}'. # <<<<<<<<<<<<<< + * format(n, self.len)) + * + */ + __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_kp_u_insufficient_data_in_buffer_requ, __pyx_n_s_format); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 611, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + + /* "asyncpg/protocol/buffer.pyx":612 + * raise BufferError( + * 'insufficient data in buffer: requested {}, remaining {}'. + * format(n, self.len)) # <<<<<<<<<<<<<< + * + * @staticmethod + */ + __pyx_t_5 = PyInt_FromSsize_t(__pyx_v_n); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 612, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_6 = PyInt_FromSsize_t(__pyx_v_self->len); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 612, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_7 = NULL; + __pyx_t_8 = 0; + if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_4))) { + __pyx_t_7 = PyMethod_GET_SELF(__pyx_t_4); + if (likely(__pyx_t_7)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4); + __Pyx_INCREF(__pyx_t_7); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_4, function); + __pyx_t_8 = 1; + } + } + #if CYTHON_FAST_PYCALL + if (PyFunction_Check(__pyx_t_4)) { + PyObject *__pyx_temp[3] = {__pyx_t_7, __pyx_t_5, __pyx_t_6}; + __pyx_t_3 = __Pyx_PyFunction_FastCall(__pyx_t_4, __pyx_temp+1-__pyx_t_8, 2+__pyx_t_8); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 612, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + } else + #endif + #if CYTHON_FAST_PYCCALL + if (__Pyx_PyFastCFunction_Check(__pyx_t_4)) { + PyObject *__pyx_temp[3] = {__pyx_t_7, __pyx_t_5, __pyx_t_6}; + __pyx_t_3 = __Pyx_PyCFunction_FastCall(__pyx_t_4, __pyx_temp+1-__pyx_t_8, 2+__pyx_t_8); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 612, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + } else + #endif + { + __pyx_t_9 = PyTuple_New(2+__pyx_t_8); if (unlikely(!__pyx_t_9)) __PYX_ERR(1, 612, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_9); + if (__pyx_t_7) { + __Pyx_GIVEREF(__pyx_t_7); PyTuple_SET_ITEM(__pyx_t_9, 0, __pyx_t_7); __pyx_t_7 = NULL; + } + __Pyx_GIVEREF(__pyx_t_5); + PyTuple_SET_ITEM(__pyx_t_9, 0+__pyx_t_8, __pyx_t_5); + __Pyx_GIVEREF(__pyx_t_6); + PyTuple_SET_ITEM(__pyx_t_9, 1+__pyx_t_8, __pyx_t_6); + __pyx_t_5 = 0; + __pyx_t_6 = 0; + __pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_4, __pyx_t_9, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 612, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + } + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_4 = NULL; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_4)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_4); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + } + } + if (!__pyx_t_4) { + __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_3); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 610, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_GOTREF(__pyx_t_1); + } else { + #if CYTHON_FAST_PYCALL + if (PyFunction_Check(__pyx_t_2)) { + PyObject *__pyx_temp[2] = {__pyx_t_4, __pyx_t_3}; + __pyx_t_1 = __Pyx_PyFunction_FastCall(__pyx_t_2, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 610, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + } else + #endif + #if CYTHON_FAST_PYCCALL + if (__Pyx_PyFastCFunction_Check(__pyx_t_2)) { + PyObject *__pyx_temp[2] = {__pyx_t_4, __pyx_t_3}; + __pyx_t_1 = __Pyx_PyCFunction_FastCall(__pyx_t_2, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 610, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + } else + #endif + { + __pyx_t_9 = PyTuple_New(1+1); if (unlikely(!__pyx_t_9)) __PYX_ERR(1, 610, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_9); + __Pyx_GIVEREF(__pyx_t_4); PyTuple_SET_ITEM(__pyx_t_9, 0, __pyx_t_4); __pyx_t_4 = NULL; + __Pyx_GIVEREF(__pyx_t_3); + PyTuple_SET_ITEM(__pyx_t_9, 0+1, __pyx_t_3); + __pyx_t_3 = 0; + __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_t_9, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 610, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + } + } + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_Raise(__pyx_t_1, 0, 0, 0); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __PYX_ERR(1, 610, __pyx_L1_error) + + /* "asyncpg/protocol/buffer.pyx":609 + * return self + * + * cdef _raise_ins_err(self, ssize_t n, ssize_t len): # <<<<<<<<<<<<<< + * raise BufferError( + * 'insufficient data in buffer: requested {}, remaining {}'. + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_XDECREF(__pyx_t_6); + __Pyx_XDECREF(__pyx_t_7); + __Pyx_XDECREF(__pyx_t_9); + __Pyx_AddTraceback("asyncpg.protocol.protocol.FastReadBuffer._raise_ins_err", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "asyncpg/protocol/buffer.pyx":615 + * + * @staticmethod + * cdef FastReadBuffer new(): # <<<<<<<<<<<<<< + * return FastReadBuffer.__new__(FastReadBuffer) + */ + +static struct __pyx_obj_7asyncpg_8protocol_8protocol_FastReadBuffer *__pyx_f_7asyncpg_8protocol_8protocol_14FastReadBuffer_new(void) { + struct __pyx_obj_7asyncpg_8protocol_8protocol_FastReadBuffer *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + __Pyx_RefNannySetupContext("new", 0); + + /* "asyncpg/protocol/buffer.pyx":616 + * @staticmethod + * cdef FastReadBuffer new(): + * return FastReadBuffer.__new__(FastReadBuffer) # <<<<<<<<<<<<<< + */ + __Pyx_XDECREF(((PyObject *)__pyx_r)); + __pyx_t_1 = __pyx_tp_new_7asyncpg_8protocol_8protocol_FastReadBuffer(((PyTypeObject *)__pyx_ptype_7asyncpg_8protocol_8protocol_FastReadBuffer), __pyx_empty_tuple, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 616, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (!(likely(__Pyx_TypeTest(__pyx_t_1, __pyx_ptype_7asyncpg_8protocol_8protocol_FastReadBuffer)))) __PYX_ERR(1, 616, __pyx_L1_error) + __pyx_r = ((struct __pyx_obj_7asyncpg_8protocol_8protocol_FastReadBuffer *)__pyx_t_1); + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "asyncpg/protocol/buffer.pyx":615 + * + * @staticmethod + * cdef FastReadBuffer new(): # <<<<<<<<<<<<<< + * return FastReadBuffer.__new__(FastReadBuffer) + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("asyncpg.protocol.protocol.FastReadBuffer.new", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XGIVEREF((PyObject *)__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "asyncpg/protocol/codecs/base.pyx":17 + * cdef class Codec: + * + * def __cinit__(self, uint32_t oid): # <<<<<<<<<<<<<< + * self.oid = oid + * self.type = CODEC_UNDEFINED + */ + +/* Python wrapper */ +static int __pyx_pw_7asyncpg_8protocol_8protocol_5Codec_1__cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ +static int __pyx_pw_7asyncpg_8protocol_8protocol_5Codec_1__cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { + uint32_t __pyx_v_oid; + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__cinit__ (wrapper)", 0); + { + static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_oid,0}; + PyObject* values[1] = {0}; + if (unlikely(__pyx_kwds)) { + Py_ssize_t kw_args; + const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args); + switch (pos_args) { + case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = PyDict_Size(__pyx_kwds); + switch (pos_args) { + case 0: + if (likely((values[0] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_oid)) != 0)) kw_args--; + else goto __pyx_L5_argtuple_error; + } + if (unlikely(kw_args > 0)) { + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "__cinit__") < 0)) __PYX_ERR(2, 17, __pyx_L3_error) + } + } else if (PyTuple_GET_SIZE(__pyx_args) != 1) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + } + __pyx_v_oid = __Pyx_PyInt_As_uint32_t(values[0]); if (unlikely((__pyx_v_oid == ((uint32_t)-1)) && PyErr_Occurred())) __PYX_ERR(2, 17, __pyx_L3_error) + } + goto __pyx_L4_argument_unpacking_done; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("__cinit__", 1, 1, 1, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(2, 17, __pyx_L3_error) + __pyx_L3_error:; + __Pyx_AddTraceback("asyncpg.protocol.protocol.Codec.__cinit__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return -1; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_7asyncpg_8protocol_8protocol_5Codec___cinit__(((struct __pyx_obj_7asyncpg_8protocol_8protocol_Codec *)__pyx_v_self), __pyx_v_oid); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_7asyncpg_8protocol_8protocol_5Codec___cinit__(struct __pyx_obj_7asyncpg_8protocol_8protocol_Codec *__pyx_v_self, uint32_t __pyx_v_oid) { + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__cinit__", 0); + + /* "asyncpg/protocol/codecs/base.pyx":18 + * + * def __cinit__(self, uint32_t oid): + * self.oid = oid # <<<<<<<<<<<<<< + * self.type = CODEC_UNDEFINED + * + */ + __pyx_v_self->oid = __pyx_v_oid; + + /* "asyncpg/protocol/codecs/base.pyx":19 + * def __cinit__(self, uint32_t oid): + * self.oid = oid + * self.type = CODEC_UNDEFINED # <<<<<<<<<<<<<< + * + * cdef init(self, str name, str schema, str kind, + */ + __pyx_v_self->type = __pyx_e_7asyncpg_8protocol_8protocol_CODEC_UNDEFINED; + + /* "asyncpg/protocol/codecs/base.pyx":17 + * cdef class Codec: + * + * def __cinit__(self, uint32_t oid): # <<<<<<<<<<<<<< + * self.oid = oid + * self.type = CODEC_UNDEFINED + */ + + /* function exit code */ + __pyx_r = 0; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "asyncpg/protocol/codecs/base.pyx":21 + * self.type = CODEC_UNDEFINED + * + * cdef init(self, str name, str schema, str kind, # <<<<<<<<<<<<<< + * CodecType type, CodecFormat format, + * encode_func c_encoder, decode_func c_decoder, + */ + +static PyObject *__pyx_f_7asyncpg_8protocol_8protocol_5Codec_init(struct __pyx_obj_7asyncpg_8protocol_8protocol_Codec *__pyx_v_self, PyObject *__pyx_v_name, PyObject *__pyx_v_schema, PyObject *__pyx_v_kind, enum __pyx_t_7asyncpg_8protocol_8protocol_CodecType __pyx_v_type, enum __pyx_t_7asyncpg_8protocol_8protocol_CodecFormat __pyx_v_format, __pyx_t_7asyncpg_8protocol_8protocol_encode_func __pyx_v_c_encoder, __pyx_t_7asyncpg_8protocol_8protocol_decode_func __pyx_v_c_decoder, PyObject *__pyx_v_py_encoder, PyObject *__pyx_v_py_decoder, struct __pyx_obj_7asyncpg_8protocol_8protocol_Codec *__pyx_v_element_codec, PyObject *__pyx_v_element_type_oids, PyObject *__pyx_v_element_names, PyObject *__pyx_v_element_codecs, Py_UCS4 __pyx_v_element_delimiter) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + int __pyx_t_2; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + PyObject *__pyx_t_5 = NULL; + PyObject *__pyx_t_6 = NULL; + PyObject *__pyx_t_7 = NULL; + __Pyx_RefNannySetupContext("init", 0); + + /* "asyncpg/protocol/codecs/base.pyx":29 + * Py_UCS4 element_delimiter): + * + * self.name = name # <<<<<<<<<<<<<< + * self.schema = schema + * self.kind = kind + */ + __Pyx_INCREF(__pyx_v_name); + __Pyx_GIVEREF(__pyx_v_name); + __Pyx_GOTREF(__pyx_v_self->name); + __Pyx_DECREF(__pyx_v_self->name); + __pyx_v_self->name = __pyx_v_name; + + /* "asyncpg/protocol/codecs/base.pyx":30 + * + * self.name = name + * self.schema = schema # <<<<<<<<<<<<<< + * self.kind = kind + * self.type = type + */ + __Pyx_INCREF(__pyx_v_schema); + __Pyx_GIVEREF(__pyx_v_schema); + __Pyx_GOTREF(__pyx_v_self->schema); + __Pyx_DECREF(__pyx_v_self->schema); + __pyx_v_self->schema = __pyx_v_schema; + + /* "asyncpg/protocol/codecs/base.pyx":31 + * self.name = name + * self.schema = schema + * self.kind = kind # <<<<<<<<<<<<<< + * self.type = type + * self.format = format + */ + __Pyx_INCREF(__pyx_v_kind); + __Pyx_GIVEREF(__pyx_v_kind); + __Pyx_GOTREF(__pyx_v_self->kind); + __Pyx_DECREF(__pyx_v_self->kind); + __pyx_v_self->kind = __pyx_v_kind; + + /* "asyncpg/protocol/codecs/base.pyx":32 + * self.schema = schema + * self.kind = kind + * self.type = type # <<<<<<<<<<<<<< + * self.format = format + * self.c_encoder = c_encoder + */ + __pyx_v_self->type = __pyx_v_type; + + /* "asyncpg/protocol/codecs/base.pyx":33 + * self.kind = kind + * self.type = type + * self.format = format # <<<<<<<<<<<<<< + * self.c_encoder = c_encoder + * self.c_decoder = c_decoder + */ + __pyx_v_self->format = __pyx_v_format; + + /* "asyncpg/protocol/codecs/base.pyx":34 + * self.type = type + * self.format = format + * self.c_encoder = c_encoder # <<<<<<<<<<<<<< + * self.c_decoder = c_decoder + * self.py_encoder = py_encoder + */ + __pyx_v_self->c_encoder = __pyx_v_c_encoder; + + /* "asyncpg/protocol/codecs/base.pyx":35 + * self.format = format + * self.c_encoder = c_encoder + * self.c_decoder = c_decoder # <<<<<<<<<<<<<< + * self.py_encoder = py_encoder + * self.py_decoder = py_decoder + */ + __pyx_v_self->c_decoder = __pyx_v_c_decoder; + + /* "asyncpg/protocol/codecs/base.pyx":36 + * self.c_encoder = c_encoder + * self.c_decoder = c_decoder + * self.py_encoder = py_encoder # <<<<<<<<<<<<<< + * self.py_decoder = py_decoder + * self.element_codec = element_codec + */ + __Pyx_INCREF(__pyx_v_py_encoder); + __Pyx_GIVEREF(__pyx_v_py_encoder); + __Pyx_GOTREF(__pyx_v_self->py_encoder); + __Pyx_DECREF(__pyx_v_self->py_encoder); + __pyx_v_self->py_encoder = __pyx_v_py_encoder; + + /* "asyncpg/protocol/codecs/base.pyx":37 + * self.c_decoder = c_decoder + * self.py_encoder = py_encoder + * self.py_decoder = py_decoder # <<<<<<<<<<<<<< + * self.element_codec = element_codec + * self.element_type_oids = element_type_oids + */ + __Pyx_INCREF(__pyx_v_py_decoder); + __Pyx_GIVEREF(__pyx_v_py_decoder); + __Pyx_GOTREF(__pyx_v_self->py_decoder); + __Pyx_DECREF(__pyx_v_self->py_decoder); + __pyx_v_self->py_decoder = __pyx_v_py_decoder; + + /* "asyncpg/protocol/codecs/base.pyx":38 + * self.py_encoder = py_encoder + * self.py_decoder = py_decoder + * self.element_codec = element_codec # <<<<<<<<<<<<<< + * self.element_type_oids = element_type_oids + * self.element_codecs = element_codecs + */ + __Pyx_INCREF(((PyObject *)__pyx_v_element_codec)); + __Pyx_GIVEREF(((PyObject *)__pyx_v_element_codec)); + __Pyx_GOTREF(__pyx_v_self->element_codec); + __Pyx_DECREF(((PyObject *)__pyx_v_self->element_codec)); + __pyx_v_self->element_codec = __pyx_v_element_codec; + + /* "asyncpg/protocol/codecs/base.pyx":39 + * self.py_decoder = py_decoder + * self.element_codec = element_codec + * self.element_type_oids = element_type_oids # <<<<<<<<<<<<<< + * self.element_codecs = element_codecs + * self.element_delimiter = element_delimiter + */ + __Pyx_INCREF(__pyx_v_element_type_oids); + __Pyx_GIVEREF(__pyx_v_element_type_oids); + __Pyx_GOTREF(__pyx_v_self->element_type_oids); + __Pyx_DECREF(__pyx_v_self->element_type_oids); + __pyx_v_self->element_type_oids = __pyx_v_element_type_oids; + + /* "asyncpg/protocol/codecs/base.pyx":40 + * self.element_codec = element_codec + * self.element_type_oids = element_type_oids + * self.element_codecs = element_codecs # <<<<<<<<<<<<<< + * self.element_delimiter = element_delimiter + * + */ + __Pyx_INCREF(__pyx_v_element_codecs); + __Pyx_GIVEREF(__pyx_v_element_codecs); + __Pyx_GOTREF(__pyx_v_self->element_codecs); + __Pyx_DECREF(__pyx_v_self->element_codecs); + __pyx_v_self->element_codecs = __pyx_v_element_codecs; + + /* "asyncpg/protocol/codecs/base.pyx":41 + * self.element_type_oids = element_type_oids + * self.element_codecs = element_codecs + * self.element_delimiter = element_delimiter # <<<<<<<<<<<<<< + * + * if element_names is not None: + */ + __pyx_v_self->element_delimiter = __pyx_v_element_delimiter; + + /* "asyncpg/protocol/codecs/base.pyx":43 + * self.element_delimiter = element_delimiter + * + * if element_names is not None: # <<<<<<<<<<<<<< + * self.element_names = record.ApgRecordDesc_New( + * element_names, tuple(element_names)) + */ + __pyx_t_1 = (__pyx_v_element_names != Py_None); + __pyx_t_2 = (__pyx_t_1 != 0); + if (__pyx_t_2) { + + /* "asyncpg/protocol/codecs/base.pyx":45 + * if element_names is not None: + * self.element_names = record.ApgRecordDesc_New( + * element_names, tuple(element_names)) # <<<<<<<<<<<<<< + * else: + * self.element_names = None + */ + __pyx_t_3 = PySequence_Tuple(__pyx_v_element_names); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 45, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + + /* "asyncpg/protocol/codecs/base.pyx":44 + * + * if element_names is not None: + * self.element_names = record.ApgRecordDesc_New( # <<<<<<<<<<<<<< + * element_names, tuple(element_names)) + * else: + */ + __pyx_t_4 = ApgRecordDesc_New(__pyx_v_element_names, __pyx_t_3); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 44, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_GIVEREF(__pyx_t_4); + __Pyx_GOTREF(__pyx_v_self->element_names); + __Pyx_DECREF(__pyx_v_self->element_names); + __pyx_v_self->element_names = __pyx_t_4; + __pyx_t_4 = 0; + + /* "asyncpg/protocol/codecs/base.pyx":43 + * self.element_delimiter = element_delimiter + * + * if element_names is not None: # <<<<<<<<<<<<<< + * self.element_names = record.ApgRecordDesc_New( + * element_names, tuple(element_names)) + */ + goto __pyx_L3; + } + + /* "asyncpg/protocol/codecs/base.pyx":47 + * element_names, tuple(element_names)) + * else: + * self.element_names = None # <<<<<<<<<<<<<< + * + * if type == CODEC_C: + */ + /*else*/ { + __Pyx_INCREF(Py_None); + __Pyx_GIVEREF(Py_None); + __Pyx_GOTREF(__pyx_v_self->element_names); + __Pyx_DECREF(__pyx_v_self->element_names); + __pyx_v_self->element_names = Py_None; + } + __pyx_L3:; + + /* "asyncpg/protocol/codecs/base.pyx":49 + * self.element_names = None + * + * if type == CODEC_C: # <<<<<<<<<<<<<< + * self.encoder = &self.encode_scalar + * self.decoder = &self.decode_scalar + */ + switch (__pyx_v_type) { + case __pyx_e_7asyncpg_8protocol_8protocol_CODEC_C: + + /* "asyncpg/protocol/codecs/base.pyx":50 + * + * if type == CODEC_C: + * self.encoder = &self.encode_scalar # <<<<<<<<<<<<<< + * self.decoder = &self.decode_scalar + * elif type == CODEC_ARRAY: + */ + __pyx_v_self->encoder = ((__pyx_t_7asyncpg_8protocol_8protocol_codec_encode_func)(&__pyx_f_7asyncpg_8protocol_8protocol_5Codec_encode_scalar)); + + /* "asyncpg/protocol/codecs/base.pyx":51 + * if type == CODEC_C: + * self.encoder = &self.encode_scalar + * self.decoder = &self.decode_scalar # <<<<<<<<<<<<<< + * elif type == CODEC_ARRAY: + * self.encoder = &self.encode_array + */ + __pyx_v_self->decoder = ((__pyx_t_7asyncpg_8protocol_8protocol_codec_decode_func)(&__pyx_f_7asyncpg_8protocol_8protocol_5Codec_decode_scalar)); + + /* "asyncpg/protocol/codecs/base.pyx":49 + * self.element_names = None + * + * if type == CODEC_C: # <<<<<<<<<<<<<< + * self.encoder = &self.encode_scalar + * self.decoder = &self.decode_scalar + */ + break; + + /* "asyncpg/protocol/codecs/base.pyx":52 + * self.encoder = &self.encode_scalar + * self.decoder = &self.decode_scalar + * elif type == CODEC_ARRAY: # <<<<<<<<<<<<<< + * self.encoder = &self.encode_array + * if format == PG_FORMAT_BINARY: + */ + case __pyx_e_7asyncpg_8protocol_8protocol_CODEC_ARRAY: + + /* "asyncpg/protocol/codecs/base.pyx":53 + * self.decoder = &self.decode_scalar + * elif type == CODEC_ARRAY: + * self.encoder = &self.encode_array # <<<<<<<<<<<<<< + * if format == PG_FORMAT_BINARY: + * self.decoder = &self.decode_array + */ + __pyx_v_self->encoder = ((__pyx_t_7asyncpg_8protocol_8protocol_codec_encode_func)(&__pyx_f_7asyncpg_8protocol_8protocol_5Codec_encode_array)); + + /* "asyncpg/protocol/codecs/base.pyx":54 + * elif type == CODEC_ARRAY: + * self.encoder = &self.encode_array + * if format == PG_FORMAT_BINARY: # <<<<<<<<<<<<<< + * self.decoder = &self.decode_array + * else: + */ + __pyx_t_2 = ((__pyx_v_format == __pyx_e_7asyncpg_8protocol_8protocol_PG_FORMAT_BINARY) != 0); + if (__pyx_t_2) { + + /* "asyncpg/protocol/codecs/base.pyx":55 + * self.encoder = &self.encode_array + * if format == PG_FORMAT_BINARY: + * self.decoder = &self.decode_array # <<<<<<<<<<<<<< + * else: + * self.decoder = &self.decode_array_text + */ + __pyx_v_self->decoder = ((__pyx_t_7asyncpg_8protocol_8protocol_codec_decode_func)(&__pyx_f_7asyncpg_8protocol_8protocol_5Codec_decode_array)); + + /* "asyncpg/protocol/codecs/base.pyx":54 + * elif type == CODEC_ARRAY: + * self.encoder = &self.encode_array + * if format == PG_FORMAT_BINARY: # <<<<<<<<<<<<<< + * self.decoder = &self.decode_array + * else: + */ + goto __pyx_L4; + } + + /* "asyncpg/protocol/codecs/base.pyx":57 + * self.decoder = &self.decode_array + * else: + * self.decoder = &self.decode_array_text # <<<<<<<<<<<<<< + * elif type == CODEC_RANGE: + * self.encoder = &self.encode_range + */ + /*else*/ { + __pyx_v_self->decoder = ((__pyx_t_7asyncpg_8protocol_8protocol_codec_decode_func)(&__pyx_f_7asyncpg_8protocol_8protocol_5Codec_decode_array_text)); + } + __pyx_L4:; + + /* "asyncpg/protocol/codecs/base.pyx":52 + * self.encoder = &self.encode_scalar + * self.decoder = &self.decode_scalar + * elif type == CODEC_ARRAY: # <<<<<<<<<<<<<< + * self.encoder = &self.encode_array + * if format == PG_FORMAT_BINARY: + */ + break; + + /* "asyncpg/protocol/codecs/base.pyx":58 + * else: + * self.decoder = &self.decode_array_text + * elif type == CODEC_RANGE: # <<<<<<<<<<<<<< + * self.encoder = &self.encode_range + * self.decoder = &self.decode_range + */ + case __pyx_e_7asyncpg_8protocol_8protocol_CODEC_RANGE: + + /* "asyncpg/protocol/codecs/base.pyx":59 + * self.decoder = &self.decode_array_text + * elif type == CODEC_RANGE: + * self.encoder = &self.encode_range # <<<<<<<<<<<<<< + * self.decoder = &self.decode_range + * elif type == CODEC_COMPOSITE: + */ + __pyx_v_self->encoder = ((__pyx_t_7asyncpg_8protocol_8protocol_codec_encode_func)(&__pyx_f_7asyncpg_8protocol_8protocol_5Codec_encode_range)); + + /* "asyncpg/protocol/codecs/base.pyx":60 + * elif type == CODEC_RANGE: + * self.encoder = &self.encode_range + * self.decoder = &self.decode_range # <<<<<<<<<<<<<< + * elif type == CODEC_COMPOSITE: + * self.encoder = &self.encode_composite + */ + __pyx_v_self->decoder = ((__pyx_t_7asyncpg_8protocol_8protocol_codec_decode_func)(&__pyx_f_7asyncpg_8protocol_8protocol_5Codec_decode_range)); + + /* "asyncpg/protocol/codecs/base.pyx":58 + * else: + * self.decoder = &self.decode_array_text + * elif type == CODEC_RANGE: # <<<<<<<<<<<<<< + * self.encoder = &self.encode_range + * self.decoder = &self.decode_range + */ + break; + + /* "asyncpg/protocol/codecs/base.pyx":61 + * self.encoder = &self.encode_range + * self.decoder = &self.decode_range + * elif type == CODEC_COMPOSITE: # <<<<<<<<<<<<<< + * self.encoder = &self.encode_composite + * self.decoder = &self.decode_composite + */ + case __pyx_e_7asyncpg_8protocol_8protocol_CODEC_COMPOSITE: + + /* "asyncpg/protocol/codecs/base.pyx":62 + * self.decoder = &self.decode_range + * elif type == CODEC_COMPOSITE: + * self.encoder = &self.encode_composite # <<<<<<<<<<<<<< + * self.decoder = &self.decode_composite + * elif type == CODEC_PY: + */ + __pyx_v_self->encoder = ((__pyx_t_7asyncpg_8protocol_8protocol_codec_encode_func)(&__pyx_f_7asyncpg_8protocol_8protocol_5Codec_encode_composite)); + + /* "asyncpg/protocol/codecs/base.pyx":63 + * elif type == CODEC_COMPOSITE: + * self.encoder = &self.encode_composite + * self.decoder = &self.decode_composite # <<<<<<<<<<<<<< + * elif type == CODEC_PY: + * self.encoder = &self.encode_in_python + */ + __pyx_v_self->decoder = ((__pyx_t_7asyncpg_8protocol_8protocol_codec_decode_func)(&__pyx_f_7asyncpg_8protocol_8protocol_5Codec_decode_composite)); + + /* "asyncpg/protocol/codecs/base.pyx":61 + * self.encoder = &self.encode_range + * self.decoder = &self.decode_range + * elif type == CODEC_COMPOSITE: # <<<<<<<<<<<<<< + * self.encoder = &self.encode_composite + * self.decoder = &self.decode_composite + */ + break; + + /* "asyncpg/protocol/codecs/base.pyx":64 + * self.encoder = &self.encode_composite + * self.decoder = &self.decode_composite + * elif type == CODEC_PY: # <<<<<<<<<<<<<< + * self.encoder = &self.encode_in_python + * self.decoder = &self.decode_in_python + */ + case __pyx_e_7asyncpg_8protocol_8protocol_CODEC_PY: + + /* "asyncpg/protocol/codecs/base.pyx":65 + * self.decoder = &self.decode_composite + * elif type == CODEC_PY: + * self.encoder = &self.encode_in_python # <<<<<<<<<<<<<< + * self.decoder = &self.decode_in_python + * else: + */ + __pyx_v_self->encoder = ((__pyx_t_7asyncpg_8protocol_8protocol_codec_encode_func)(&__pyx_f_7asyncpg_8protocol_8protocol_5Codec_encode_in_python)); + + /* "asyncpg/protocol/codecs/base.pyx":66 + * elif type == CODEC_PY: + * self.encoder = &self.encode_in_python + * self.decoder = &self.decode_in_python # <<<<<<<<<<<<<< + * else: + * raise RuntimeError('unexpected codec type: {}'.format(type)) + */ + __pyx_v_self->decoder = ((__pyx_t_7asyncpg_8protocol_8protocol_codec_decode_func)(&__pyx_f_7asyncpg_8protocol_8protocol_5Codec_decode_in_python)); + + /* "asyncpg/protocol/codecs/base.pyx":64 + * self.encoder = &self.encode_composite + * self.decoder = &self.decode_composite + * elif type == CODEC_PY: # <<<<<<<<<<<<<< + * self.encoder = &self.encode_in_python + * self.decoder = &self.decode_in_python + */ + break; + default: + + /* "asyncpg/protocol/codecs/base.pyx":68 + * self.decoder = &self.decode_in_python + * else: + * raise RuntimeError('unexpected codec type: {}'.format(type)) # <<<<<<<<<<<<<< + * + * cdef Codec copy(self): + */ + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_kp_u_unexpected_codec_type, __pyx_n_s_format); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 68, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_5 = __Pyx_PyInt_From_enum____pyx_t_7asyncpg_8protocol_8protocol_CodecType(__pyx_v_type); if (unlikely(!__pyx_t_5)) __PYX_ERR(2, 68, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_6 = NULL; + if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_3))) { + __pyx_t_6 = PyMethod_GET_SELF(__pyx_t_3); + if (likely(__pyx_t_6)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); + __Pyx_INCREF(__pyx_t_6); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_3, function); + } + } + if (!__pyx_t_6) { + __pyx_t_4 = __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_5); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 68, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_GOTREF(__pyx_t_4); + } else { + #if CYTHON_FAST_PYCALL + if (PyFunction_Check(__pyx_t_3)) { + PyObject *__pyx_temp[2] = {__pyx_t_6, __pyx_t_5}; + __pyx_t_4 = __Pyx_PyFunction_FastCall(__pyx_t_3, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 68, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + } else + #endif + #if CYTHON_FAST_PYCCALL + if (__Pyx_PyFastCFunction_Check(__pyx_t_3)) { + PyObject *__pyx_temp[2] = {__pyx_t_6, __pyx_t_5}; + __pyx_t_4 = __Pyx_PyCFunction_FastCall(__pyx_t_3, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 68, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + } else + #endif + { + __pyx_t_7 = PyTuple_New(1+1); if (unlikely(!__pyx_t_7)) __PYX_ERR(2, 68, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __Pyx_GIVEREF(__pyx_t_6); PyTuple_SET_ITEM(__pyx_t_7, 0, __pyx_t_6); __pyx_t_6 = NULL; + __Pyx_GIVEREF(__pyx_t_5); + PyTuple_SET_ITEM(__pyx_t_7, 0+1, __pyx_t_5); + __pyx_t_5 = 0; + __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_t_7, NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 68, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + } + } + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_3 = PyTuple_New(1); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 68, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_GIVEREF(__pyx_t_4); + PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_t_4); + __pyx_t_4 = 0; + __pyx_t_4 = __Pyx_PyObject_Call(__pyx_builtin_RuntimeError, __pyx_t_3, NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 68, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_Raise(__pyx_t_4, 0, 0, 0); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __PYX_ERR(2, 68, __pyx_L1_error) + break; + } + + /* "asyncpg/protocol/codecs/base.pyx":21 + * self.type = CODEC_UNDEFINED + * + * cdef init(self, str name, str schema, str kind, # <<<<<<<<<<<<<< + * CodecType type, CodecFormat format, + * encode_func c_encoder, decode_func c_decoder, + */ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_XDECREF(__pyx_t_6); + __Pyx_XDECREF(__pyx_t_7); + __Pyx_AddTraceback("asyncpg.protocol.protocol.Codec.init", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "asyncpg/protocol/codecs/base.pyx":70 + * raise RuntimeError('unexpected codec type: {}'.format(type)) + * + * cdef Codec copy(self): # <<<<<<<<<<<<<< + * cdef Codec codec + * + */ + +static CYTHON_INLINE struct __pyx_obj_7asyncpg_8protocol_8protocol_Codec *__pyx_f_7asyncpg_8protocol_8protocol_5Codec_copy(struct __pyx_obj_7asyncpg_8protocol_8protocol_Codec *__pyx_v_self) { + struct __pyx_obj_7asyncpg_8protocol_8protocol_Codec *__pyx_v_codec = 0; + struct __pyx_obj_7asyncpg_8protocol_8protocol_Codec *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + PyObject *__pyx_t_5 = NULL; + PyObject *__pyx_t_6 = NULL; + PyObject *__pyx_t_7 = NULL; + PyObject *__pyx_t_8 = NULL; + PyObject *__pyx_t_9 = NULL; + PyObject *__pyx_t_10 = NULL; + __Pyx_RefNannySetupContext("copy", 0); + + /* "asyncpg/protocol/codecs/base.pyx":73 + * cdef Codec codec + * + * codec = Codec(self.oid) # <<<<<<<<<<<<<< + * codec.init(self.name, self.schema, self.kind, + * self.type, self.format, + */ + __pyx_t_1 = __Pyx_PyInt_From_uint32_t(__pyx_v_self->oid); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 73, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = PyTuple_New(1); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 73, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_GIVEREF(__pyx_t_1); + PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_t_1); + __pyx_t_1 = 0; + __pyx_t_1 = __Pyx_PyObject_Call(((PyObject *)__pyx_ptype_7asyncpg_8protocol_8protocol_Codec), __pyx_t_2, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 73, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_v_codec = ((struct __pyx_obj_7asyncpg_8protocol_8protocol_Codec *)__pyx_t_1); + __pyx_t_1 = 0; + + /* "asyncpg/protocol/codecs/base.pyx":74 + * + * codec = Codec(self.oid) + * codec.init(self.name, self.schema, self.kind, # <<<<<<<<<<<<<< + * self.type, self.format, + * self.c_encoder, self.c_decoder, + */ + __pyx_t_1 = __pyx_v_self->name; + __Pyx_INCREF(__pyx_t_1); + __pyx_t_2 = __pyx_v_self->schema; + __Pyx_INCREF(__pyx_t_2); + __pyx_t_3 = __pyx_v_self->kind; + __Pyx_INCREF(__pyx_t_3); + + /* "asyncpg/protocol/codecs/base.pyx":77 + * self.type, self.format, + * self.c_encoder, self.c_decoder, + * self.py_encoder, self.py_decoder, # <<<<<<<<<<<<<< + * self.element_codec, + * self.element_type_oids, self.element_names, + */ + __pyx_t_4 = __pyx_v_self->py_encoder; + __Pyx_INCREF(__pyx_t_4); + __pyx_t_5 = __pyx_v_self->py_decoder; + __Pyx_INCREF(__pyx_t_5); + + /* "asyncpg/protocol/codecs/base.pyx":78 + * self.c_encoder, self.c_decoder, + * self.py_encoder, self.py_decoder, + * self.element_codec, # <<<<<<<<<<<<<< + * self.element_type_oids, self.element_names, + * self.element_codecs, self.element_delimiter) + */ + __pyx_t_6 = ((PyObject *)__pyx_v_self->element_codec); + __Pyx_INCREF(__pyx_t_6); + + /* "asyncpg/protocol/codecs/base.pyx":79 + * self.py_encoder, self.py_decoder, + * self.element_codec, + * self.element_type_oids, self.element_names, # <<<<<<<<<<<<<< + * self.element_codecs, self.element_delimiter) + * + */ + __pyx_t_7 = __pyx_v_self->element_type_oids; + __Pyx_INCREF(__pyx_t_7); + __pyx_t_8 = __pyx_v_self->element_names; + __Pyx_INCREF(__pyx_t_8); + + /* "asyncpg/protocol/codecs/base.pyx":80 + * self.element_codec, + * self.element_type_oids, self.element_names, + * self.element_codecs, self.element_delimiter) # <<<<<<<<<<<<<< + * + * return codec + */ + __pyx_t_9 = __pyx_v_self->element_codecs; + __Pyx_INCREF(__pyx_t_9); + + /* "asyncpg/protocol/codecs/base.pyx":74 + * + * codec = Codec(self.oid) + * codec.init(self.name, self.schema, self.kind, # <<<<<<<<<<<<<< + * self.type, self.format, + * self.c_encoder, self.c_decoder, + */ + __pyx_t_10 = __pyx_f_7asyncpg_8protocol_8protocol_5Codec_init(__pyx_v_codec, ((PyObject*)__pyx_t_1), ((PyObject*)__pyx_t_2), ((PyObject*)__pyx_t_3), __pyx_v_self->type, __pyx_v_self->format, __pyx_v_self->c_encoder, __pyx_v_self->c_decoder, __pyx_t_4, __pyx_t_5, ((struct __pyx_obj_7asyncpg_8protocol_8protocol_Codec *)__pyx_t_6), ((PyObject*)__pyx_t_7), __pyx_t_8, ((PyObject*)__pyx_t_9), __pyx_v_self->element_delimiter); if (unlikely(!__pyx_t_10)) __PYX_ERR(2, 74, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_10); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; + + /* "asyncpg/protocol/codecs/base.pyx":82 + * self.element_codecs, self.element_delimiter) + * + * return codec # <<<<<<<<<<<<<< + * + * cdef encode_scalar(self, ConnectionSettings settings, WriteBuffer buf, + */ + __Pyx_XDECREF(((PyObject *)__pyx_r)); + __Pyx_INCREF(((PyObject *)__pyx_v_codec)); + __pyx_r = __pyx_v_codec; + goto __pyx_L0; + + /* "asyncpg/protocol/codecs/base.pyx":70 + * raise RuntimeError('unexpected codec type: {}'.format(type)) + * + * cdef Codec copy(self): # <<<<<<<<<<<<<< + * cdef Codec codec + * + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_XDECREF(__pyx_t_6); + __Pyx_XDECREF(__pyx_t_7); + __Pyx_XDECREF(__pyx_t_8); + __Pyx_XDECREF(__pyx_t_9); + __Pyx_XDECREF(__pyx_t_10); + __Pyx_AddTraceback("asyncpg.protocol.protocol.Codec.copy", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XDECREF((PyObject *)__pyx_v_codec); + __Pyx_XGIVEREF((PyObject *)__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "asyncpg/protocol/codecs/base.pyx":84 + * return codec + * + * cdef encode_scalar(self, ConnectionSettings settings, WriteBuffer buf, # <<<<<<<<<<<<<< + * object obj): + * self.c_encoder(settings, buf, obj) + */ + +static PyObject *__pyx_f_7asyncpg_8protocol_8protocol_5Codec_encode_scalar(struct __pyx_obj_7asyncpg_8protocol_8protocol_Codec *__pyx_v_self, struct __pyx_obj_7asyncpg_8protocol_8protocol_ConnectionSettings *__pyx_v_settings, struct __pyx_obj_7asyncpg_8protocol_8protocol_WriteBuffer *__pyx_v_buf, PyObject *__pyx_v_obj) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + __Pyx_RefNannySetupContext("encode_scalar", 0); + + /* "asyncpg/protocol/codecs/base.pyx":86 + * cdef encode_scalar(self, ConnectionSettings settings, WriteBuffer buf, + * object obj): + * self.c_encoder(settings, buf, obj) # <<<<<<<<<<<<<< + * + * cdef encode_array(self, ConnectionSettings settings, WriteBuffer buf, + */ + __pyx_t_1 = __pyx_v_self->c_encoder(__pyx_v_settings, __pyx_v_buf, __pyx_v_obj); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 86, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "asyncpg/protocol/codecs/base.pyx":84 + * return codec + * + * cdef encode_scalar(self, ConnectionSettings settings, WriteBuffer buf, # <<<<<<<<<<<<<< + * object obj): + * self.c_encoder(settings, buf, obj) + */ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("asyncpg.protocol.protocol.Codec.encode_scalar", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "asyncpg/protocol/codecs/base.pyx":88 + * self.c_encoder(settings, buf, obj) + * + * cdef encode_array(self, ConnectionSettings settings, WriteBuffer buf, # <<<<<<<<<<<<<< + * object obj): + * array_encode(settings, buf, obj, self.element_codec.oid, + */ + +static PyObject *__pyx_f_7asyncpg_8protocol_8protocol_5Codec_encode_array(struct __pyx_obj_7asyncpg_8protocol_8protocol_Codec *__pyx_v_self, struct __pyx_obj_7asyncpg_8protocol_8protocol_ConnectionSettings *__pyx_v_settings, struct __pyx_obj_7asyncpg_8protocol_8protocol_WriteBuffer *__pyx_v_buf, PyObject *__pyx_v_obj) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + __Pyx_RefNannySetupContext("encode_array", 0); + + /* "asyncpg/protocol/codecs/base.pyx":90 + * cdef encode_array(self, ConnectionSettings settings, WriteBuffer buf, + * object obj): + * array_encode(settings, buf, obj, self.element_codec.oid, # <<<<<<<<<<<<<< + * codec_encode_func_ex, + * (self.element_codec)) + */ + __pyx_t_1 = __pyx_f_7asyncpg_8protocol_8protocol_array_encode(__pyx_v_settings, __pyx_v_buf, __pyx_v_obj, __pyx_v_self->element_codec->oid, __pyx_f_7asyncpg_8protocol_8protocol_codec_encode_func_ex, ((void *)__pyx_v_self->element_codec)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 90, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "asyncpg/protocol/codecs/base.pyx":88 + * self.c_encoder(settings, buf, obj) + * + * cdef encode_array(self, ConnectionSettings settings, WriteBuffer buf, # <<<<<<<<<<<<<< + * object obj): + * array_encode(settings, buf, obj, self.element_codec.oid, + */ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("asyncpg.protocol.protocol.Codec.encode_array", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "asyncpg/protocol/codecs/base.pyx":94 + * (self.element_codec)) + * + * cdef encode_range(self, ConnectionSettings settings, WriteBuffer buf, # <<<<<<<<<<<<<< + * object obj): + * range_encode(settings, buf, obj, self.element_codec.oid, + */ + +static PyObject *__pyx_f_7asyncpg_8protocol_8protocol_5Codec_encode_range(struct __pyx_obj_7asyncpg_8protocol_8protocol_Codec *__pyx_v_self, struct __pyx_obj_7asyncpg_8protocol_8protocol_ConnectionSettings *__pyx_v_settings, struct __pyx_obj_7asyncpg_8protocol_8protocol_WriteBuffer *__pyx_v_buf, PyObject *__pyx_v_obj) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + __Pyx_RefNannySetupContext("encode_range", 0); + + /* "asyncpg/protocol/codecs/base.pyx":96 + * cdef encode_range(self, ConnectionSettings settings, WriteBuffer buf, + * object obj): + * range_encode(settings, buf, obj, self.element_codec.oid, # <<<<<<<<<<<<<< + * codec_encode_func_ex, + * (self.element_codec)) + */ + __pyx_t_1 = __pyx_f_7asyncpg_8protocol_8protocol_range_encode(__pyx_v_settings, __pyx_v_buf, __pyx_v_obj, __pyx_v_self->element_codec->oid, __pyx_f_7asyncpg_8protocol_8protocol_codec_encode_func_ex, ((void *)__pyx_v_self->element_codec)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 96, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "asyncpg/protocol/codecs/base.pyx":94 + * (self.element_codec)) + * + * cdef encode_range(self, ConnectionSettings settings, WriteBuffer buf, # <<<<<<<<<<<<<< + * object obj): + * range_encode(settings, buf, obj, self.element_codec.oid, + */ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("asyncpg.protocol.protocol.Codec.encode_range", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "asyncpg/protocol/codecs/base.pyx":100 + * (self.element_codec)) + * + * cdef encode_composite(self, ConnectionSettings settings, WriteBuffer buf, # <<<<<<<<<<<<<< + * object obj): + * cdef: + */ + +static PyObject *__pyx_f_7asyncpg_8protocol_8protocol_5Codec_encode_composite(struct __pyx_obj_7asyncpg_8protocol_8protocol_Codec *__pyx_v_self, struct __pyx_obj_7asyncpg_8protocol_8protocol_ConnectionSettings *__pyx_v_settings, struct __pyx_obj_7asyncpg_8protocol_8protocol_WriteBuffer *__pyx_v_buf, PyObject *__pyx_v_obj) { + struct __pyx_obj_7asyncpg_8protocol_8protocol_WriteBuffer *__pyx_v_elem_data = 0; + int __pyx_v_i; + PyObject *__pyx_v_elem_codecs = 0; + Py_ssize_t __pyx_v_count; + PyObject *__pyx_v_item = NULL; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + Py_ssize_t __pyx_t_2; + int __pyx_t_3; + PyObject *(*__pyx_t_4)(PyObject *); + PyObject *__pyx_t_5 = NULL; + int32_t __pyx_t_6; + int __pyx_t_7; + PyObject *__pyx_t_8 = NULL; + __Pyx_RefNannySetupContext("encode_composite", 0); + + /* "asyncpg/protocol/codecs/base.pyx":105 + * WriteBuffer elem_data + * int i + * list elem_codecs = self.element_codecs # <<<<<<<<<<<<<< + * ssize_t count + * + */ + __pyx_t_1 = __pyx_v_self->element_codecs; + __Pyx_INCREF(__pyx_t_1); + __pyx_v_elem_codecs = ((PyObject*)__pyx_t_1); + __pyx_t_1 = 0; + + /* "asyncpg/protocol/codecs/base.pyx":108 + * ssize_t count + * + * count = len(obj) # <<<<<<<<<<<<<< + * if count > _MAXINT32: + * raise ValueError('too many elements in composite type record') + */ + __pyx_t_2 = PyObject_Length(__pyx_v_obj); if (unlikely(__pyx_t_2 == -1)) __PYX_ERR(2, 108, __pyx_L1_error) + __pyx_v_count = __pyx_t_2; + + /* "asyncpg/protocol/codecs/base.pyx":109 + * + * count = len(obj) + * if count > _MAXINT32: # <<<<<<<<<<<<<< + * raise ValueError('too many elements in composite type record') + * + */ + __pyx_t_3 = ((__pyx_v_count > 0x7FFFFFFF) != 0); + if (__pyx_t_3) { + + /* "asyncpg/protocol/codecs/base.pyx":110 + * count = len(obj) + * if count > _MAXINT32: + * raise ValueError('too many elements in composite type record') # <<<<<<<<<<<<<< + * + * elem_data = WriteBuffer.new() + */ + __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__25, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 110, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_Raise(__pyx_t_1, 0, 0, 0); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __PYX_ERR(2, 110, __pyx_L1_error) + + /* "asyncpg/protocol/codecs/base.pyx":109 + * + * count = len(obj) + * if count > _MAXINT32: # <<<<<<<<<<<<<< + * raise ValueError('too many elements in composite type record') + * + */ + } + + /* "asyncpg/protocol/codecs/base.pyx":112 + * raise ValueError('too many elements in composite type record') + * + * elem_data = WriteBuffer.new() # <<<<<<<<<<<<<< + * i = 0 + * for item in obj: + */ + __pyx_t_1 = ((PyObject *)__pyx_f_7asyncpg_8protocol_8protocol_11WriteBuffer_new()); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 112, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_v_elem_data = ((struct __pyx_obj_7asyncpg_8protocol_8protocol_WriteBuffer *)__pyx_t_1); + __pyx_t_1 = 0; + + /* "asyncpg/protocol/codecs/base.pyx":113 + * + * elem_data = WriteBuffer.new() + * i = 0 # <<<<<<<<<<<<<< + * for item in obj: + * elem_data.write_int32(self.element_type_oids[i]) + */ + __pyx_v_i = 0; + + /* "asyncpg/protocol/codecs/base.pyx":114 + * elem_data = WriteBuffer.new() + * i = 0 + * for item in obj: # <<<<<<<<<<<<<< + * elem_data.write_int32(self.element_type_oids[i]) + * if item is None: + */ + if (likely(PyList_CheckExact(__pyx_v_obj)) || PyTuple_CheckExact(__pyx_v_obj)) { + __pyx_t_1 = __pyx_v_obj; __Pyx_INCREF(__pyx_t_1); __pyx_t_2 = 0; + __pyx_t_4 = NULL; + } else { + __pyx_t_2 = -1; __pyx_t_1 = PyObject_GetIter(__pyx_v_obj); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 114, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_4 = Py_TYPE(__pyx_t_1)->tp_iternext; if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 114, __pyx_L1_error) + } + for (;;) { + if (likely(!__pyx_t_4)) { + if (likely(PyList_CheckExact(__pyx_t_1))) { + if (__pyx_t_2 >= PyList_GET_SIZE(__pyx_t_1)) break; + #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + __pyx_t_5 = PyList_GET_ITEM(__pyx_t_1, __pyx_t_2); __Pyx_INCREF(__pyx_t_5); __pyx_t_2++; if (unlikely(0 < 0)) __PYX_ERR(2, 114, __pyx_L1_error) + #else + __pyx_t_5 = PySequence_ITEM(__pyx_t_1, __pyx_t_2); __pyx_t_2++; if (unlikely(!__pyx_t_5)) __PYX_ERR(2, 114, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + #endif + } else { + if (__pyx_t_2 >= PyTuple_GET_SIZE(__pyx_t_1)) break; + #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + __pyx_t_5 = PyTuple_GET_ITEM(__pyx_t_1, __pyx_t_2); __Pyx_INCREF(__pyx_t_5); __pyx_t_2++; if (unlikely(0 < 0)) __PYX_ERR(2, 114, __pyx_L1_error) + #else + __pyx_t_5 = PySequence_ITEM(__pyx_t_1, __pyx_t_2); __pyx_t_2++; if (unlikely(!__pyx_t_5)) __PYX_ERR(2, 114, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + #endif + } + } else { + __pyx_t_5 = __pyx_t_4(__pyx_t_1); + if (unlikely(!__pyx_t_5)) { + PyObject* exc_type = PyErr_Occurred(); + if (exc_type) { + if (likely(exc_type == PyExc_StopIteration || PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) PyErr_Clear(); + else __PYX_ERR(2, 114, __pyx_L1_error) + } + break; + } + __Pyx_GOTREF(__pyx_t_5); + } + __Pyx_XDECREF_SET(__pyx_v_item, __pyx_t_5); + __pyx_t_5 = 0; + + /* "asyncpg/protocol/codecs/base.pyx":115 + * i = 0 + * for item in obj: + * elem_data.write_int32(self.element_type_oids[i]) # <<<<<<<<<<<<<< + * if item is None: + * elem_data.write_int32(-1) + */ + if (unlikely(__pyx_v_self->element_type_oids == Py_None)) { + PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable"); + __PYX_ERR(2, 115, __pyx_L1_error) + } + __pyx_t_5 = __Pyx_GetItemInt_Tuple(__pyx_v_self->element_type_oids, __pyx_v_i, int, 1, __Pyx_PyInt_From_int, 0, 1, 1); if (unlikely(!__pyx_t_5)) __PYX_ERR(2, 115, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_6 = __Pyx_PyInt_As_int32_t(__pyx_t_5); if (unlikely((__pyx_t_6 == ((int32_t)-1)) && PyErr_Occurred())) __PYX_ERR(2, 115, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __pyx_t_5 = __pyx_f_7asyncpg_8protocol_8protocol_11WriteBuffer_write_int32(__pyx_v_elem_data, ((int32_t)__pyx_t_6)); if (unlikely(!__pyx_t_5)) __PYX_ERR(2, 115, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + + /* "asyncpg/protocol/codecs/base.pyx":116 + * for item in obj: + * elem_data.write_int32(self.element_type_oids[i]) + * if item is None: # <<<<<<<<<<<<<< + * elem_data.write_int32(-1) + * else: + */ + __pyx_t_3 = (__pyx_v_item == Py_None); + __pyx_t_7 = (__pyx_t_3 != 0); + if (__pyx_t_7) { + + /* "asyncpg/protocol/codecs/base.pyx":117 + * elem_data.write_int32(self.element_type_oids[i]) + * if item is None: + * elem_data.write_int32(-1) # <<<<<<<<<<<<<< + * else: + * (elem_codecs[i]).encode(settings, elem_data, item) + */ + __pyx_t_5 = __pyx_f_7asyncpg_8protocol_8protocol_11WriteBuffer_write_int32(__pyx_v_elem_data, -1); if (unlikely(!__pyx_t_5)) __PYX_ERR(2, 117, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + + /* "asyncpg/protocol/codecs/base.pyx":116 + * for item in obj: + * elem_data.write_int32(self.element_type_oids[i]) + * if item is None: # <<<<<<<<<<<<<< + * elem_data.write_int32(-1) + * else: + */ + goto __pyx_L6; + } + + /* "asyncpg/protocol/codecs/base.pyx":119 + * elem_data.write_int32(-1) + * else: + * (elem_codecs[i]).encode(settings, elem_data, item) # <<<<<<<<<<<<<< + * i += 1 + * + */ + /*else*/ { + if (unlikely(__pyx_v_elem_codecs == Py_None)) { + PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable"); + __PYX_ERR(2, 119, __pyx_L1_error) + } + __pyx_t_5 = __Pyx_GetItemInt_List(__pyx_v_elem_codecs, __pyx_v_i, int, 1, __Pyx_PyInt_From_int, 1, 1, 1); if (unlikely(!__pyx_t_5)) __PYX_ERR(2, 119, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_8 = __pyx_f_7asyncpg_8protocol_8protocol_5Codec_encode(((struct __pyx_obj_7asyncpg_8protocol_8protocol_Codec *)__pyx_t_5), __pyx_v_settings, __pyx_v_elem_data, __pyx_v_item); if (unlikely(!__pyx_t_8)) __PYX_ERR(2, 119, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + } + __pyx_L6:; + + /* "asyncpg/protocol/codecs/base.pyx":120 + * else: + * (elem_codecs[i]).encode(settings, elem_data, item) + * i += 1 # <<<<<<<<<<<<<< + * + * record_encode_frame(settings, buf, elem_data, count) + */ + __pyx_v_i = (__pyx_v_i + 1); + + /* "asyncpg/protocol/codecs/base.pyx":114 + * elem_data = WriteBuffer.new() + * i = 0 + * for item in obj: # <<<<<<<<<<<<<< + * elem_data.write_int32(self.element_type_oids[i]) + * if item is None: + */ + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "asyncpg/protocol/codecs/base.pyx":122 + * i += 1 + * + * record_encode_frame(settings, buf, elem_data, count) # <<<<<<<<<<<<<< + * + * cdef encode_in_python(self, ConnectionSettings settings, WriteBuffer buf, + */ + __pyx_t_1 = __pyx_f_7asyncpg_8protocol_8protocol_record_encode_frame(__pyx_v_settings, __pyx_v_buf, __pyx_v_elem_data, ((int32_t)__pyx_v_count)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 122, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "asyncpg/protocol/codecs/base.pyx":100 + * (self.element_codec)) + * + * cdef encode_composite(self, ConnectionSettings settings, WriteBuffer buf, # <<<<<<<<<<<<<< + * object obj): + * cdef: + */ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_XDECREF(__pyx_t_8); + __Pyx_AddTraceback("asyncpg.protocol.protocol.Codec.encode_composite", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XDECREF((PyObject *)__pyx_v_elem_data); + __Pyx_XDECREF(__pyx_v_elem_codecs); + __Pyx_XDECREF(__pyx_v_item); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "asyncpg/protocol/codecs/base.pyx":124 + * record_encode_frame(settings, buf, elem_data, count) + * + * cdef encode_in_python(self, ConnectionSettings settings, WriteBuffer buf, # <<<<<<<<<<<<<< + * object obj): + * bb = self.py_encoder(obj) + */ + +static PyObject *__pyx_f_7asyncpg_8protocol_8protocol_5Codec_encode_in_python(struct __pyx_obj_7asyncpg_8protocol_8protocol_Codec *__pyx_v_self, struct __pyx_obj_7asyncpg_8protocol_8protocol_ConnectionSettings *__pyx_v_settings, struct __pyx_obj_7asyncpg_8protocol_8protocol_WriteBuffer *__pyx_v_buf, PyObject *__pyx_v_obj) { + PyObject *__pyx_v_bb = NULL; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + int __pyx_t_5; + __Pyx_RefNannySetupContext("encode_in_python", 0); + + /* "asyncpg/protocol/codecs/base.pyx":126 + * cdef encode_in_python(self, ConnectionSettings settings, WriteBuffer buf, + * object obj): + * bb = self.py_encoder(obj) # <<<<<<<<<<<<<< + * if self.format == PG_FORMAT_BINARY: + * bytea_encode(settings, buf, bb) + */ + __Pyx_INCREF(__pyx_v_self->py_encoder); + __pyx_t_2 = __pyx_v_self->py_encoder; __pyx_t_3 = NULL; + if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_3)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_3); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + } + } + if (!__pyx_t_3) { + __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_v_obj); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 126, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + } else { + #if CYTHON_FAST_PYCALL + if (PyFunction_Check(__pyx_t_2)) { + PyObject *__pyx_temp[2] = {__pyx_t_3, __pyx_v_obj}; + __pyx_t_1 = __Pyx_PyFunction_FastCall(__pyx_t_2, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 126, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_GOTREF(__pyx_t_1); + } else + #endif + #if CYTHON_FAST_PYCCALL + if (__Pyx_PyFastCFunction_Check(__pyx_t_2)) { + PyObject *__pyx_temp[2] = {__pyx_t_3, __pyx_v_obj}; + __pyx_t_1 = __Pyx_PyCFunction_FastCall(__pyx_t_2, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 126, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_GOTREF(__pyx_t_1); + } else + #endif + { + __pyx_t_4 = PyTuple_New(1+1); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 126, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_GIVEREF(__pyx_t_3); PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_3); __pyx_t_3 = NULL; + __Pyx_INCREF(__pyx_v_obj); + __Pyx_GIVEREF(__pyx_v_obj); + PyTuple_SET_ITEM(__pyx_t_4, 0+1, __pyx_v_obj); + __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_t_4, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 126, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + } + } + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_v_bb = __pyx_t_1; + __pyx_t_1 = 0; + + /* "asyncpg/protocol/codecs/base.pyx":127 + * object obj): + * bb = self.py_encoder(obj) + * if self.format == PG_FORMAT_BINARY: # <<<<<<<<<<<<<< + * bytea_encode(settings, buf, bb) + * else: + */ + __pyx_t_5 = ((__pyx_v_self->format == __pyx_e_7asyncpg_8protocol_8protocol_PG_FORMAT_BINARY) != 0); + if (__pyx_t_5) { + + /* "asyncpg/protocol/codecs/base.pyx":128 + * bb = self.py_encoder(obj) + * if self.format == PG_FORMAT_BINARY: + * bytea_encode(settings, buf, bb) # <<<<<<<<<<<<<< + * else: + * text_encode(settings, buf, bb) + */ + __pyx_t_1 = __pyx_f_7asyncpg_8protocol_8protocol_bytea_encode(__pyx_v_settings, __pyx_v_buf, __pyx_v_bb); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 128, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "asyncpg/protocol/codecs/base.pyx":127 + * object obj): + * bb = self.py_encoder(obj) + * if self.format == PG_FORMAT_BINARY: # <<<<<<<<<<<<<< + * bytea_encode(settings, buf, bb) + * else: + */ + goto __pyx_L3; + } + + /* "asyncpg/protocol/codecs/base.pyx":130 + * bytea_encode(settings, buf, bb) + * else: + * text_encode(settings, buf, bb) # <<<<<<<<<<<<<< + * + * cdef encode(self, ConnectionSettings settings, WriteBuffer buf, + */ + /*else*/ { + __pyx_t_1 = __pyx_f_7asyncpg_8protocol_8protocol_text_encode(__pyx_v_settings, __pyx_v_buf, __pyx_v_bb); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 130, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + } + __pyx_L3:; + + /* "asyncpg/protocol/codecs/base.pyx":124 + * record_encode_frame(settings, buf, elem_data, count) + * + * cdef encode_in_python(self, ConnectionSettings settings, WriteBuffer buf, # <<<<<<<<<<<<<< + * object obj): + * bb = self.py_encoder(obj) + */ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_AddTraceback("asyncpg.protocol.protocol.Codec.encode_in_python", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XDECREF(__pyx_v_bb); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "asyncpg/protocol/codecs/base.pyx":132 + * text_encode(settings, buf, bb) + * + * cdef encode(self, ConnectionSettings settings, WriteBuffer buf, # <<<<<<<<<<<<<< + * object obj): + * return self.encoder(self, settings, buf, obj) + */ + +static CYTHON_INLINE PyObject *__pyx_f_7asyncpg_8protocol_8protocol_5Codec_encode(struct __pyx_obj_7asyncpg_8protocol_8protocol_Codec *__pyx_v_self, struct __pyx_obj_7asyncpg_8protocol_8protocol_ConnectionSettings *__pyx_v_settings, struct __pyx_obj_7asyncpg_8protocol_8protocol_WriteBuffer *__pyx_v_buf, PyObject *__pyx_v_obj) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + __Pyx_RefNannySetupContext("encode", 0); + + /* "asyncpg/protocol/codecs/base.pyx":134 + * cdef encode(self, ConnectionSettings settings, WriteBuffer buf, + * object obj): + * return self.encoder(self, settings, buf, obj) # <<<<<<<<<<<<<< + * + * cdef decode_scalar(self, ConnectionSettings settings, FastReadBuffer buf): + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __pyx_v_self->encoder(__pyx_v_self, __pyx_v_settings, __pyx_v_buf, __pyx_v_obj); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 134, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "asyncpg/protocol/codecs/base.pyx":132 + * text_encode(settings, buf, bb) + * + * cdef encode(self, ConnectionSettings settings, WriteBuffer buf, # <<<<<<<<<<<<<< + * object obj): + * return self.encoder(self, settings, buf, obj) + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("asyncpg.protocol.protocol.Codec.encode", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "asyncpg/protocol/codecs/base.pyx":136 + * return self.encoder(self, settings, buf, obj) + * + * cdef decode_scalar(self, ConnectionSettings settings, FastReadBuffer buf): # <<<<<<<<<<<<<< + * return self.c_decoder(settings, buf) + * + */ + +static PyObject *__pyx_f_7asyncpg_8protocol_8protocol_5Codec_decode_scalar(struct __pyx_obj_7asyncpg_8protocol_8protocol_Codec *__pyx_v_self, struct __pyx_obj_7asyncpg_8protocol_8protocol_ConnectionSettings *__pyx_v_settings, struct __pyx_obj_7asyncpg_8protocol_8protocol_FastReadBuffer *__pyx_v_buf) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + __Pyx_RefNannySetupContext("decode_scalar", 0); + + /* "asyncpg/protocol/codecs/base.pyx":137 + * + * cdef decode_scalar(self, ConnectionSettings settings, FastReadBuffer buf): + * return self.c_decoder(settings, buf) # <<<<<<<<<<<<<< + * + * cdef decode_array(self, ConnectionSettings settings, FastReadBuffer buf): + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __pyx_v_self->c_decoder(__pyx_v_settings, __pyx_v_buf); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 137, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "asyncpg/protocol/codecs/base.pyx":136 + * return self.encoder(self, settings, buf, obj) + * + * cdef decode_scalar(self, ConnectionSettings settings, FastReadBuffer buf): # <<<<<<<<<<<<<< + * return self.c_decoder(settings, buf) + * + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("asyncpg.protocol.protocol.Codec.decode_scalar", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "asyncpg/protocol/codecs/base.pyx":139 + * return self.c_decoder(settings, buf) + * + * cdef decode_array(self, ConnectionSettings settings, FastReadBuffer buf): # <<<<<<<<<<<<<< + * return array_decode(settings, buf, codec_decode_func_ex, + * (self.element_codec)) + */ + +static PyObject *__pyx_f_7asyncpg_8protocol_8protocol_5Codec_decode_array(struct __pyx_obj_7asyncpg_8protocol_8protocol_Codec *__pyx_v_self, struct __pyx_obj_7asyncpg_8protocol_8protocol_ConnectionSettings *__pyx_v_settings, struct __pyx_obj_7asyncpg_8protocol_8protocol_FastReadBuffer *__pyx_v_buf) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + __Pyx_RefNannySetupContext("decode_array", 0); + + /* "asyncpg/protocol/codecs/base.pyx":140 + * + * cdef decode_array(self, ConnectionSettings settings, FastReadBuffer buf): + * return array_decode(settings, buf, codec_decode_func_ex, # <<<<<<<<<<<<<< + * (self.element_codec)) + * + */ + __Pyx_XDECREF(__pyx_r); + + /* "asyncpg/protocol/codecs/base.pyx":141 + * cdef decode_array(self, ConnectionSettings settings, FastReadBuffer buf): + * return array_decode(settings, buf, codec_decode_func_ex, + * (self.element_codec)) # <<<<<<<<<<<<<< + * + * cdef decode_array_text(self, ConnectionSettings settings, + */ + __pyx_t_1 = __pyx_f_7asyncpg_8protocol_8protocol_array_decode(__pyx_v_settings, __pyx_v_buf, __pyx_f_7asyncpg_8protocol_8protocol_codec_decode_func_ex, ((void *)__pyx_v_self->element_codec)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 140, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "asyncpg/protocol/codecs/base.pyx":139 + * return self.c_decoder(settings, buf) + * + * cdef decode_array(self, ConnectionSettings settings, FastReadBuffer buf): # <<<<<<<<<<<<<< + * return array_decode(settings, buf, codec_decode_func_ex, + * (self.element_codec)) + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("asyncpg.protocol.protocol.Codec.decode_array", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "asyncpg/protocol/codecs/base.pyx":143 + * (self.element_codec)) + * + * cdef decode_array_text(self, ConnectionSettings settings, # <<<<<<<<<<<<<< + * FastReadBuffer buf): + * return textarray_decode(settings, buf, codec_decode_func_ex, + */ + +static PyObject *__pyx_f_7asyncpg_8protocol_8protocol_5Codec_decode_array_text(struct __pyx_obj_7asyncpg_8protocol_8protocol_Codec *__pyx_v_self, struct __pyx_obj_7asyncpg_8protocol_8protocol_ConnectionSettings *__pyx_v_settings, struct __pyx_obj_7asyncpg_8protocol_8protocol_FastReadBuffer *__pyx_v_buf) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + __Pyx_RefNannySetupContext("decode_array_text", 0); + + /* "asyncpg/protocol/codecs/base.pyx":145 + * cdef decode_array_text(self, ConnectionSettings settings, + * FastReadBuffer buf): + * return textarray_decode(settings, buf, codec_decode_func_ex, # <<<<<<<<<<<<<< + * (self.element_codec), + * self.element_delimiter) + */ + __Pyx_XDECREF(__pyx_r); + + /* "asyncpg/protocol/codecs/base.pyx":147 + * return textarray_decode(settings, buf, codec_decode_func_ex, + * (self.element_codec), + * self.element_delimiter) # <<<<<<<<<<<<<< + * + * cdef decode_range(self, ConnectionSettings settings, FastReadBuffer buf): + */ + __pyx_t_1 = __pyx_f_7asyncpg_8protocol_8protocol_textarray_decode(__pyx_v_settings, __pyx_v_buf, __pyx_f_7asyncpg_8protocol_8protocol_codec_decode_func_ex, ((void *)__pyx_v_self->element_codec), __pyx_v_self->element_delimiter); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 145, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "asyncpg/protocol/codecs/base.pyx":143 + * (self.element_codec)) + * + * cdef decode_array_text(self, ConnectionSettings settings, # <<<<<<<<<<<<<< + * FastReadBuffer buf): + * return textarray_decode(settings, buf, codec_decode_func_ex, + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("asyncpg.protocol.protocol.Codec.decode_array_text", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "asyncpg/protocol/codecs/base.pyx":149 + * self.element_delimiter) + * + * cdef decode_range(self, ConnectionSettings settings, FastReadBuffer buf): # <<<<<<<<<<<<<< + * return range_decode(settings, buf, codec_decode_func_ex, + * (self.element_codec)) + */ + +static PyObject *__pyx_f_7asyncpg_8protocol_8protocol_5Codec_decode_range(struct __pyx_obj_7asyncpg_8protocol_8protocol_Codec *__pyx_v_self, struct __pyx_obj_7asyncpg_8protocol_8protocol_ConnectionSettings *__pyx_v_settings, struct __pyx_obj_7asyncpg_8protocol_8protocol_FastReadBuffer *__pyx_v_buf) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + __Pyx_RefNannySetupContext("decode_range", 0); + + /* "asyncpg/protocol/codecs/base.pyx":150 + * + * cdef decode_range(self, ConnectionSettings settings, FastReadBuffer buf): + * return range_decode(settings, buf, codec_decode_func_ex, # <<<<<<<<<<<<<< + * (self.element_codec)) + * + */ + __Pyx_XDECREF(__pyx_r); + + /* "asyncpg/protocol/codecs/base.pyx":151 + * cdef decode_range(self, ConnectionSettings settings, FastReadBuffer buf): + * return range_decode(settings, buf, codec_decode_func_ex, + * (self.element_codec)) # <<<<<<<<<<<<<< + * + * cdef decode_composite(self, ConnectionSettings settings, + */ + __pyx_t_1 = __pyx_f_7asyncpg_8protocol_8protocol_range_decode(__pyx_v_settings, __pyx_v_buf, __pyx_f_7asyncpg_8protocol_8protocol_codec_decode_func_ex, ((void *)__pyx_v_self->element_codec)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 150, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "asyncpg/protocol/codecs/base.pyx":149 + * self.element_delimiter) + * + * cdef decode_range(self, ConnectionSettings settings, FastReadBuffer buf): # <<<<<<<<<<<<<< + * return range_decode(settings, buf, codec_decode_func_ex, + * (self.element_codec)) + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("asyncpg.protocol.protocol.Codec.decode_range", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "asyncpg/protocol/codecs/base.pyx":153 + * (self.element_codec)) + * + * cdef decode_composite(self, ConnectionSettings settings, # <<<<<<<<<<<<<< + * FastReadBuffer buf): + * cdef: + */ + +static PyObject *__pyx_f_7asyncpg_8protocol_8protocol_5Codec_decode_composite(struct __pyx_obj_7asyncpg_8protocol_8protocol_Codec *__pyx_v_self, struct __pyx_obj_7asyncpg_8protocol_8protocol_ConnectionSettings *__pyx_v_settings, struct __pyx_obj_7asyncpg_8protocol_8protocol_FastReadBuffer *__pyx_v_buf) { + PyObject *__pyx_v_result = 0; + uint32_t __pyx_v_elem_count; + uint32_t __pyx_v_i; + int32_t __pyx_v_elem_len; + uint32_t __pyx_v_elem_typ; + uint32_t __pyx_v_received_elem_typ; + struct __pyx_obj_7asyncpg_8protocol_8protocol_Codec *__pyx_v_elem_codec = 0; + struct __pyx_obj_7asyncpg_8protocol_8protocol_FastReadBuffer *__pyx_v_elem_buf = 0; + PyObject *__pyx_v_elem = NULL; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + char const *__pyx_t_2; + PyObject *__pyx_t_3 = NULL; + uint32_t __pyx_t_4; + uint32_t __pyx_t_5; + uint32_t __pyx_t_6; + int __pyx_t_7; + PyObject *__pyx_t_8 = NULL; + PyObject *__pyx_t_9 = NULL; + PyObject *__pyx_t_10 = NULL; + PyObject *__pyx_t_11 = NULL; + PyObject *__pyx_t_12 = NULL; + PyObject *__pyx_t_13 = NULL; + int __pyx_t_14; + PyObject *__pyx_t_15 = NULL; + PyObject *__pyx_t_16 = NULL; + __Pyx_RefNannySetupContext("decode_composite", 0); + + /* "asyncpg/protocol/codecs/base.pyx":163 + * uint32_t received_elem_typ + * Codec elem_codec + * FastReadBuffer elem_buf = FastReadBuffer.new() # <<<<<<<<<<<<<< + * + * elem_count = hton.unpack_int32(buf.read(4)) + */ + __pyx_t_1 = ((PyObject *)__pyx_f_7asyncpg_8protocol_8protocol_14FastReadBuffer_new()); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 163, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_v_elem_buf = ((struct __pyx_obj_7asyncpg_8protocol_8protocol_FastReadBuffer *)__pyx_t_1); + __pyx_t_1 = 0; + + /* "asyncpg/protocol/codecs/base.pyx":165 + * FastReadBuffer elem_buf = FastReadBuffer.new() + * + * elem_count = hton.unpack_int32(buf.read(4)) # <<<<<<<<<<<<<< + * result = record.ApgRecord_New(self.element_names, elem_count) + * for i in range(elem_count): + */ + __pyx_t_2 = __pyx_f_7asyncpg_8protocol_8protocol_14FastReadBuffer_read(__pyx_v_buf, 4); if (unlikely(__pyx_t_2 == NULL)) __PYX_ERR(2, 165, __pyx_L1_error) + __pyx_v_elem_count = ((uint32_t)__pyx_f_7asyncpg_8protocol_4hton_unpack_int32(__pyx_t_2)); + + /* "asyncpg/protocol/codecs/base.pyx":166 + * + * elem_count = hton.unpack_int32(buf.read(4)) + * result = record.ApgRecord_New(self.element_names, elem_count) # <<<<<<<<<<<<<< + * for i in range(elem_count): + * elem_typ = self.element_type_oids[i] + */ + __pyx_t_1 = __pyx_v_self->element_names; + __Pyx_INCREF(__pyx_t_1); + __pyx_t_3 = ApgRecord_New(__pyx_t_1, __pyx_v_elem_count); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 166, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_v_result = __pyx_t_3; + __pyx_t_3 = 0; + + /* "asyncpg/protocol/codecs/base.pyx":167 + * elem_count = hton.unpack_int32(buf.read(4)) + * result = record.ApgRecord_New(self.element_names, elem_count) + * for i in range(elem_count): # <<<<<<<<<<<<<< + * elem_typ = self.element_type_oids[i] + * received_elem_typ = hton.unpack_int32(buf.read(4)) + */ + __pyx_t_4 = __pyx_v_elem_count; + for (__pyx_t_5 = 0; __pyx_t_5 < __pyx_t_4; __pyx_t_5+=1) { + __pyx_v_i = __pyx_t_5; + + /* "asyncpg/protocol/codecs/base.pyx":168 + * result = record.ApgRecord_New(self.element_names, elem_count) + * for i in range(elem_count): + * elem_typ = self.element_type_oids[i] # <<<<<<<<<<<<<< + * received_elem_typ = hton.unpack_int32(buf.read(4)) + * + */ + if (unlikely(__pyx_v_self->element_type_oids == Py_None)) { + PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable"); + __PYX_ERR(2, 168, __pyx_L1_error) + } + __pyx_t_3 = __Pyx_GetItemInt_Tuple(__pyx_v_self->element_type_oids, __pyx_v_i, uint32_t, 0, __Pyx_PyInt_From_uint32_t, 0, 0, 1); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 168, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_6 = __Pyx_PyInt_As_uint32_t(__pyx_t_3); if (unlikely((__pyx_t_6 == ((uint32_t)-1)) && PyErr_Occurred())) __PYX_ERR(2, 168, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_v_elem_typ = __pyx_t_6; + + /* "asyncpg/protocol/codecs/base.pyx":169 + * for i in range(elem_count): + * elem_typ = self.element_type_oids[i] + * received_elem_typ = hton.unpack_int32(buf.read(4)) # <<<<<<<<<<<<<< + * + * if received_elem_typ != elem_typ: + */ + __pyx_t_2 = __pyx_f_7asyncpg_8protocol_8protocol_14FastReadBuffer_read(__pyx_v_buf, 4); if (unlikely(__pyx_t_2 == NULL)) __PYX_ERR(2, 169, __pyx_L1_error) + __pyx_v_received_elem_typ = ((uint32_t)__pyx_f_7asyncpg_8protocol_4hton_unpack_int32(__pyx_t_2)); + + /* "asyncpg/protocol/codecs/base.pyx":171 + * received_elem_typ = hton.unpack_int32(buf.read(4)) + * + * if received_elem_typ != elem_typ: # <<<<<<<<<<<<<< + * raise RuntimeError( + * 'unexpected data type of composite type attribute {}: ' + */ + __pyx_t_7 = ((__pyx_v_received_elem_typ != __pyx_v_elem_typ) != 0); + if (__pyx_t_7) { + + /* "asyncpg/protocol/codecs/base.pyx":175 + * 'unexpected data type of composite type attribute {}: ' + * '{!r}, expected {!r}' + * .format( # <<<<<<<<<<<<<< + * i, + * TYPEMAP.get(received_elem_typ, received_elem_typ), + */ + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_kp_u_unexpected_data_type_of_composit, __pyx_n_s_format); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 175, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + + /* "asyncpg/protocol/codecs/base.pyx":176 + * '{!r}, expected {!r}' + * .format( + * i, # <<<<<<<<<<<<<< + * TYPEMAP.get(received_elem_typ, received_elem_typ), + * TYPEMAP.get(elem_typ, elem_typ) + */ + __pyx_t_8 = __Pyx_PyInt_From_uint32_t(__pyx_v_i); if (unlikely(!__pyx_t_8)) __PYX_ERR(2, 176, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + + /* "asyncpg/protocol/codecs/base.pyx":177 + * .format( + * i, + * TYPEMAP.get(received_elem_typ, received_elem_typ), # <<<<<<<<<<<<<< + * TYPEMAP.get(elem_typ, elem_typ) + * ) + */ + __pyx_t_10 = __Pyx_GetModuleGlobalName(__pyx_n_s_TYPEMAP); if (unlikely(!__pyx_t_10)) __PYX_ERR(2, 177, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_10); + __pyx_t_11 = __Pyx_PyObject_GetAttrStr(__pyx_t_10, __pyx_n_s_get); if (unlikely(!__pyx_t_11)) __PYX_ERR(2, 177, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_11); + __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; + __pyx_t_10 = __Pyx_PyInt_From_uint32_t(__pyx_v_received_elem_typ); if (unlikely(!__pyx_t_10)) __PYX_ERR(2, 177, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_10); + __pyx_t_12 = __Pyx_PyInt_From_uint32_t(__pyx_v_received_elem_typ); if (unlikely(!__pyx_t_12)) __PYX_ERR(2, 177, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_12); + __pyx_t_13 = NULL; + __pyx_t_14 = 0; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_11))) { + __pyx_t_13 = PyMethod_GET_SELF(__pyx_t_11); + if (likely(__pyx_t_13)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_11); + __Pyx_INCREF(__pyx_t_13); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_11, function); + __pyx_t_14 = 1; + } + } + #if CYTHON_FAST_PYCALL + if (PyFunction_Check(__pyx_t_11)) { + PyObject *__pyx_temp[3] = {__pyx_t_13, __pyx_t_10, __pyx_t_12}; + __pyx_t_9 = __Pyx_PyFunction_FastCall(__pyx_t_11, __pyx_temp+1-__pyx_t_14, 2+__pyx_t_14); if (unlikely(!__pyx_t_9)) __PYX_ERR(2, 177, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_13); __pyx_t_13 = 0; + __Pyx_GOTREF(__pyx_t_9); + __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; + __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0; + } else + #endif + #if CYTHON_FAST_PYCCALL + if (__Pyx_PyFastCFunction_Check(__pyx_t_11)) { + PyObject *__pyx_temp[3] = {__pyx_t_13, __pyx_t_10, __pyx_t_12}; + __pyx_t_9 = __Pyx_PyCFunction_FastCall(__pyx_t_11, __pyx_temp+1-__pyx_t_14, 2+__pyx_t_14); if (unlikely(!__pyx_t_9)) __PYX_ERR(2, 177, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_13); __pyx_t_13 = 0; + __Pyx_GOTREF(__pyx_t_9); + __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; + __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0; + } else + #endif + { + __pyx_t_15 = PyTuple_New(2+__pyx_t_14); if (unlikely(!__pyx_t_15)) __PYX_ERR(2, 177, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_15); + if (__pyx_t_13) { + __Pyx_GIVEREF(__pyx_t_13); PyTuple_SET_ITEM(__pyx_t_15, 0, __pyx_t_13); __pyx_t_13 = NULL; + } + __Pyx_GIVEREF(__pyx_t_10); + PyTuple_SET_ITEM(__pyx_t_15, 0+__pyx_t_14, __pyx_t_10); + __Pyx_GIVEREF(__pyx_t_12); + PyTuple_SET_ITEM(__pyx_t_15, 1+__pyx_t_14, __pyx_t_12); + __pyx_t_10 = 0; + __pyx_t_12 = 0; + __pyx_t_9 = __Pyx_PyObject_Call(__pyx_t_11, __pyx_t_15, NULL); if (unlikely(!__pyx_t_9)) __PYX_ERR(2, 177, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_9); + __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0; + } + __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0; + + /* "asyncpg/protocol/codecs/base.pyx":178 + * i, + * TYPEMAP.get(received_elem_typ, received_elem_typ), + * TYPEMAP.get(elem_typ, elem_typ) # <<<<<<<<<<<<<< + * ) + * ) + */ + __pyx_t_15 = __Pyx_GetModuleGlobalName(__pyx_n_s_TYPEMAP); if (unlikely(!__pyx_t_15)) __PYX_ERR(2, 178, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_15); + __pyx_t_12 = __Pyx_PyObject_GetAttrStr(__pyx_t_15, __pyx_n_s_get); if (unlikely(!__pyx_t_12)) __PYX_ERR(2, 178, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_12); + __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0; + __pyx_t_15 = __Pyx_PyInt_From_uint32_t(__pyx_v_elem_typ); if (unlikely(!__pyx_t_15)) __PYX_ERR(2, 178, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_15); + __pyx_t_10 = __Pyx_PyInt_From_uint32_t(__pyx_v_elem_typ); if (unlikely(!__pyx_t_10)) __PYX_ERR(2, 178, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_10); + __pyx_t_13 = NULL; + __pyx_t_14 = 0; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_12))) { + __pyx_t_13 = PyMethod_GET_SELF(__pyx_t_12); + if (likely(__pyx_t_13)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_12); + __Pyx_INCREF(__pyx_t_13); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_12, function); + __pyx_t_14 = 1; + } + } + #if CYTHON_FAST_PYCALL + if (PyFunction_Check(__pyx_t_12)) { + PyObject *__pyx_temp[3] = {__pyx_t_13, __pyx_t_15, __pyx_t_10}; + __pyx_t_11 = __Pyx_PyFunction_FastCall(__pyx_t_12, __pyx_temp+1-__pyx_t_14, 2+__pyx_t_14); if (unlikely(!__pyx_t_11)) __PYX_ERR(2, 178, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_13); __pyx_t_13 = 0; + __Pyx_GOTREF(__pyx_t_11); + __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0; + __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; + } else + #endif + #if CYTHON_FAST_PYCCALL + if (__Pyx_PyFastCFunction_Check(__pyx_t_12)) { + PyObject *__pyx_temp[3] = {__pyx_t_13, __pyx_t_15, __pyx_t_10}; + __pyx_t_11 = __Pyx_PyCFunction_FastCall(__pyx_t_12, __pyx_temp+1-__pyx_t_14, 2+__pyx_t_14); if (unlikely(!__pyx_t_11)) __PYX_ERR(2, 178, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_13); __pyx_t_13 = 0; + __Pyx_GOTREF(__pyx_t_11); + __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0; + __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; + } else + #endif + { + __pyx_t_16 = PyTuple_New(2+__pyx_t_14); if (unlikely(!__pyx_t_16)) __PYX_ERR(2, 178, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_16); + if (__pyx_t_13) { + __Pyx_GIVEREF(__pyx_t_13); PyTuple_SET_ITEM(__pyx_t_16, 0, __pyx_t_13); __pyx_t_13 = NULL; + } + __Pyx_GIVEREF(__pyx_t_15); + PyTuple_SET_ITEM(__pyx_t_16, 0+__pyx_t_14, __pyx_t_15); + __Pyx_GIVEREF(__pyx_t_10); + PyTuple_SET_ITEM(__pyx_t_16, 1+__pyx_t_14, __pyx_t_10); + __pyx_t_15 = 0; + __pyx_t_10 = 0; + __pyx_t_11 = __Pyx_PyObject_Call(__pyx_t_12, __pyx_t_16, NULL); if (unlikely(!__pyx_t_11)) __PYX_ERR(2, 178, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_11); + __Pyx_DECREF(__pyx_t_16); __pyx_t_16 = 0; + } + __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0; + __pyx_t_12 = NULL; + __pyx_t_14 = 0; + if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_1))) { + __pyx_t_12 = PyMethod_GET_SELF(__pyx_t_1); + if (likely(__pyx_t_12)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_1); + __Pyx_INCREF(__pyx_t_12); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_1, function); + __pyx_t_14 = 1; + } + } + #if CYTHON_FAST_PYCALL + if (PyFunction_Check(__pyx_t_1)) { + PyObject *__pyx_temp[4] = {__pyx_t_12, __pyx_t_8, __pyx_t_9, __pyx_t_11}; + __pyx_t_3 = __Pyx_PyFunction_FastCall(__pyx_t_1, __pyx_temp+1-__pyx_t_14, 3+__pyx_t_14); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 175, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_12); __pyx_t_12 = 0; + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0; + } else + #endif + #if CYTHON_FAST_PYCCALL + if (__Pyx_PyFastCFunction_Check(__pyx_t_1)) { + PyObject *__pyx_temp[4] = {__pyx_t_12, __pyx_t_8, __pyx_t_9, __pyx_t_11}; + __pyx_t_3 = __Pyx_PyCFunction_FastCall(__pyx_t_1, __pyx_temp+1-__pyx_t_14, 3+__pyx_t_14); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 175, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_12); __pyx_t_12 = 0; + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0; + } else + #endif + { + __pyx_t_16 = PyTuple_New(3+__pyx_t_14); if (unlikely(!__pyx_t_16)) __PYX_ERR(2, 175, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_16); + if (__pyx_t_12) { + __Pyx_GIVEREF(__pyx_t_12); PyTuple_SET_ITEM(__pyx_t_16, 0, __pyx_t_12); __pyx_t_12 = NULL; + } + __Pyx_GIVEREF(__pyx_t_8); + PyTuple_SET_ITEM(__pyx_t_16, 0+__pyx_t_14, __pyx_t_8); + __Pyx_GIVEREF(__pyx_t_9); + PyTuple_SET_ITEM(__pyx_t_16, 1+__pyx_t_14, __pyx_t_9); + __Pyx_GIVEREF(__pyx_t_11); + PyTuple_SET_ITEM(__pyx_t_16, 2+__pyx_t_14, __pyx_t_11); + __pyx_t_8 = 0; + __pyx_t_9 = 0; + __pyx_t_11 = 0; + __pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_t_16, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 175, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_16); __pyx_t_16 = 0; + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "asyncpg/protocol/codecs/base.pyx":172 + * + * if received_elem_typ != elem_typ: + * raise RuntimeError( # <<<<<<<<<<<<<< + * 'unexpected data type of composite type attribute {}: ' + * '{!r}, expected {!r}' + */ + __pyx_t_1 = PyTuple_New(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 172, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_GIVEREF(__pyx_t_3); + PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_t_3); + __pyx_t_3 = 0; + __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_RuntimeError, __pyx_t_1, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 172, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_Raise(__pyx_t_3, 0, 0, 0); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __PYX_ERR(2, 172, __pyx_L1_error) + + /* "asyncpg/protocol/codecs/base.pyx":171 + * received_elem_typ = hton.unpack_int32(buf.read(4)) + * + * if received_elem_typ != elem_typ: # <<<<<<<<<<<<<< + * raise RuntimeError( + * 'unexpected data type of composite type attribute {}: ' + */ + } + + /* "asyncpg/protocol/codecs/base.pyx":182 + * ) + * + * elem_len = hton.unpack_int32(buf.read(4)) # <<<<<<<<<<<<<< + * if elem_len == -1: + * elem = None + */ + __pyx_t_2 = __pyx_f_7asyncpg_8protocol_8protocol_14FastReadBuffer_read(__pyx_v_buf, 4); if (unlikely(__pyx_t_2 == NULL)) __PYX_ERR(2, 182, __pyx_L1_error) + __pyx_v_elem_len = __pyx_f_7asyncpg_8protocol_4hton_unpack_int32(__pyx_t_2); + + /* "asyncpg/protocol/codecs/base.pyx":183 + * + * elem_len = hton.unpack_int32(buf.read(4)) + * if elem_len == -1: # <<<<<<<<<<<<<< + * elem = None + * else: + */ + __pyx_t_7 = ((__pyx_v_elem_len == -1L) != 0); + if (__pyx_t_7) { + + /* "asyncpg/protocol/codecs/base.pyx":184 + * elem_len = hton.unpack_int32(buf.read(4)) + * if elem_len == -1: + * elem = None # <<<<<<<<<<<<<< + * else: + * elem_codec = self.element_codecs[i] + */ + __Pyx_INCREF(Py_None); + __Pyx_XDECREF_SET(__pyx_v_elem, Py_None); + + /* "asyncpg/protocol/codecs/base.pyx":183 + * + * elem_len = hton.unpack_int32(buf.read(4)) + * if elem_len == -1: # <<<<<<<<<<<<<< + * elem = None + * else: + */ + goto __pyx_L6; + } + + /* "asyncpg/protocol/codecs/base.pyx":186 + * elem = None + * else: + * elem_codec = self.element_codecs[i] # <<<<<<<<<<<<<< + * elem = elem_codec.decode(settings, + * elem_buf.slice_from(buf, elem_len)) + */ + /*else*/ { + if (unlikely(__pyx_v_self->element_codecs == Py_None)) { + PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable"); + __PYX_ERR(2, 186, __pyx_L1_error) + } + __pyx_t_3 = __Pyx_GetItemInt_List(__pyx_v_self->element_codecs, __pyx_v_i, uint32_t, 0, __Pyx_PyInt_From_uint32_t, 1, 0, 1); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 186, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + if (!(likely(((__pyx_t_3) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_3, __pyx_ptype_7asyncpg_8protocol_8protocol_Codec))))) __PYX_ERR(2, 186, __pyx_L1_error) + __Pyx_XDECREF_SET(__pyx_v_elem_codec, ((struct __pyx_obj_7asyncpg_8protocol_8protocol_Codec *)__pyx_t_3)); + __pyx_t_3 = 0; + + /* "asyncpg/protocol/codecs/base.pyx":188 + * elem_codec = self.element_codecs[i] + * elem = elem_codec.decode(settings, + * elem_buf.slice_from(buf, elem_len)) # <<<<<<<<<<<<<< + * + * cpython.Py_INCREF(elem) + */ + __pyx_t_3 = ((PyObject *)__pyx_f_7asyncpg_8protocol_8protocol_14FastReadBuffer_slice_from(__pyx_v_elem_buf, __pyx_v_buf, __pyx_v_elem_len)); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 188, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + + /* "asyncpg/protocol/codecs/base.pyx":187 + * else: + * elem_codec = self.element_codecs[i] + * elem = elem_codec.decode(settings, # <<<<<<<<<<<<<< + * elem_buf.slice_from(buf, elem_len)) + * + */ + __pyx_t_1 = __pyx_f_7asyncpg_8protocol_8protocol_5Codec_decode(__pyx_v_elem_codec, __pyx_v_settings, ((struct __pyx_obj_7asyncpg_8protocol_8protocol_FastReadBuffer *)__pyx_t_3)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 187, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_XDECREF_SET(__pyx_v_elem, __pyx_t_1); + __pyx_t_1 = 0; + } + __pyx_L6:; + + /* "asyncpg/protocol/codecs/base.pyx":190 + * elem_buf.slice_from(buf, elem_len)) + * + * cpython.Py_INCREF(elem) # <<<<<<<<<<<<<< + * record.ApgRecord_SET_ITEM(result, i, elem) + * + */ + Py_INCREF(__pyx_v_elem); + + /* "asyncpg/protocol/codecs/base.pyx":191 + * + * cpython.Py_INCREF(elem) + * record.ApgRecord_SET_ITEM(result, i, elem) # <<<<<<<<<<<<<< + * + * return result + */ + ApgRecord_SET_ITEM(__pyx_v_result, __pyx_v_i, __pyx_v_elem); + } + + /* "asyncpg/protocol/codecs/base.pyx":193 + * record.ApgRecord_SET_ITEM(result, i, elem) + * + * return result # <<<<<<<<<<<<<< + * + * cdef decode_in_python(self, ConnectionSettings settings, + */ + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(__pyx_v_result); + __pyx_r = __pyx_v_result; + goto __pyx_L0; + + /* "asyncpg/protocol/codecs/base.pyx":153 + * (self.element_codec)) + * + * cdef decode_composite(self, ConnectionSettings settings, # <<<<<<<<<<<<<< + * FastReadBuffer buf): + * cdef: + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_8); + __Pyx_XDECREF(__pyx_t_9); + __Pyx_XDECREF(__pyx_t_10); + __Pyx_XDECREF(__pyx_t_11); + __Pyx_XDECREF(__pyx_t_12); + __Pyx_XDECREF(__pyx_t_13); + __Pyx_XDECREF(__pyx_t_15); + __Pyx_XDECREF(__pyx_t_16); + __Pyx_AddTraceback("asyncpg.protocol.protocol.Codec.decode_composite", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XDECREF(__pyx_v_result); + __Pyx_XDECREF((PyObject *)__pyx_v_elem_codec); + __Pyx_XDECREF((PyObject *)__pyx_v_elem_buf); + __Pyx_XDECREF(__pyx_v_elem); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "asyncpg/protocol/codecs/base.pyx":195 + * return result + * + * cdef decode_in_python(self, ConnectionSettings settings, # <<<<<<<<<<<<<< + * FastReadBuffer buf): + * if self.format == PG_FORMAT_BINARY: + */ + +static PyObject *__pyx_f_7asyncpg_8protocol_8protocol_5Codec_decode_in_python(struct __pyx_obj_7asyncpg_8protocol_8protocol_Codec *__pyx_v_self, struct __pyx_obj_7asyncpg_8protocol_8protocol_ConnectionSettings *__pyx_v_settings, struct __pyx_obj_7asyncpg_8protocol_8protocol_FastReadBuffer *__pyx_v_buf) { + PyObject *__pyx_v_bb = NULL; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + PyObject *__pyx_t_5 = NULL; + __Pyx_RefNannySetupContext("decode_in_python", 0); + + /* "asyncpg/protocol/codecs/base.pyx":197 + * cdef decode_in_python(self, ConnectionSettings settings, + * FastReadBuffer buf): + * if self.format == PG_FORMAT_BINARY: # <<<<<<<<<<<<<< + * bb = bytea_decode(settings, buf) + * else: + */ + __pyx_t_1 = ((__pyx_v_self->format == __pyx_e_7asyncpg_8protocol_8protocol_PG_FORMAT_BINARY) != 0); + if (__pyx_t_1) { + + /* "asyncpg/protocol/codecs/base.pyx":198 + * FastReadBuffer buf): + * if self.format == PG_FORMAT_BINARY: + * bb = bytea_decode(settings, buf) # <<<<<<<<<<<<<< + * else: + * bb = text_decode(settings, buf) + */ + __pyx_t_2 = __pyx_f_7asyncpg_8protocol_8protocol_bytea_decode(__pyx_v_settings, __pyx_v_buf); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 198, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_v_bb = __pyx_t_2; + __pyx_t_2 = 0; + + /* "asyncpg/protocol/codecs/base.pyx":197 + * cdef decode_in_python(self, ConnectionSettings settings, + * FastReadBuffer buf): + * if self.format == PG_FORMAT_BINARY: # <<<<<<<<<<<<<< + * bb = bytea_decode(settings, buf) + * else: + */ + goto __pyx_L3; + } + + /* "asyncpg/protocol/codecs/base.pyx":200 + * bb = bytea_decode(settings, buf) + * else: + * bb = text_decode(settings, buf) # <<<<<<<<<<<<<< + * + * return self.py_decoder(bb) + */ + /*else*/ { + __pyx_t_2 = __pyx_f_7asyncpg_8protocol_8protocol_text_decode(__pyx_v_settings, __pyx_v_buf); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 200, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_v_bb = __pyx_t_2; + __pyx_t_2 = 0; + } + __pyx_L3:; + + /* "asyncpg/protocol/codecs/base.pyx":202 + * bb = text_decode(settings, buf) + * + * return self.py_decoder(bb) # <<<<<<<<<<<<<< + * + * cdef inline decode(self, ConnectionSettings settings, FastReadBuffer buf): + */ + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(__pyx_v_self->py_decoder); + __pyx_t_3 = __pyx_v_self->py_decoder; __pyx_t_4 = NULL; + if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_3))) { + __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_3); + if (likely(__pyx_t_4)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); + __Pyx_INCREF(__pyx_t_4); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_3, function); + } + } + if (!__pyx_t_4) { + __pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_v_bb); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 202, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + } else { + #if CYTHON_FAST_PYCALL + if (PyFunction_Check(__pyx_t_3)) { + PyObject *__pyx_temp[2] = {__pyx_t_4, __pyx_v_bb}; + __pyx_t_2 = __Pyx_PyFunction_FastCall(__pyx_t_3, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 202, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_GOTREF(__pyx_t_2); + } else + #endif + #if CYTHON_FAST_PYCCALL + if (__Pyx_PyFastCFunction_Check(__pyx_t_3)) { + PyObject *__pyx_temp[2] = {__pyx_t_4, __pyx_v_bb}; + __pyx_t_2 = __Pyx_PyCFunction_FastCall(__pyx_t_3, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 202, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_GOTREF(__pyx_t_2); + } else + #endif + { + __pyx_t_5 = PyTuple_New(1+1); if (unlikely(!__pyx_t_5)) __PYX_ERR(2, 202, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_GIVEREF(__pyx_t_4); PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_t_4); __pyx_t_4 = NULL; + __Pyx_INCREF(__pyx_v_bb); + __Pyx_GIVEREF(__pyx_v_bb); + PyTuple_SET_ITEM(__pyx_t_5, 0+1, __pyx_v_bb); + __pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_t_5, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 202, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + } + } + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_r = __pyx_t_2; + __pyx_t_2 = 0; + goto __pyx_L0; + + /* "asyncpg/protocol/codecs/base.pyx":195 + * return result + * + * cdef decode_in_python(self, ConnectionSettings settings, # <<<<<<<<<<<<<< + * FastReadBuffer buf): + * if self.format == PG_FORMAT_BINARY: + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_AddTraceback("asyncpg.protocol.protocol.Codec.decode_in_python", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XDECREF(__pyx_v_bb); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "asyncpg/protocol/codecs/base.pyx":204 + * return self.py_decoder(bb) + * + * cdef inline decode(self, ConnectionSettings settings, FastReadBuffer buf): # <<<<<<<<<<<<<< + * return self.decoder(self, settings, buf) + * + */ + +static CYTHON_INLINE PyObject *__pyx_f_7asyncpg_8protocol_8protocol_5Codec_decode(struct __pyx_obj_7asyncpg_8protocol_8protocol_Codec *__pyx_v_self, struct __pyx_obj_7asyncpg_8protocol_8protocol_ConnectionSettings *__pyx_v_settings, struct __pyx_obj_7asyncpg_8protocol_8protocol_FastReadBuffer *__pyx_v_buf) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + __Pyx_RefNannySetupContext("decode", 0); + + /* "asyncpg/protocol/codecs/base.pyx":205 + * + * cdef inline decode(self, ConnectionSettings settings, FastReadBuffer buf): + * return self.decoder(self, settings, buf) # <<<<<<<<<<<<<< + * + * cdef inline has_encoder(self): + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __pyx_v_self->decoder(__pyx_v_self, __pyx_v_settings, __pyx_v_buf); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 205, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "asyncpg/protocol/codecs/base.pyx":204 + * return self.py_decoder(bb) + * + * cdef inline decode(self, ConnectionSettings settings, FastReadBuffer buf): # <<<<<<<<<<<<<< + * return self.decoder(self, settings, buf) + * + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("asyncpg.protocol.protocol.Codec.decode", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "asyncpg/protocol/codecs/base.pyx":207 + * return self.decoder(self, settings, buf) + * + * cdef inline has_encoder(self): # <<<<<<<<<<<<<< + * cdef Codec elem_codec + * + */ + +static PyObject *__pyx_f_7asyncpg_8protocol_8protocol_5Codec_has_encoder(struct __pyx_obj_7asyncpg_8protocol_8protocol_Codec *__pyx_v_self) { + struct __pyx_obj_7asyncpg_8protocol_8protocol_Codec *__pyx_v_elem_codec = 0; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + int __pyx_t_2; + int __pyx_t_3; + PyObject *__pyx_t_4 = NULL; + Py_ssize_t __pyx_t_5; + PyObject *__pyx_t_6 = NULL; + __Pyx_RefNannySetupContext("has_encoder", 0); + + /* "asyncpg/protocol/codecs/base.pyx":210 + * cdef Codec elem_codec + * + * if self.c_encoder is not NULL or self.py_encoder is not None: # <<<<<<<<<<<<<< + * return True + * + */ + __pyx_t_2 = ((__pyx_v_self->c_encoder != NULL) != 0); + if (!__pyx_t_2) { + } else { + __pyx_t_1 = __pyx_t_2; + goto __pyx_L4_bool_binop_done; + } + __pyx_t_2 = (__pyx_v_self->py_encoder != Py_None); + __pyx_t_3 = (__pyx_t_2 != 0); + __pyx_t_1 = __pyx_t_3; + __pyx_L4_bool_binop_done:; + if (__pyx_t_1) { + + /* "asyncpg/protocol/codecs/base.pyx":211 + * + * if self.c_encoder is not NULL or self.py_encoder is not None: + * return True # <<<<<<<<<<<<<< + * + * elif self.type == CODEC_ARRAY or self.type == CODEC_RANGE: + */ + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(Py_True); + __pyx_r = Py_True; + goto __pyx_L0; + + /* "asyncpg/protocol/codecs/base.pyx":210 + * cdef Codec elem_codec + * + * if self.c_encoder is not NULL or self.py_encoder is not None: # <<<<<<<<<<<<<< + * return True + * + */ + } + + /* "asyncpg/protocol/codecs/base.pyx":213 + * return True + * + * elif self.type == CODEC_ARRAY or self.type == CODEC_RANGE: # <<<<<<<<<<<<<< + * return self.element_codec.has_encoder() + * + */ + switch (__pyx_v_self->type) { + case __pyx_e_7asyncpg_8protocol_8protocol_CODEC_ARRAY: + case __pyx_e_7asyncpg_8protocol_8protocol_CODEC_RANGE: + __pyx_t_1 = 1; + break; + default: + __pyx_t_1 = 0; + break; + } + if (__pyx_t_1) { + + /* "asyncpg/protocol/codecs/base.pyx":214 + * + * elif self.type == CODEC_ARRAY or self.type == CODEC_RANGE: + * return self.element_codec.has_encoder() # <<<<<<<<<<<<<< + * + * elif self.type == CODEC_COMPOSITE: + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_4 = __pyx_f_7asyncpg_8protocol_8protocol_5Codec_has_encoder(__pyx_v_self->element_codec); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 214, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_r = __pyx_t_4; + __pyx_t_4 = 0; + goto __pyx_L0; + + /* "asyncpg/protocol/codecs/base.pyx":213 + * return True + * + * elif self.type == CODEC_ARRAY or self.type == CODEC_RANGE: # <<<<<<<<<<<<<< + * return self.element_codec.has_encoder() + * + */ + } + + /* "asyncpg/protocol/codecs/base.pyx":216 + * return self.element_codec.has_encoder() + * + * elif self.type == CODEC_COMPOSITE: # <<<<<<<<<<<<<< + * for elem_codec in self.element_codecs: + * if not elem_codec.has_encoder(): + */ + __pyx_t_1 = ((__pyx_v_self->type == __pyx_e_7asyncpg_8protocol_8protocol_CODEC_COMPOSITE) != 0); + if (__pyx_t_1) { + + /* "asyncpg/protocol/codecs/base.pyx":217 + * + * elif self.type == CODEC_COMPOSITE: + * for elem_codec in self.element_codecs: # <<<<<<<<<<<<<< + * if not elem_codec.has_encoder(): + * return False + */ + if (unlikely(__pyx_v_self->element_codecs == Py_None)) { + PyErr_SetString(PyExc_TypeError, "'NoneType' object is not iterable"); + __PYX_ERR(2, 217, __pyx_L1_error) + } + __pyx_t_4 = __pyx_v_self->element_codecs; __Pyx_INCREF(__pyx_t_4); __pyx_t_5 = 0; + for (;;) { + if (__pyx_t_5 >= PyList_GET_SIZE(__pyx_t_4)) break; + #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + __pyx_t_6 = PyList_GET_ITEM(__pyx_t_4, __pyx_t_5); __Pyx_INCREF(__pyx_t_6); __pyx_t_5++; if (unlikely(0 < 0)) __PYX_ERR(2, 217, __pyx_L1_error) + #else + __pyx_t_6 = PySequence_ITEM(__pyx_t_4, __pyx_t_5); __pyx_t_5++; if (unlikely(!__pyx_t_6)) __PYX_ERR(2, 217, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + #endif + if (!(likely(((__pyx_t_6) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_6, __pyx_ptype_7asyncpg_8protocol_8protocol_Codec))))) __PYX_ERR(2, 217, __pyx_L1_error) + __Pyx_XDECREF_SET(__pyx_v_elem_codec, ((struct __pyx_obj_7asyncpg_8protocol_8protocol_Codec *)__pyx_t_6)); + __pyx_t_6 = 0; + + /* "asyncpg/protocol/codecs/base.pyx":218 + * elif self.type == CODEC_COMPOSITE: + * for elem_codec in self.element_codecs: + * if not elem_codec.has_encoder(): # <<<<<<<<<<<<<< + * return False + * return True + */ + __pyx_t_6 = __pyx_f_7asyncpg_8protocol_8protocol_5Codec_has_encoder(__pyx_v_elem_codec); if (unlikely(!__pyx_t_6)) __PYX_ERR(2, 218, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_t_6); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(2, 218, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __pyx_t_3 = ((!__pyx_t_1) != 0); + if (__pyx_t_3) { + + /* "asyncpg/protocol/codecs/base.pyx":219 + * for elem_codec in self.element_codecs: + * if not elem_codec.has_encoder(): + * return False # <<<<<<<<<<<<<< + * return True + * + */ + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(Py_False); + __pyx_r = Py_False; + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + goto __pyx_L0; + + /* "asyncpg/protocol/codecs/base.pyx":218 + * elif self.type == CODEC_COMPOSITE: + * for elem_codec in self.element_codecs: + * if not elem_codec.has_encoder(): # <<<<<<<<<<<<<< + * return False + * return True + */ + } + + /* "asyncpg/protocol/codecs/base.pyx":217 + * + * elif self.type == CODEC_COMPOSITE: + * for elem_codec in self.element_codecs: # <<<<<<<<<<<<<< + * if not elem_codec.has_encoder(): + * return False + */ + } + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + + /* "asyncpg/protocol/codecs/base.pyx":220 + * if not elem_codec.has_encoder(): + * return False + * return True # <<<<<<<<<<<<<< + * + * else: + */ + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(Py_True); + __pyx_r = Py_True; + goto __pyx_L0; + + /* "asyncpg/protocol/codecs/base.pyx":216 + * return self.element_codec.has_encoder() + * + * elif self.type == CODEC_COMPOSITE: # <<<<<<<<<<<<<< + * for elem_codec in self.element_codecs: + * if not elem_codec.has_encoder(): + */ + } + + /* "asyncpg/protocol/codecs/base.pyx":223 + * + * else: + * return False # <<<<<<<<<<<<<< + * + * cdef has_decoder(self): + */ + /*else*/ { + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(Py_False); + __pyx_r = Py_False; + goto __pyx_L0; + } + + /* "asyncpg/protocol/codecs/base.pyx":207 + * return self.decoder(self, settings, buf) + * + * cdef inline has_encoder(self): # <<<<<<<<<<<<<< + * cdef Codec elem_codec + * + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_4); + __Pyx_XDECREF(__pyx_t_6); + __Pyx_AddTraceback("asyncpg.protocol.protocol.Codec.has_encoder", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XDECREF((PyObject *)__pyx_v_elem_codec); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "asyncpg/protocol/codecs/base.pyx":225 + * return False + * + * cdef has_decoder(self): # <<<<<<<<<<<<<< + * cdef Codec elem_codec + * + */ + +static PyObject *__pyx_f_7asyncpg_8protocol_8protocol_5Codec_has_decoder(struct __pyx_obj_7asyncpg_8protocol_8protocol_Codec *__pyx_v_self) { + struct __pyx_obj_7asyncpg_8protocol_8protocol_Codec *__pyx_v_elem_codec = 0; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + int __pyx_t_2; + int __pyx_t_3; + PyObject *__pyx_t_4 = NULL; + Py_ssize_t __pyx_t_5; + PyObject *__pyx_t_6 = NULL; + __Pyx_RefNannySetupContext("has_decoder", 0); + + /* "asyncpg/protocol/codecs/base.pyx":228 + * cdef Codec elem_codec + * + * if self.c_decoder is not NULL or self.py_decoder is not None: # <<<<<<<<<<<<<< + * return True + * + */ + __pyx_t_2 = ((__pyx_v_self->c_decoder != NULL) != 0); + if (!__pyx_t_2) { + } else { + __pyx_t_1 = __pyx_t_2; + goto __pyx_L4_bool_binop_done; + } + __pyx_t_2 = (__pyx_v_self->py_decoder != Py_None); + __pyx_t_3 = (__pyx_t_2 != 0); + __pyx_t_1 = __pyx_t_3; + __pyx_L4_bool_binop_done:; + if (__pyx_t_1) { + + /* "asyncpg/protocol/codecs/base.pyx":229 + * + * if self.c_decoder is not NULL or self.py_decoder is not None: + * return True # <<<<<<<<<<<<<< + * + * elif self.type == CODEC_ARRAY or self.type == CODEC_RANGE: + */ + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(Py_True); + __pyx_r = Py_True; + goto __pyx_L0; + + /* "asyncpg/protocol/codecs/base.pyx":228 + * cdef Codec elem_codec + * + * if self.c_decoder is not NULL or self.py_decoder is not None: # <<<<<<<<<<<<<< + * return True + * + */ + } + + /* "asyncpg/protocol/codecs/base.pyx":231 + * return True + * + * elif self.type == CODEC_ARRAY or self.type == CODEC_RANGE: # <<<<<<<<<<<<<< + * return self.element_codec.has_decoder() + * + */ + switch (__pyx_v_self->type) { + case __pyx_e_7asyncpg_8protocol_8protocol_CODEC_ARRAY: + case __pyx_e_7asyncpg_8protocol_8protocol_CODEC_RANGE: + __pyx_t_1 = 1; + break; + default: + __pyx_t_1 = 0; + break; + } + if (__pyx_t_1) { + + /* "asyncpg/protocol/codecs/base.pyx":232 + * + * elif self.type == CODEC_ARRAY or self.type == CODEC_RANGE: + * return self.element_codec.has_decoder() # <<<<<<<<<<<<<< + * + * elif self.type == CODEC_COMPOSITE: + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_4 = __pyx_f_7asyncpg_8protocol_8protocol_5Codec_has_decoder(__pyx_v_self->element_codec); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 232, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_r = __pyx_t_4; + __pyx_t_4 = 0; + goto __pyx_L0; + + /* "asyncpg/protocol/codecs/base.pyx":231 + * return True + * + * elif self.type == CODEC_ARRAY or self.type == CODEC_RANGE: # <<<<<<<<<<<<<< + * return self.element_codec.has_decoder() + * + */ + } + + /* "asyncpg/protocol/codecs/base.pyx":234 + * return self.element_codec.has_decoder() + * + * elif self.type == CODEC_COMPOSITE: # <<<<<<<<<<<<<< + * for elem_codec in self.element_codecs: + * if not elem_codec.has_decoder(): + */ + __pyx_t_1 = ((__pyx_v_self->type == __pyx_e_7asyncpg_8protocol_8protocol_CODEC_COMPOSITE) != 0); + if (__pyx_t_1) { + + /* "asyncpg/protocol/codecs/base.pyx":235 + * + * elif self.type == CODEC_COMPOSITE: + * for elem_codec in self.element_codecs: # <<<<<<<<<<<<<< + * if not elem_codec.has_decoder(): + * return False + */ + if (unlikely(__pyx_v_self->element_codecs == Py_None)) { + PyErr_SetString(PyExc_TypeError, "'NoneType' object is not iterable"); + __PYX_ERR(2, 235, __pyx_L1_error) + } + __pyx_t_4 = __pyx_v_self->element_codecs; __Pyx_INCREF(__pyx_t_4); __pyx_t_5 = 0; + for (;;) { + if (__pyx_t_5 >= PyList_GET_SIZE(__pyx_t_4)) break; + #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + __pyx_t_6 = PyList_GET_ITEM(__pyx_t_4, __pyx_t_5); __Pyx_INCREF(__pyx_t_6); __pyx_t_5++; if (unlikely(0 < 0)) __PYX_ERR(2, 235, __pyx_L1_error) + #else + __pyx_t_6 = PySequence_ITEM(__pyx_t_4, __pyx_t_5); __pyx_t_5++; if (unlikely(!__pyx_t_6)) __PYX_ERR(2, 235, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + #endif + if (!(likely(((__pyx_t_6) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_6, __pyx_ptype_7asyncpg_8protocol_8protocol_Codec))))) __PYX_ERR(2, 235, __pyx_L1_error) + __Pyx_XDECREF_SET(__pyx_v_elem_codec, ((struct __pyx_obj_7asyncpg_8protocol_8protocol_Codec *)__pyx_t_6)); + __pyx_t_6 = 0; + + /* "asyncpg/protocol/codecs/base.pyx":236 + * elif self.type == CODEC_COMPOSITE: + * for elem_codec in self.element_codecs: + * if not elem_codec.has_decoder(): # <<<<<<<<<<<<<< + * return False + * return True + */ + __pyx_t_6 = __pyx_f_7asyncpg_8protocol_8protocol_5Codec_has_decoder(__pyx_v_elem_codec); if (unlikely(!__pyx_t_6)) __PYX_ERR(2, 236, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_t_6); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(2, 236, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __pyx_t_3 = ((!__pyx_t_1) != 0); + if (__pyx_t_3) { + + /* "asyncpg/protocol/codecs/base.pyx":237 + * for elem_codec in self.element_codecs: + * if not elem_codec.has_decoder(): + * return False # <<<<<<<<<<<<<< + * return True + * + */ + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(Py_False); + __pyx_r = Py_False; + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + goto __pyx_L0; + + /* "asyncpg/protocol/codecs/base.pyx":236 + * elif self.type == CODEC_COMPOSITE: + * for elem_codec in self.element_codecs: + * if not elem_codec.has_decoder(): # <<<<<<<<<<<<<< + * return False + * return True + */ + } + + /* "asyncpg/protocol/codecs/base.pyx":235 + * + * elif self.type == CODEC_COMPOSITE: + * for elem_codec in self.element_codecs: # <<<<<<<<<<<<<< + * if not elem_codec.has_decoder(): + * return False + */ + } + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + + /* "asyncpg/protocol/codecs/base.pyx":238 + * if not elem_codec.has_decoder(): + * return False + * return True # <<<<<<<<<<<<<< + * + * else: + */ + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(Py_True); + __pyx_r = Py_True; + goto __pyx_L0; + + /* "asyncpg/protocol/codecs/base.pyx":234 + * return self.element_codec.has_decoder() + * + * elif self.type == CODEC_COMPOSITE: # <<<<<<<<<<<<<< + * for elem_codec in self.element_codecs: + * if not elem_codec.has_decoder(): + */ + } + + /* "asyncpg/protocol/codecs/base.pyx":241 + * + * else: + * return False # <<<<<<<<<<<<<< + * + * cdef is_binary(self): + */ + /*else*/ { + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(Py_False); + __pyx_r = Py_False; + goto __pyx_L0; + } + + /* "asyncpg/protocol/codecs/base.pyx":225 + * return False + * + * cdef has_decoder(self): # <<<<<<<<<<<<<< + * cdef Codec elem_codec + * + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_4); + __Pyx_XDECREF(__pyx_t_6); + __Pyx_AddTraceback("asyncpg.protocol.protocol.Codec.has_decoder", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XDECREF((PyObject *)__pyx_v_elem_codec); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "asyncpg/protocol/codecs/base.pyx":243 + * return False + * + * cdef is_binary(self): # <<<<<<<<<<<<<< + * return self.format == PG_FORMAT_BINARY + * + */ + +static PyObject *__pyx_f_7asyncpg_8protocol_8protocol_5Codec_is_binary(struct __pyx_obj_7asyncpg_8protocol_8protocol_Codec *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + __Pyx_RefNannySetupContext("is_binary", 0); + + /* "asyncpg/protocol/codecs/base.pyx":244 + * + * cdef is_binary(self): + * return self.format == PG_FORMAT_BINARY # <<<<<<<<<<<<<< + * + * def __repr__(self): + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyBool_FromLong((__pyx_v_self->format == __pyx_e_7asyncpg_8protocol_8protocol_PG_FORMAT_BINARY)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 244, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "asyncpg/protocol/codecs/base.pyx":243 + * return False + * + * cdef is_binary(self): # <<<<<<<<<<<<<< + * return self.format == PG_FORMAT_BINARY + * + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("asyncpg.protocol.protocol.Codec.is_binary", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "asyncpg/protocol/codecs/base.pyx":246 + * return self.format == PG_FORMAT_BINARY + * + * def __repr__(self): # <<<<<<<<<<<<<< + * return ''.format( + * self.oid, + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_7asyncpg_8protocol_8protocol_5Codec_3__repr__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_7asyncpg_8protocol_8protocol_5Codec_3__repr__(PyObject *__pyx_v_self) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__repr__ (wrapper)", 0); + __pyx_r = __pyx_pf_7asyncpg_8protocol_8protocol_5Codec_2__repr__(((struct __pyx_obj_7asyncpg_8protocol_8protocol_Codec *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_7asyncpg_8protocol_8protocol_5Codec_2__repr__(struct __pyx_obj_7asyncpg_8protocol_8protocol_Codec *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + int __pyx_t_5; + PyObject *__pyx_t_6 = NULL; + PyObject *__pyx_t_7 = NULL; + int __pyx_t_8; + PyObject *__pyx_t_9 = NULL; + __Pyx_RefNannySetupContext("__repr__", 0); + + /* "asyncpg/protocol/codecs/base.pyx":247 + * + * def __repr__(self): + * return ''.format( # <<<<<<<<<<<<<< + * self.oid, + * 'NA' if self.element_codec is None else self.element_codec.oid, + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_kp_u_Codec_oid_elem_oid_core, __pyx_n_s_format); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 247, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + + /* "asyncpg/protocol/codecs/base.pyx":248 + * def __repr__(self): + * return ''.format( + * self.oid, # <<<<<<<<<<<<<< + * 'NA' if self.element_codec is None else self.element_codec.oid, + * has_core_codec(self.oid)) + */ + __pyx_t_3 = __Pyx_PyInt_From_uint32_t(__pyx_v_self->oid); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 248, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + + /* "asyncpg/protocol/codecs/base.pyx":249 + * return ''.format( + * self.oid, + * 'NA' if self.element_codec is None else self.element_codec.oid, # <<<<<<<<<<<<<< + * has_core_codec(self.oid)) + * + */ + __pyx_t_5 = (((PyObject *)__pyx_v_self->element_codec) == Py_None); + if ((__pyx_t_5 != 0)) { + __Pyx_INCREF(__pyx_n_u_NA); + __pyx_t_4 = __pyx_n_u_NA; + } else { + __pyx_t_6 = __Pyx_PyInt_From_uint32_t(__pyx_v_self->element_codec->oid); if (unlikely(!__pyx_t_6)) __PYX_ERR(2, 249, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_4 = __pyx_t_6; + __pyx_t_6 = 0; + } + + /* "asyncpg/protocol/codecs/base.pyx":250 + * self.oid, + * 'NA' if self.element_codec is None else self.element_codec.oid, + * has_core_codec(self.oid)) # <<<<<<<<<<<<<< + * + * @staticmethod + */ + __pyx_t_6 = __Pyx_PyInt_From_int(__pyx_f_7asyncpg_8protocol_8protocol_has_core_codec(__pyx_v_self->oid)); if (unlikely(!__pyx_t_6)) __PYX_ERR(2, 250, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_7 = NULL; + __pyx_t_8 = 0; + if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_7 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_7)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_7); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + __pyx_t_8 = 1; + } + } + #if CYTHON_FAST_PYCALL + if (PyFunction_Check(__pyx_t_2)) { + PyObject *__pyx_temp[4] = {__pyx_t_7, __pyx_t_3, __pyx_t_4, __pyx_t_6}; + __pyx_t_1 = __Pyx_PyFunction_FastCall(__pyx_t_2, __pyx_temp+1-__pyx_t_8, 3+__pyx_t_8); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 247, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + } else + #endif + #if CYTHON_FAST_PYCCALL + if (__Pyx_PyFastCFunction_Check(__pyx_t_2)) { + PyObject *__pyx_temp[4] = {__pyx_t_7, __pyx_t_3, __pyx_t_4, __pyx_t_6}; + __pyx_t_1 = __Pyx_PyCFunction_FastCall(__pyx_t_2, __pyx_temp+1-__pyx_t_8, 3+__pyx_t_8); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 247, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + } else + #endif + { + __pyx_t_9 = PyTuple_New(3+__pyx_t_8); if (unlikely(!__pyx_t_9)) __PYX_ERR(2, 247, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_9); + if (__pyx_t_7) { + __Pyx_GIVEREF(__pyx_t_7); PyTuple_SET_ITEM(__pyx_t_9, 0, __pyx_t_7); __pyx_t_7 = NULL; + } + __Pyx_GIVEREF(__pyx_t_3); + PyTuple_SET_ITEM(__pyx_t_9, 0+__pyx_t_8, __pyx_t_3); + __Pyx_GIVEREF(__pyx_t_4); + PyTuple_SET_ITEM(__pyx_t_9, 1+__pyx_t_8, __pyx_t_4); + __Pyx_GIVEREF(__pyx_t_6); + PyTuple_SET_ITEM(__pyx_t_9, 2+__pyx_t_8, __pyx_t_6); + __pyx_t_3 = 0; + __pyx_t_4 = 0; + __pyx_t_6 = 0; + __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_t_9, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 247, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + } + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "asyncpg/protocol/codecs/base.pyx":246 + * return self.format == PG_FORMAT_BINARY + * + * def __repr__(self): # <<<<<<<<<<<<<< + * return ''.format( + * self.oid, + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_XDECREF(__pyx_t_6); + __Pyx_XDECREF(__pyx_t_7); + __Pyx_XDECREF(__pyx_t_9); + __Pyx_AddTraceback("asyncpg.protocol.protocol.Codec.__repr__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "asyncpg/protocol/codecs/base.pyx":253 + * + * @staticmethod + * cdef Codec new_array_codec(uint32_t oid, # <<<<<<<<<<<<<< + * str name, + * str schema, + */ + +static struct __pyx_obj_7asyncpg_8protocol_8protocol_Codec *__pyx_f_7asyncpg_8protocol_8protocol_5Codec_new_array_codec(uint32_t __pyx_v_oid, PyObject *__pyx_v_name, PyObject *__pyx_v_schema, struct __pyx_obj_7asyncpg_8protocol_8protocol_Codec *__pyx_v_element_codec, Py_UCS4 __pyx_v_element_delimiter) { + struct __pyx_obj_7asyncpg_8protocol_8protocol_Codec *__pyx_v_codec = 0; + struct __pyx_obj_7asyncpg_8protocol_8protocol_Codec *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + __Pyx_RefNannySetupContext("new_array_codec", 0); + + /* "asyncpg/protocol/codecs/base.pyx":259 + * Py_UCS4 element_delimiter): + * cdef Codec codec + * codec = Codec(oid) # <<<<<<<<<<<<<< + * codec.init(name, schema, 'array', CODEC_ARRAY, element_codec.format, + * NULL, NULL, None, None, element_codec, None, None, None, + */ + __pyx_t_1 = __Pyx_PyInt_From_uint32_t(__pyx_v_oid); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 259, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = PyTuple_New(1); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 259, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_GIVEREF(__pyx_t_1); + PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_t_1); + __pyx_t_1 = 0; + __pyx_t_1 = __Pyx_PyObject_Call(((PyObject *)__pyx_ptype_7asyncpg_8protocol_8protocol_Codec), __pyx_t_2, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 259, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_v_codec = ((struct __pyx_obj_7asyncpg_8protocol_8protocol_Codec *)__pyx_t_1); + __pyx_t_1 = 0; + + /* "asyncpg/protocol/codecs/base.pyx":260 + * cdef Codec codec + * codec = Codec(oid) + * codec.init(name, schema, 'array', CODEC_ARRAY, element_codec.format, # <<<<<<<<<<<<<< + * NULL, NULL, None, None, element_codec, None, None, None, + * element_delimiter) + */ + __pyx_t_1 = __pyx_f_7asyncpg_8protocol_8protocol_5Codec_init(__pyx_v_codec, __pyx_v_name, __pyx_v_schema, __pyx_n_u_array, __pyx_e_7asyncpg_8protocol_8protocol_CODEC_ARRAY, __pyx_v_element_codec->format, NULL, NULL, Py_None, Py_None, __pyx_v_element_codec, ((PyObject*)Py_None), Py_None, ((PyObject*)Py_None), __pyx_v_element_delimiter); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 260, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "asyncpg/protocol/codecs/base.pyx":263 + * NULL, NULL, None, None, element_codec, None, None, None, + * element_delimiter) + * return codec # <<<<<<<<<<<<<< + * + * @staticmethod + */ + __Pyx_XDECREF(((PyObject *)__pyx_r)); + __Pyx_INCREF(((PyObject *)__pyx_v_codec)); + __pyx_r = __pyx_v_codec; + goto __pyx_L0; + + /* "asyncpg/protocol/codecs/base.pyx":253 + * + * @staticmethod + * cdef Codec new_array_codec(uint32_t oid, # <<<<<<<<<<<<<< + * str name, + * str schema, + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_AddTraceback("asyncpg.protocol.protocol.Codec.new_array_codec", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XDECREF((PyObject *)__pyx_v_codec); + __Pyx_XGIVEREF((PyObject *)__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "asyncpg/protocol/codecs/base.pyx":266 + * + * @staticmethod + * cdef Codec new_range_codec(uint32_t oid, # <<<<<<<<<<<<<< + * str name, + * str schema, + */ + +static struct __pyx_obj_7asyncpg_8protocol_8protocol_Codec *__pyx_f_7asyncpg_8protocol_8protocol_5Codec_new_range_codec(uint32_t __pyx_v_oid, PyObject *__pyx_v_name, PyObject *__pyx_v_schema, struct __pyx_obj_7asyncpg_8protocol_8protocol_Codec *__pyx_v_element_codec) { + struct __pyx_obj_7asyncpg_8protocol_8protocol_Codec *__pyx_v_codec = 0; + struct __pyx_obj_7asyncpg_8protocol_8protocol_Codec *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + __Pyx_RefNannySetupContext("new_range_codec", 0); + + /* "asyncpg/protocol/codecs/base.pyx":271 + * Codec element_codec): + * cdef Codec codec + * codec = Codec(oid) # <<<<<<<<<<<<<< + * codec.init(name, schema, 'range', CODEC_RANGE, PG_FORMAT_BINARY, + * NULL, NULL, None, None, element_codec, None, None, None, + */ + __pyx_t_1 = __Pyx_PyInt_From_uint32_t(__pyx_v_oid); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 271, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = PyTuple_New(1); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 271, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_GIVEREF(__pyx_t_1); + PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_t_1); + __pyx_t_1 = 0; + __pyx_t_1 = __Pyx_PyObject_Call(((PyObject *)__pyx_ptype_7asyncpg_8protocol_8protocol_Codec), __pyx_t_2, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 271, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_v_codec = ((struct __pyx_obj_7asyncpg_8protocol_8protocol_Codec *)__pyx_t_1); + __pyx_t_1 = 0; + + /* "asyncpg/protocol/codecs/base.pyx":272 + * cdef Codec codec + * codec = Codec(oid) + * codec.init(name, schema, 'range', CODEC_RANGE, PG_FORMAT_BINARY, # <<<<<<<<<<<<<< + * NULL, NULL, None, None, element_codec, None, None, None, + * 0) + */ + __pyx_t_1 = __pyx_f_7asyncpg_8protocol_8protocol_5Codec_init(__pyx_v_codec, __pyx_v_name, __pyx_v_schema, __pyx_n_u_range, __pyx_e_7asyncpg_8protocol_8protocol_CODEC_RANGE, __pyx_e_7asyncpg_8protocol_8protocol_PG_FORMAT_BINARY, NULL, NULL, Py_None, Py_None, __pyx_v_element_codec, ((PyObject*)Py_None), Py_None, ((PyObject*)Py_None), 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 272, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "asyncpg/protocol/codecs/base.pyx":275 + * NULL, NULL, None, None, element_codec, None, None, None, + * 0) + * return codec # <<<<<<<<<<<<<< + * + * @staticmethod + */ + __Pyx_XDECREF(((PyObject *)__pyx_r)); + __Pyx_INCREF(((PyObject *)__pyx_v_codec)); + __pyx_r = __pyx_v_codec; + goto __pyx_L0; + + /* "asyncpg/protocol/codecs/base.pyx":266 + * + * @staticmethod + * cdef Codec new_range_codec(uint32_t oid, # <<<<<<<<<<<<<< + * str name, + * str schema, + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_AddTraceback("asyncpg.protocol.protocol.Codec.new_range_codec", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XDECREF((PyObject *)__pyx_v_codec); + __Pyx_XGIVEREF((PyObject *)__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "asyncpg/protocol/codecs/base.pyx":278 + * + * @staticmethod + * cdef Codec new_composite_codec(uint32_t oid, # <<<<<<<<<<<<<< + * str name, + * str schema, + */ + +static struct __pyx_obj_7asyncpg_8protocol_8protocol_Codec *__pyx_f_7asyncpg_8protocol_8protocol_5Codec_new_composite_codec(uint32_t __pyx_v_oid, PyObject *__pyx_v_name, PyObject *__pyx_v_schema, PyObject *__pyx_v_element_codecs, PyObject *__pyx_v_element_type_oids, PyObject *__pyx_v_element_names) { + struct __pyx_obj_7asyncpg_8protocol_8protocol_Codec *__pyx_v_codec = 0; + struct __pyx_obj_7asyncpg_8protocol_8protocol_Codec *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + __Pyx_RefNannySetupContext("new_composite_codec", 0); + + /* "asyncpg/protocol/codecs/base.pyx":285 + * object element_names): + * cdef Codec codec + * codec = Codec(oid) # <<<<<<<<<<<<<< + * codec.init(name, schema, 'composite', CODEC_COMPOSITE, + * PG_FORMAT_BINARY, NULL, NULL, None, None, None, + */ + __pyx_t_1 = __Pyx_PyInt_From_uint32_t(__pyx_v_oid); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 285, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = PyTuple_New(1); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 285, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_GIVEREF(__pyx_t_1); + PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_t_1); + __pyx_t_1 = 0; + __pyx_t_1 = __Pyx_PyObject_Call(((PyObject *)__pyx_ptype_7asyncpg_8protocol_8protocol_Codec), __pyx_t_2, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 285, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_v_codec = ((struct __pyx_obj_7asyncpg_8protocol_8protocol_Codec *)__pyx_t_1); + __pyx_t_1 = 0; + + /* "asyncpg/protocol/codecs/base.pyx":286 + * cdef Codec codec + * codec = Codec(oid) + * codec.init(name, schema, 'composite', CODEC_COMPOSITE, # <<<<<<<<<<<<<< + * PG_FORMAT_BINARY, NULL, NULL, None, None, None, + * element_type_oids, element_names, element_codecs, 0) + */ + __pyx_t_1 = __pyx_f_7asyncpg_8protocol_8protocol_5Codec_init(__pyx_v_codec, __pyx_v_name, __pyx_v_schema, __pyx_n_u_composite, __pyx_e_7asyncpg_8protocol_8protocol_CODEC_COMPOSITE, __pyx_e_7asyncpg_8protocol_8protocol_PG_FORMAT_BINARY, NULL, NULL, Py_None, Py_None, ((struct __pyx_obj_7asyncpg_8protocol_8protocol_Codec *)Py_None), __pyx_v_element_type_oids, __pyx_v_element_names, __pyx_v_element_codecs, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 286, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "asyncpg/protocol/codecs/base.pyx":289 + * PG_FORMAT_BINARY, NULL, NULL, None, None, None, + * element_type_oids, element_names, element_codecs, 0) + * return codec # <<<<<<<<<<<<<< + * + * @staticmethod + */ + __Pyx_XDECREF(((PyObject *)__pyx_r)); + __Pyx_INCREF(((PyObject *)__pyx_v_codec)); + __pyx_r = __pyx_v_codec; + goto __pyx_L0; + + /* "asyncpg/protocol/codecs/base.pyx":278 + * + * @staticmethod + * cdef Codec new_composite_codec(uint32_t oid, # <<<<<<<<<<<<<< + * str name, + * str schema, + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_AddTraceback("asyncpg.protocol.protocol.Codec.new_composite_codec", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XDECREF((PyObject *)__pyx_v_codec); + __Pyx_XGIVEREF((PyObject *)__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "asyncpg/protocol/codecs/base.pyx":292 + * + * @staticmethod + * cdef Codec new_python_codec(uint32_t oid, # <<<<<<<<<<<<<< + * str name, + * str schema, + */ + +static struct __pyx_obj_7asyncpg_8protocol_8protocol_Codec *__pyx_f_7asyncpg_8protocol_8protocol_5Codec_new_python_codec(uint32_t __pyx_v_oid, PyObject *__pyx_v_name, PyObject *__pyx_v_schema, PyObject *__pyx_v_kind, PyObject *__pyx_v_encoder, PyObject *__pyx_v_decoder, enum __pyx_t_7asyncpg_8protocol_8protocol_CodecFormat __pyx_v_format) { + struct __pyx_obj_7asyncpg_8protocol_8protocol_Codec *__pyx_v_codec = 0; + struct __pyx_obj_7asyncpg_8protocol_8protocol_Codec *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + __Pyx_RefNannySetupContext("new_python_codec", 0); + + /* "asyncpg/protocol/codecs/base.pyx":300 + * CodecFormat format): + * cdef Codec codec + * codec = Codec(oid) # <<<<<<<<<<<<<< + * codec.init(name, schema, kind, CODEC_PY, format, NULL, NULL, + * encoder, decoder, None, None, None, None, 0) + */ + __pyx_t_1 = __Pyx_PyInt_From_uint32_t(__pyx_v_oid); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 300, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = PyTuple_New(1); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 300, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_GIVEREF(__pyx_t_1); + PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_t_1); + __pyx_t_1 = 0; + __pyx_t_1 = __Pyx_PyObject_Call(((PyObject *)__pyx_ptype_7asyncpg_8protocol_8protocol_Codec), __pyx_t_2, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 300, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_v_codec = ((struct __pyx_obj_7asyncpg_8protocol_8protocol_Codec *)__pyx_t_1); + __pyx_t_1 = 0; + + /* "asyncpg/protocol/codecs/base.pyx":301 + * cdef Codec codec + * codec = Codec(oid) + * codec.init(name, schema, kind, CODEC_PY, format, NULL, NULL, # <<<<<<<<<<<<<< + * encoder, decoder, None, None, None, None, 0) + * return codec + */ + __pyx_t_1 = __pyx_f_7asyncpg_8protocol_8protocol_5Codec_init(__pyx_v_codec, __pyx_v_name, __pyx_v_schema, __pyx_v_kind, __pyx_e_7asyncpg_8protocol_8protocol_CODEC_PY, __pyx_v_format, NULL, NULL, __pyx_v_encoder, __pyx_v_decoder, ((struct __pyx_obj_7asyncpg_8protocol_8protocol_Codec *)Py_None), ((PyObject*)Py_None), Py_None, ((PyObject*)Py_None), 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 301, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "asyncpg/protocol/codecs/base.pyx":303 + * codec.init(name, schema, kind, CODEC_PY, format, NULL, NULL, + * encoder, decoder, None, None, None, None, 0) + * return codec # <<<<<<<<<<<<<< + * + * + */ + __Pyx_XDECREF(((PyObject *)__pyx_r)); + __Pyx_INCREF(((PyObject *)__pyx_v_codec)); + __pyx_r = __pyx_v_codec; + goto __pyx_L0; + + /* "asyncpg/protocol/codecs/base.pyx":292 + * + * @staticmethod + * cdef Codec new_python_codec(uint32_t oid, # <<<<<<<<<<<<<< + * str name, + * str schema, + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_AddTraceback("asyncpg.protocol.protocol.Codec.new_python_codec", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XDECREF((PyObject *)__pyx_v_codec); + __Pyx_XGIVEREF((PyObject *)__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "asyncpg/protocol/codecs/base.pyx":307 + * + * # Encode callback for arrays + * cdef codec_encode_func_ex(ConnectionSettings settings, WriteBuffer buf, # <<<<<<<<<<<<<< + * object obj, const void *arg): + * return (arg).encode(settings, buf, obj) + */ + +static PyObject *__pyx_f_7asyncpg_8protocol_8protocol_codec_encode_func_ex(struct __pyx_obj_7asyncpg_8protocol_8protocol_ConnectionSettings *__pyx_v_settings, struct __pyx_obj_7asyncpg_8protocol_8protocol_WriteBuffer *__pyx_v_buf, PyObject *__pyx_v_obj, void const *__pyx_v_arg) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + __Pyx_RefNannySetupContext("codec_encode_func_ex", 0); + + /* "asyncpg/protocol/codecs/base.pyx":309 + * cdef codec_encode_func_ex(ConnectionSettings settings, WriteBuffer buf, + * object obj, const void *arg): + * return (arg).encode(settings, buf, obj) # <<<<<<<<<<<<<< + * + * + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __pyx_f_7asyncpg_8protocol_8protocol_5Codec_encode(((struct __pyx_obj_7asyncpg_8protocol_8protocol_Codec *)__pyx_v_arg), __pyx_v_settings, __pyx_v_buf, __pyx_v_obj); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 309, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "asyncpg/protocol/codecs/base.pyx":307 + * + * # Encode callback for arrays + * cdef codec_encode_func_ex(ConnectionSettings settings, WriteBuffer buf, # <<<<<<<<<<<<<< + * object obj, const void *arg): + * return (arg).encode(settings, buf, obj) + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("asyncpg.protocol.protocol.codec_encode_func_ex", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "asyncpg/protocol/codecs/base.pyx":313 + * + * # Decode callback for arrays + * cdef codec_decode_func_ex(ConnectionSettings settings, FastReadBuffer buf, # <<<<<<<<<<<<<< + * const void *arg): + * return (arg).decode(settings, buf) + */ + +static PyObject *__pyx_f_7asyncpg_8protocol_8protocol_codec_decode_func_ex(struct __pyx_obj_7asyncpg_8protocol_8protocol_ConnectionSettings *__pyx_v_settings, struct __pyx_obj_7asyncpg_8protocol_8protocol_FastReadBuffer *__pyx_v_buf, void const *__pyx_v_arg) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + __Pyx_RefNannySetupContext("codec_decode_func_ex", 0); + + /* "asyncpg/protocol/codecs/base.pyx":315 + * cdef codec_decode_func_ex(ConnectionSettings settings, FastReadBuffer buf, + * const void *arg): + * return (arg).decode(settings, buf) # <<<<<<<<<<<<<< + * + * + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __pyx_f_7asyncpg_8protocol_8protocol_5Codec_decode(((struct __pyx_obj_7asyncpg_8protocol_8protocol_Codec *)__pyx_v_arg), __pyx_v_settings, __pyx_v_buf); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 315, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "asyncpg/protocol/codecs/base.pyx":313 + * + * # Decode callback for arrays + * cdef codec_decode_func_ex(ConnectionSettings settings, FastReadBuffer buf, # <<<<<<<<<<<<<< + * const void *arg): + * return (arg).decode(settings, buf) + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("asyncpg.protocol.protocol.codec_decode_func_ex", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "asyncpg/protocol/codecs/base.pyx":319 + * + * cdef class DataCodecConfig: + * def __init__(self, cache_key): # <<<<<<<<<<<<<< + * try: + * self._type_codecs_cache = TYPE_CODECS_CACHE[cache_key] + */ + +/* Python wrapper */ +static int __pyx_pw_7asyncpg_8protocol_8protocol_15DataCodecConfig_1__init__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ +static int __pyx_pw_7asyncpg_8protocol_8protocol_15DataCodecConfig_1__init__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { + PyObject *__pyx_v_cache_key = 0; + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__init__ (wrapper)", 0); + { + static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_cache_key,0}; + PyObject* values[1] = {0}; + if (unlikely(__pyx_kwds)) { + Py_ssize_t kw_args; + const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args); + switch (pos_args) { + case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = PyDict_Size(__pyx_kwds); + switch (pos_args) { + case 0: + if (likely((values[0] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_cache_key)) != 0)) kw_args--; + else goto __pyx_L5_argtuple_error; + } + if (unlikely(kw_args > 0)) { + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "__init__") < 0)) __PYX_ERR(2, 319, __pyx_L3_error) + } + } else if (PyTuple_GET_SIZE(__pyx_args) != 1) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + } + __pyx_v_cache_key = values[0]; + } + goto __pyx_L4_argument_unpacking_done; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("__init__", 1, 1, 1, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(2, 319, __pyx_L3_error) + __pyx_L3_error:; + __Pyx_AddTraceback("asyncpg.protocol.protocol.DataCodecConfig.__init__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return -1; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_7asyncpg_8protocol_8protocol_15DataCodecConfig___init__(((struct __pyx_obj_7asyncpg_8protocol_8protocol_DataCodecConfig *)__pyx_v_self), __pyx_v_cache_key); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_7asyncpg_8protocol_8protocol_15DataCodecConfig___init__(struct __pyx_obj_7asyncpg_8protocol_8protocol_DataCodecConfig *__pyx_v_self, PyObject *__pyx_v_cache_key) { + int __pyx_r; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + int __pyx_t_5; + PyObject *__pyx_t_6 = NULL; + PyObject *__pyx_t_7 = NULL; + PyObject *__pyx_t_8 = NULL; + __Pyx_RefNannySetupContext("__init__", 0); + + /* "asyncpg/protocol/codecs/base.pyx":320 + * cdef class DataCodecConfig: + * def __init__(self, cache_key): + * try: # <<<<<<<<<<<<<< + * self._type_codecs_cache = TYPE_CODECS_CACHE[cache_key] + * except KeyError: + */ + { + __Pyx_PyThreadState_declare + __Pyx_PyThreadState_assign + __Pyx_ExceptionSave(&__pyx_t_1, &__pyx_t_2, &__pyx_t_3); + __Pyx_XGOTREF(__pyx_t_1); + __Pyx_XGOTREF(__pyx_t_2); + __Pyx_XGOTREF(__pyx_t_3); + /*try:*/ { + + /* "asyncpg/protocol/codecs/base.pyx":321 + * def __init__(self, cache_key): + * try: + * self._type_codecs_cache = TYPE_CODECS_CACHE[cache_key] # <<<<<<<<<<<<<< + * except KeyError: + * self._type_codecs_cache = TYPE_CODECS_CACHE[cache_key] = {} + */ + if (unlikely(__pyx_v_7asyncpg_8protocol_8protocol_TYPE_CODECS_CACHE == Py_None)) { + PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable"); + __PYX_ERR(2, 321, __pyx_L3_error) + } + __pyx_t_4 = __Pyx_PyDict_GetItem(__pyx_v_7asyncpg_8protocol_8protocol_TYPE_CODECS_CACHE, __pyx_v_cache_key); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 321, __pyx_L3_error) + __Pyx_GOTREF(__pyx_t_4); + if (!(likely(PyDict_CheckExact(__pyx_t_4))||((__pyx_t_4) == Py_None)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "dict", Py_TYPE(__pyx_t_4)->tp_name), 0))) __PYX_ERR(2, 321, __pyx_L3_error) + __Pyx_GIVEREF(__pyx_t_4); + __Pyx_GOTREF(__pyx_v_self->_type_codecs_cache); + __Pyx_DECREF(__pyx_v_self->_type_codecs_cache); + __pyx_v_self->_type_codecs_cache = ((PyObject*)__pyx_t_4); + __pyx_t_4 = 0; + + /* "asyncpg/protocol/codecs/base.pyx":320 + * cdef class DataCodecConfig: + * def __init__(self, cache_key): + * try: # <<<<<<<<<<<<<< + * self._type_codecs_cache = TYPE_CODECS_CACHE[cache_key] + * except KeyError: + */ + } + __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + goto __pyx_L10_try_end; + __pyx_L3_error:; + __Pyx_PyThreadState_assign + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + + /* "asyncpg/protocol/codecs/base.pyx":322 + * try: + * self._type_codecs_cache = TYPE_CODECS_CACHE[cache_key] + * except KeyError: # <<<<<<<<<<<<<< + * self._type_codecs_cache = TYPE_CODECS_CACHE[cache_key] = {} + * + */ + __pyx_t_5 = __Pyx_PyErr_ExceptionMatches(__pyx_builtin_KeyError); + if (__pyx_t_5) { + __Pyx_AddTraceback("asyncpg.protocol.protocol.DataCodecConfig.__init__", __pyx_clineno, __pyx_lineno, __pyx_filename); + if (__Pyx_GetException(&__pyx_t_4, &__pyx_t_6, &__pyx_t_7) < 0) __PYX_ERR(2, 322, __pyx_L5_except_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_GOTREF(__pyx_t_6); + __Pyx_GOTREF(__pyx_t_7); + + /* "asyncpg/protocol/codecs/base.pyx":323 + * self._type_codecs_cache = TYPE_CODECS_CACHE[cache_key] + * except KeyError: + * self._type_codecs_cache = TYPE_CODECS_CACHE[cache_key] = {} # <<<<<<<<<<<<<< + * + * self._local_type_codecs = {} + */ + __pyx_t_8 = PyDict_New(); if (unlikely(!__pyx_t_8)) __PYX_ERR(2, 323, __pyx_L5_except_error) + __Pyx_GOTREF(__pyx_t_8); + __Pyx_INCREF(__pyx_t_8); + __Pyx_GIVEREF(__pyx_t_8); + __Pyx_GOTREF(__pyx_v_self->_type_codecs_cache); + __Pyx_DECREF(__pyx_v_self->_type_codecs_cache); + __pyx_v_self->_type_codecs_cache = __pyx_t_8; + if (unlikely(__pyx_v_7asyncpg_8protocol_8protocol_TYPE_CODECS_CACHE == Py_None)) { + PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable"); + __PYX_ERR(2, 323, __pyx_L5_except_error) + } + if (unlikely(PyDict_SetItem(__pyx_v_7asyncpg_8protocol_8protocol_TYPE_CODECS_CACHE, __pyx_v_cache_key, __pyx_t_8) < 0)) __PYX_ERR(2, 323, __pyx_L5_except_error) + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + goto __pyx_L4_exception_handled; + } + goto __pyx_L5_except_error; + __pyx_L5_except_error:; + + /* "asyncpg/protocol/codecs/base.pyx":320 + * cdef class DataCodecConfig: + * def __init__(self, cache_key): + * try: # <<<<<<<<<<<<<< + * self._type_codecs_cache = TYPE_CODECS_CACHE[cache_key] + * except KeyError: + */ + __Pyx_PyThreadState_assign + __Pyx_XGIVEREF(__pyx_t_1); + __Pyx_XGIVEREF(__pyx_t_2); + __Pyx_XGIVEREF(__pyx_t_3); + __Pyx_ExceptionReset(__pyx_t_1, __pyx_t_2, __pyx_t_3); + goto __pyx_L1_error; + __pyx_L4_exception_handled:; + __Pyx_PyThreadState_assign + __Pyx_XGIVEREF(__pyx_t_1); + __Pyx_XGIVEREF(__pyx_t_2); + __Pyx_XGIVEREF(__pyx_t_3); + __Pyx_ExceptionReset(__pyx_t_1, __pyx_t_2, __pyx_t_3); + __pyx_L10_try_end:; + } + + /* "asyncpg/protocol/codecs/base.pyx":325 + * self._type_codecs_cache = TYPE_CODECS_CACHE[cache_key] = {} + * + * self._local_type_codecs = {} # <<<<<<<<<<<<<< + * + * def add_types(self, types): + */ + __pyx_t_7 = PyDict_New(); if (unlikely(!__pyx_t_7)) __PYX_ERR(2, 325, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __Pyx_GIVEREF(__pyx_t_7); + __Pyx_GOTREF(__pyx_v_self->_local_type_codecs); + __Pyx_DECREF(__pyx_v_self->_local_type_codecs); + __pyx_v_self->_local_type_codecs = ((PyObject*)__pyx_t_7); + __pyx_t_7 = 0; + + /* "asyncpg/protocol/codecs/base.pyx":319 + * + * cdef class DataCodecConfig: + * def __init__(self, cache_key): # <<<<<<<<<<<<<< + * try: + * self._type_codecs_cache = TYPE_CODECS_CACHE[cache_key] + */ + + /* function exit code */ + __pyx_r = 0; + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_4); + __Pyx_XDECREF(__pyx_t_6); + __Pyx_XDECREF(__pyx_t_7); + __Pyx_XDECREF(__pyx_t_8); + __Pyx_AddTraceback("asyncpg.protocol.protocol.DataCodecConfig.__init__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = -1; + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "asyncpg/protocol/codecs/base.pyx":327 + * self._local_type_codecs = {} + * + * def add_types(self, types): # <<<<<<<<<<<<<< + * cdef: + * Codec elem_codec + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_7asyncpg_8protocol_8protocol_15DataCodecConfig_3add_types(PyObject *__pyx_v_self, PyObject *__pyx_v_types); /*proto*/ +static PyObject *__pyx_pw_7asyncpg_8protocol_8protocol_15DataCodecConfig_3add_types(PyObject *__pyx_v_self, PyObject *__pyx_v_types) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("add_types (wrapper)", 0); + __pyx_r = __pyx_pf_7asyncpg_8protocol_8protocol_15DataCodecConfig_2add_types(((struct __pyx_obj_7asyncpg_8protocol_8protocol_DataCodecConfig *)__pyx_v_self), ((PyObject *)__pyx_v_types)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_7asyncpg_8protocol_8protocol_15DataCodecConfig_2add_types(struct __pyx_obj_7asyncpg_8protocol_8protocol_DataCodecConfig *__pyx_v_self, PyObject *__pyx_v_types) { + struct __pyx_obj_7asyncpg_8protocol_8protocol_Codec *__pyx_v_elem_codec = 0; + PyObject *__pyx_v_comp_elem_codecs = 0; + enum __pyx_t_7asyncpg_8protocol_8protocol_CodecFormat __pyx_v_format; + enum __pyx_t_7asyncpg_8protocol_8protocol_CodecFormat __pyx_v_elem_format; + int __pyx_v_has_text_elements; + Py_UCS4 __pyx_v_elem_delim; + PyObject *__pyx_v_ti = NULL; + PyObject *__pyx_v_oid = NULL; + PyObject *__pyx_v_name = NULL; + PyObject *__pyx_v_schema = NULL; + PyObject *__pyx_v_array_element_oid = NULL; + PyObject *__pyx_v_range_subtype_oid = NULL; + PyObject *__pyx_v_comp_type_attrs = NULL; + PyObject *__pyx_v_base_type = NULL; + PyObject *__pyx_v_typoid = NULL; + PyObject *__pyx_v_element_names = NULL; + PyObject *__pyx_v_i = NULL; + PyObject *__pyx_v_attrname = NULL; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + Py_ssize_t __pyx_t_2; + PyObject *(*__pyx_t_3)(PyObject *); + PyObject *__pyx_t_4 = NULL; + int __pyx_t_5; + int __pyx_t_6; + uint32_t __pyx_t_7; + PyObject *__pyx_t_8 = NULL; + PyObject *__pyx_t_9 = NULL; + PyObject *__pyx_t_10 = NULL; + Py_UCS4 __pyx_t_11; + Py_ssize_t __pyx_t_12; + PyObject *(*__pyx_t_13)(PyObject *); + PyObject *__pyx_t_14 = NULL; + int __pyx_t_15; + int __pyx_t_16; + __Pyx_RefNannySetupContext("add_types", 0); + + /* "asyncpg/protocol/codecs/base.pyx":336 + * Py_UCS4 elem_delim + * + * for ti in types: # <<<<<<<<<<<<<< + * oid = ti['oid'] + * + */ + if (likely(PyList_CheckExact(__pyx_v_types)) || PyTuple_CheckExact(__pyx_v_types)) { + __pyx_t_1 = __pyx_v_types; __Pyx_INCREF(__pyx_t_1); __pyx_t_2 = 0; + __pyx_t_3 = NULL; + } else { + __pyx_t_2 = -1; __pyx_t_1 = PyObject_GetIter(__pyx_v_types); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 336, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_3 = Py_TYPE(__pyx_t_1)->tp_iternext; if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 336, __pyx_L1_error) + } + for (;;) { + if (likely(!__pyx_t_3)) { + if (likely(PyList_CheckExact(__pyx_t_1))) { + if (__pyx_t_2 >= PyList_GET_SIZE(__pyx_t_1)) break; + #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + __pyx_t_4 = PyList_GET_ITEM(__pyx_t_1, __pyx_t_2); __Pyx_INCREF(__pyx_t_4); __pyx_t_2++; if (unlikely(0 < 0)) __PYX_ERR(2, 336, __pyx_L1_error) + #else + __pyx_t_4 = PySequence_ITEM(__pyx_t_1, __pyx_t_2); __pyx_t_2++; if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 336, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + #endif + } else { + if (__pyx_t_2 >= PyTuple_GET_SIZE(__pyx_t_1)) break; + #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + __pyx_t_4 = PyTuple_GET_ITEM(__pyx_t_1, __pyx_t_2); __Pyx_INCREF(__pyx_t_4); __pyx_t_2++; if (unlikely(0 < 0)) __PYX_ERR(2, 336, __pyx_L1_error) + #else + __pyx_t_4 = PySequence_ITEM(__pyx_t_1, __pyx_t_2); __pyx_t_2++; if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 336, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + #endif + } + } else { + __pyx_t_4 = __pyx_t_3(__pyx_t_1); + if (unlikely(!__pyx_t_4)) { + PyObject* exc_type = PyErr_Occurred(); + if (exc_type) { + if (likely(exc_type == PyExc_StopIteration || PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) PyErr_Clear(); + else __PYX_ERR(2, 336, __pyx_L1_error) + } + break; + } + __Pyx_GOTREF(__pyx_t_4); + } + __Pyx_XDECREF_SET(__pyx_v_ti, __pyx_t_4); + __pyx_t_4 = 0; + + /* "asyncpg/protocol/codecs/base.pyx":337 + * + * for ti in types: + * oid = ti['oid'] # <<<<<<<<<<<<<< + * + * if not ti['has_bin_io']: + */ + __pyx_t_4 = PyObject_GetItem(__pyx_v_ti, __pyx_n_u_oid); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 337, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_XDECREF_SET(__pyx_v_oid, __pyx_t_4); + __pyx_t_4 = 0; + + /* "asyncpg/protocol/codecs/base.pyx":339 + * oid = ti['oid'] + * + * if not ti['has_bin_io']: # <<<<<<<<<<<<<< + * format = PG_FORMAT_TEXT + * else: + */ + __pyx_t_4 = PyObject_GetItem(__pyx_v_ti, __pyx_n_u_has_bin_io); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 339, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_5 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_5 < 0)) __PYX_ERR(2, 339, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_6 = ((!__pyx_t_5) != 0); + if (__pyx_t_6) { + + /* "asyncpg/protocol/codecs/base.pyx":340 + * + * if not ti['has_bin_io']: + * format = PG_FORMAT_TEXT # <<<<<<<<<<<<<< + * else: + * format = PG_FORMAT_BINARY + */ + __pyx_v_format = __pyx_e_7asyncpg_8protocol_8protocol_PG_FORMAT_TEXT; + + /* "asyncpg/protocol/codecs/base.pyx":339 + * oid = ti['oid'] + * + * if not ti['has_bin_io']: # <<<<<<<<<<<<<< + * format = PG_FORMAT_TEXT + * else: + */ + goto __pyx_L5; + } + + /* "asyncpg/protocol/codecs/base.pyx":342 + * format = PG_FORMAT_TEXT + * else: + * format = PG_FORMAT_BINARY # <<<<<<<<<<<<<< + * + * has_text_elements = False + */ + /*else*/ { + __pyx_v_format = __pyx_e_7asyncpg_8protocol_8protocol_PG_FORMAT_BINARY; + } + __pyx_L5:; + + /* "asyncpg/protocol/codecs/base.pyx":344 + * format = PG_FORMAT_BINARY + * + * has_text_elements = False # <<<<<<<<<<<<<< + * + * if self.get_codec(oid, format) is not None: + */ + __pyx_v_has_text_elements = 0; + + /* "asyncpg/protocol/codecs/base.pyx":346 + * has_text_elements = False + * + * if self.get_codec(oid, format) is not None: # <<<<<<<<<<<<<< + * continue + * + */ + __pyx_t_7 = __Pyx_PyInt_As_uint32_t(__pyx_v_oid); if (unlikely((__pyx_t_7 == ((uint32_t)-1)) && PyErr_Occurred())) __PYX_ERR(2, 346, __pyx_L1_error) + __pyx_t_4 = ((PyObject *)__pyx_f_7asyncpg_8protocol_8protocol_15DataCodecConfig_get_codec(__pyx_v_self, __pyx_t_7, __pyx_v_format)); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 346, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_6 = (__pyx_t_4 != Py_None); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_5 = (__pyx_t_6 != 0); + if (__pyx_t_5) { + + /* "asyncpg/protocol/codecs/base.pyx":347 + * + * if self.get_codec(oid, format) is not None: + * continue # <<<<<<<<<<<<<< + * + * name = ti['name'] + */ + goto __pyx_L3_continue; + + /* "asyncpg/protocol/codecs/base.pyx":346 + * has_text_elements = False + * + * if self.get_codec(oid, format) is not None: # <<<<<<<<<<<<<< + * continue + * + */ + } + + /* "asyncpg/protocol/codecs/base.pyx":349 + * continue + * + * name = ti['name'] # <<<<<<<<<<<<<< + * schema = ti['ns'] + * array_element_oid = ti['elemtype'] + */ + __pyx_t_4 = PyObject_GetItem(__pyx_v_ti, __pyx_n_u_name); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 349, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_XDECREF_SET(__pyx_v_name, __pyx_t_4); + __pyx_t_4 = 0; + + /* "asyncpg/protocol/codecs/base.pyx":350 + * + * name = ti['name'] + * schema = ti['ns'] # <<<<<<<<<<<<<< + * array_element_oid = ti['elemtype'] + * range_subtype_oid = ti['range_subtype'] + */ + __pyx_t_4 = PyObject_GetItem(__pyx_v_ti, __pyx_n_u_ns); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 350, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_XDECREF_SET(__pyx_v_schema, __pyx_t_4); + __pyx_t_4 = 0; + + /* "asyncpg/protocol/codecs/base.pyx":351 + * name = ti['name'] + * schema = ti['ns'] + * array_element_oid = ti['elemtype'] # <<<<<<<<<<<<<< + * range_subtype_oid = ti['range_subtype'] + * if ti['attrtypoids']: + */ + __pyx_t_4 = PyObject_GetItem(__pyx_v_ti, __pyx_n_u_elemtype); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 351, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_XDECREF_SET(__pyx_v_array_element_oid, __pyx_t_4); + __pyx_t_4 = 0; + + /* "asyncpg/protocol/codecs/base.pyx":352 + * schema = ti['ns'] + * array_element_oid = ti['elemtype'] + * range_subtype_oid = ti['range_subtype'] # <<<<<<<<<<<<<< + * if ti['attrtypoids']: + * comp_type_attrs = tuple(ti['attrtypoids']) + */ + __pyx_t_4 = PyObject_GetItem(__pyx_v_ti, __pyx_n_u_range_subtype); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 352, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_XDECREF_SET(__pyx_v_range_subtype_oid, __pyx_t_4); + __pyx_t_4 = 0; + + /* "asyncpg/protocol/codecs/base.pyx":353 + * array_element_oid = ti['elemtype'] + * range_subtype_oid = ti['range_subtype'] + * if ti['attrtypoids']: # <<<<<<<<<<<<<< + * comp_type_attrs = tuple(ti['attrtypoids']) + * else: + */ + __pyx_t_4 = PyObject_GetItem(__pyx_v_ti, __pyx_n_u_attrtypoids); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 353, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_5 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_5 < 0)) __PYX_ERR(2, 353, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + if (__pyx_t_5) { + + /* "asyncpg/protocol/codecs/base.pyx":354 + * range_subtype_oid = ti['range_subtype'] + * if ti['attrtypoids']: + * comp_type_attrs = tuple(ti['attrtypoids']) # <<<<<<<<<<<<<< + * else: + * comp_type_attrs = None + */ + __pyx_t_4 = PyObject_GetItem(__pyx_v_ti, __pyx_n_u_attrtypoids); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 354, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_8 = PySequence_Tuple(__pyx_t_4); if (unlikely(!__pyx_t_8)) __PYX_ERR(2, 354, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_XDECREF_SET(__pyx_v_comp_type_attrs, __pyx_t_8); + __pyx_t_8 = 0; + + /* "asyncpg/protocol/codecs/base.pyx":353 + * array_element_oid = ti['elemtype'] + * range_subtype_oid = ti['range_subtype'] + * if ti['attrtypoids']: # <<<<<<<<<<<<<< + * comp_type_attrs = tuple(ti['attrtypoids']) + * else: + */ + goto __pyx_L7; + } + + /* "asyncpg/protocol/codecs/base.pyx":356 + * comp_type_attrs = tuple(ti['attrtypoids']) + * else: + * comp_type_attrs = None # <<<<<<<<<<<<<< + * base_type = ti['basetype'] + * + */ + /*else*/ { + __Pyx_INCREF(Py_None); + __Pyx_XDECREF_SET(__pyx_v_comp_type_attrs, Py_None); + } + __pyx_L7:; + + /* "asyncpg/protocol/codecs/base.pyx":357 + * else: + * comp_type_attrs = None + * base_type = ti['basetype'] # <<<<<<<<<<<<<< + * + * if array_element_oid: + */ + __pyx_t_8 = PyObject_GetItem(__pyx_v_ti, __pyx_n_u_basetype); if (unlikely(!__pyx_t_8)) __PYX_ERR(2, 357, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __Pyx_XDECREF_SET(__pyx_v_base_type, __pyx_t_8); + __pyx_t_8 = 0; + + /* "asyncpg/protocol/codecs/base.pyx":359 + * base_type = ti['basetype'] + * + * if array_element_oid: # <<<<<<<<<<<<<< + * # Array type (note, there is no separate 'kind' for arrays) + * + */ + __pyx_t_5 = __Pyx_PyObject_IsTrue(__pyx_v_array_element_oid); if (unlikely(__pyx_t_5 < 0)) __PYX_ERR(2, 359, __pyx_L1_error) + if (__pyx_t_5) { + + /* "asyncpg/protocol/codecs/base.pyx":363 + * + * # Canonicalize type name to "elemtype[]" + * if name.startswith('_'): # <<<<<<<<<<<<<< + * name = name[1:] + * name = '{}[]'.format(name) + */ + __pyx_t_8 = __Pyx_PyObject_GetAttrStr(__pyx_v_name, __pyx_n_s_startswith); if (unlikely(!__pyx_t_8)) __PYX_ERR(2, 363, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_8, __pyx_tuple__26, NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 363, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + __pyx_t_5 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_5 < 0)) __PYX_ERR(2, 363, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + if (__pyx_t_5) { + + /* "asyncpg/protocol/codecs/base.pyx":364 + * # Canonicalize type name to "elemtype[]" + * if name.startswith('_'): + * name = name[1:] # <<<<<<<<<<<<<< + * name = '{}[]'.format(name) + * + */ + __pyx_t_4 = __Pyx_PyObject_GetSlice(__pyx_v_name, 1, 0, NULL, NULL, &__pyx_slice__27, 1, 0, 1); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 364, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF_SET(__pyx_v_name, __pyx_t_4); + __pyx_t_4 = 0; + + /* "asyncpg/protocol/codecs/base.pyx":363 + * + * # Canonicalize type name to "elemtype[]" + * if name.startswith('_'): # <<<<<<<<<<<<<< + * name = name[1:] + * name = '{}[]'.format(name) + */ + } + + /* "asyncpg/protocol/codecs/base.pyx":365 + * if name.startswith('_'): + * name = name[1:] + * name = '{}[]'.format(name) # <<<<<<<<<<<<<< + * + * if ti['elem_has_bin_io']: + */ + __pyx_t_8 = __Pyx_PyObject_GetAttrStr(__pyx_kp_u__28, __pyx_n_s_format); if (unlikely(!__pyx_t_8)) __PYX_ERR(2, 365, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __pyx_t_9 = NULL; + if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_8))) { + __pyx_t_9 = PyMethod_GET_SELF(__pyx_t_8); + if (likely(__pyx_t_9)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_8); + __Pyx_INCREF(__pyx_t_9); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_8, function); + } + } + if (!__pyx_t_9) { + __pyx_t_4 = __Pyx_PyObject_CallOneArg(__pyx_t_8, __pyx_v_name); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 365, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + } else { + #if CYTHON_FAST_PYCALL + if (PyFunction_Check(__pyx_t_8)) { + PyObject *__pyx_temp[2] = {__pyx_t_9, __pyx_v_name}; + __pyx_t_4 = __Pyx_PyFunction_FastCall(__pyx_t_8, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 365, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0; + __Pyx_GOTREF(__pyx_t_4); + } else + #endif + #if CYTHON_FAST_PYCCALL + if (__Pyx_PyFastCFunction_Check(__pyx_t_8)) { + PyObject *__pyx_temp[2] = {__pyx_t_9, __pyx_v_name}; + __pyx_t_4 = __Pyx_PyCFunction_FastCall(__pyx_t_8, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 365, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0; + __Pyx_GOTREF(__pyx_t_4); + } else + #endif + { + __pyx_t_10 = PyTuple_New(1+1); if (unlikely(!__pyx_t_10)) __PYX_ERR(2, 365, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_10); + __Pyx_GIVEREF(__pyx_t_9); PyTuple_SET_ITEM(__pyx_t_10, 0, __pyx_t_9); __pyx_t_9 = NULL; + __Pyx_INCREF(__pyx_v_name); + __Pyx_GIVEREF(__pyx_v_name); + PyTuple_SET_ITEM(__pyx_t_10, 0+1, __pyx_v_name); + __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_8, __pyx_t_10, NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 365, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; + } + } + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + __Pyx_DECREF_SET(__pyx_v_name, __pyx_t_4); + __pyx_t_4 = 0; + + /* "asyncpg/protocol/codecs/base.pyx":367 + * name = '{}[]'.format(name) + * + * if ti['elem_has_bin_io']: # <<<<<<<<<<<<<< + * elem_format = PG_FORMAT_BINARY + * else: + */ + __pyx_t_4 = PyObject_GetItem(__pyx_v_ti, __pyx_n_u_elem_has_bin_io); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 367, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_5 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_5 < 0)) __PYX_ERR(2, 367, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + if (__pyx_t_5) { + + /* "asyncpg/protocol/codecs/base.pyx":368 + * + * if ti['elem_has_bin_io']: + * elem_format = PG_FORMAT_BINARY # <<<<<<<<<<<<<< + * else: + * elem_format = PG_FORMAT_TEXT + */ + __pyx_v_elem_format = __pyx_e_7asyncpg_8protocol_8protocol_PG_FORMAT_BINARY; + + /* "asyncpg/protocol/codecs/base.pyx":367 + * name = '{}[]'.format(name) + * + * if ti['elem_has_bin_io']: # <<<<<<<<<<<<<< + * elem_format = PG_FORMAT_BINARY + * else: + */ + goto __pyx_L10; + } + + /* "asyncpg/protocol/codecs/base.pyx":370 + * elem_format = PG_FORMAT_BINARY + * else: + * elem_format = PG_FORMAT_TEXT # <<<<<<<<<<<<<< + * elem_codec = self.get_codec(array_element_oid, elem_format) + * if elem_codec is None: + */ + /*else*/ { + __pyx_v_elem_format = __pyx_e_7asyncpg_8protocol_8protocol_PG_FORMAT_TEXT; + } + __pyx_L10:; + + /* "asyncpg/protocol/codecs/base.pyx":371 + * else: + * elem_format = PG_FORMAT_TEXT + * elem_codec = self.get_codec(array_element_oid, elem_format) # <<<<<<<<<<<<<< + * if elem_codec is None: + * raise RuntimeError( + */ + __pyx_t_7 = __Pyx_PyInt_As_uint32_t(__pyx_v_array_element_oid); if (unlikely((__pyx_t_7 == ((uint32_t)-1)) && PyErr_Occurred())) __PYX_ERR(2, 371, __pyx_L1_error) + __pyx_t_4 = ((PyObject *)__pyx_f_7asyncpg_8protocol_8protocol_15DataCodecConfig_get_codec(__pyx_v_self, __pyx_t_7, __pyx_v_elem_format)); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 371, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_XDECREF_SET(__pyx_v_elem_codec, ((struct __pyx_obj_7asyncpg_8protocol_8protocol_Codec *)__pyx_t_4)); + __pyx_t_4 = 0; + + /* "asyncpg/protocol/codecs/base.pyx":372 + * elem_format = PG_FORMAT_TEXT + * elem_codec = self.get_codec(array_element_oid, elem_format) + * if elem_codec is None: # <<<<<<<<<<<<<< + * raise RuntimeError( + * 'no codec for array element type {}'.format( + */ + __pyx_t_5 = (((PyObject *)__pyx_v_elem_codec) == Py_None); + __pyx_t_6 = (__pyx_t_5 != 0); + if (__pyx_t_6) { + + /* "asyncpg/protocol/codecs/base.pyx":374 + * if elem_codec is None: + * raise RuntimeError( + * 'no codec for array element type {}'.format( # <<<<<<<<<<<<<< + * array_element_oid)) + * + */ + __pyx_t_8 = __Pyx_PyObject_GetAttrStr(__pyx_kp_u_no_codec_for_array_element_type, __pyx_n_s_format); if (unlikely(!__pyx_t_8)) __PYX_ERR(2, 374, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + + /* "asyncpg/protocol/codecs/base.pyx":375 + * raise RuntimeError( + * 'no codec for array element type {}'.format( + * array_element_oid)) # <<<<<<<<<<<<<< + * + * elem_delim = ti['elemdelim'][0] + */ + __pyx_t_10 = NULL; + if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_8))) { + __pyx_t_10 = PyMethod_GET_SELF(__pyx_t_8); + if (likely(__pyx_t_10)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_8); + __Pyx_INCREF(__pyx_t_10); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_8, function); + } + } + if (!__pyx_t_10) { + __pyx_t_4 = __Pyx_PyObject_CallOneArg(__pyx_t_8, __pyx_v_array_element_oid); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 374, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + } else { + #if CYTHON_FAST_PYCALL + if (PyFunction_Check(__pyx_t_8)) { + PyObject *__pyx_temp[2] = {__pyx_t_10, __pyx_v_array_element_oid}; + __pyx_t_4 = __Pyx_PyFunction_FastCall(__pyx_t_8, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 374, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_10); __pyx_t_10 = 0; + __Pyx_GOTREF(__pyx_t_4); + } else + #endif + #if CYTHON_FAST_PYCCALL + if (__Pyx_PyFastCFunction_Check(__pyx_t_8)) { + PyObject *__pyx_temp[2] = {__pyx_t_10, __pyx_v_array_element_oid}; + __pyx_t_4 = __Pyx_PyCFunction_FastCall(__pyx_t_8, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 374, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_10); __pyx_t_10 = 0; + __Pyx_GOTREF(__pyx_t_4); + } else + #endif + { + __pyx_t_9 = PyTuple_New(1+1); if (unlikely(!__pyx_t_9)) __PYX_ERR(2, 374, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_9); + __Pyx_GIVEREF(__pyx_t_10); PyTuple_SET_ITEM(__pyx_t_9, 0, __pyx_t_10); __pyx_t_10 = NULL; + __Pyx_INCREF(__pyx_v_array_element_oid); + __Pyx_GIVEREF(__pyx_v_array_element_oid); + PyTuple_SET_ITEM(__pyx_t_9, 0+1, __pyx_v_array_element_oid); + __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_8, __pyx_t_9, NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 374, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + } + } + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + + /* "asyncpg/protocol/codecs/base.pyx":373 + * elem_codec = self.get_codec(array_element_oid, elem_format) + * if elem_codec is None: + * raise RuntimeError( # <<<<<<<<<<<<<< + * 'no codec for array element type {}'.format( + * array_element_oid)) + */ + __pyx_t_8 = PyTuple_New(1); if (unlikely(!__pyx_t_8)) __PYX_ERR(2, 373, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __Pyx_GIVEREF(__pyx_t_4); + PyTuple_SET_ITEM(__pyx_t_8, 0, __pyx_t_4); + __pyx_t_4 = 0; + __pyx_t_4 = __Pyx_PyObject_Call(__pyx_builtin_RuntimeError, __pyx_t_8, NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 373, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + __Pyx_Raise(__pyx_t_4, 0, 0, 0); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __PYX_ERR(2, 373, __pyx_L1_error) + + /* "asyncpg/protocol/codecs/base.pyx":372 + * elem_format = PG_FORMAT_TEXT + * elem_codec = self.get_codec(array_element_oid, elem_format) + * if elem_codec is None: # <<<<<<<<<<<<<< + * raise RuntimeError( + * 'no codec for array element type {}'.format( + */ + } + + /* "asyncpg/protocol/codecs/base.pyx":377 + * array_element_oid)) + * + * elem_delim = ti['elemdelim'][0] # <<<<<<<<<<<<<< + * + * self._type_codecs_cache[oid, elem_format] = \ + */ + __pyx_t_4 = PyObject_GetItem(__pyx_v_ti, __pyx_n_u_elemdelim); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 377, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_8 = __Pyx_GetItemInt(__pyx_t_4, 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_8)) __PYX_ERR(2, 377, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_11 = __Pyx_PyObject_AsPy_UCS4(__pyx_t_8); if (unlikely((__pyx_t_11 == (Py_UCS4)-1) && PyErr_Occurred())) __PYX_ERR(2, 377, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + __pyx_v_elem_delim = ((Py_UCS4)__pyx_t_11); + + /* "asyncpg/protocol/codecs/base.pyx":381 + * self._type_codecs_cache[oid, elem_format] = \ + * Codec.new_array_codec( + * oid, name, schema, elem_codec, elem_delim) # <<<<<<<<<<<<<< + * + * elif ti['kind'] == b'c': + */ + __pyx_t_7 = __Pyx_PyInt_As_uint32_t(__pyx_v_oid); if (unlikely((__pyx_t_7 == ((uint32_t)-1)) && PyErr_Occurred())) __PYX_ERR(2, 381, __pyx_L1_error) + if (!(likely(PyUnicode_CheckExact(__pyx_v_name))||((__pyx_v_name) == Py_None)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "unicode", Py_TYPE(__pyx_v_name)->tp_name), 0))) __PYX_ERR(2, 381, __pyx_L1_error) + if (!(likely(PyUnicode_CheckExact(__pyx_v_schema))||((__pyx_v_schema) == Py_None)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "unicode", Py_TYPE(__pyx_v_schema)->tp_name), 0))) __PYX_ERR(2, 381, __pyx_L1_error) + + /* "asyncpg/protocol/codecs/base.pyx":380 + * + * self._type_codecs_cache[oid, elem_format] = \ + * Codec.new_array_codec( # <<<<<<<<<<<<<< + * oid, name, schema, elem_codec, elem_delim) + * + */ + __pyx_t_8 = ((PyObject *)__pyx_f_7asyncpg_8protocol_8protocol_5Codec_new_array_codec(__pyx_t_7, ((PyObject*)__pyx_v_name), ((PyObject*)__pyx_v_schema), __pyx_v_elem_codec, __pyx_v_elem_delim)); if (unlikely(!__pyx_t_8)) __PYX_ERR(2, 380, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + + /* "asyncpg/protocol/codecs/base.pyx":379 + * elem_delim = ti['elemdelim'][0] + * + * self._type_codecs_cache[oid, elem_format] = \ # <<<<<<<<<<<<<< + * Codec.new_array_codec( + * oid, name, schema, elem_codec, elem_delim) + */ + if (unlikely(__pyx_v_self->_type_codecs_cache == Py_None)) { + PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable"); + __PYX_ERR(2, 379, __pyx_L1_error) + } + __pyx_t_4 = __Pyx_PyInt_From_enum____pyx_t_7asyncpg_8protocol_8protocol_CodecFormat(__pyx_v_elem_format); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 379, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_9 = PyTuple_New(2); if (unlikely(!__pyx_t_9)) __PYX_ERR(2, 379, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_9); + __Pyx_INCREF(__pyx_v_oid); + __Pyx_GIVEREF(__pyx_v_oid); + PyTuple_SET_ITEM(__pyx_t_9, 0, __pyx_v_oid); + __Pyx_GIVEREF(__pyx_t_4); + PyTuple_SET_ITEM(__pyx_t_9, 1, __pyx_t_4); + __pyx_t_4 = 0; + if (unlikely(PyDict_SetItem(__pyx_v_self->_type_codecs_cache, __pyx_t_9, __pyx_t_8) < 0)) __PYX_ERR(2, 379, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + + /* "asyncpg/protocol/codecs/base.pyx":359 + * base_type = ti['basetype'] + * + * if array_element_oid: # <<<<<<<<<<<<<< + * # Array type (note, there is no separate 'kind' for arrays) + * + */ + goto __pyx_L8; + } + + /* "asyncpg/protocol/codecs/base.pyx":383 + * oid, name, schema, elem_codec, elem_delim) + * + * elif ti['kind'] == b'c': # <<<<<<<<<<<<<< + * if not comp_type_attrs: + * raise RuntimeError( + */ + __pyx_t_8 = PyObject_GetItem(__pyx_v_ti, __pyx_n_u_kind); if (unlikely(!__pyx_t_8)) __PYX_ERR(2, 383, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __pyx_t_6 = (__Pyx_PyBytes_Equals(__pyx_t_8, __pyx_n_b_c, Py_EQ)); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(2, 383, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + if (__pyx_t_6) { + + /* "asyncpg/protocol/codecs/base.pyx":384 + * + * elif ti['kind'] == b'c': + * if not comp_type_attrs: # <<<<<<<<<<<<<< + * raise RuntimeError( + * 'type record missing field types for ' + */ + __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_v_comp_type_attrs); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(2, 384, __pyx_L1_error) + __pyx_t_5 = ((!__pyx_t_6) != 0); + if (__pyx_t_5) { + + /* "asyncpg/protocol/codecs/base.pyx":387 + * raise RuntimeError( + * 'type record missing field types for ' + * 'composite {}'.format(oid)) # <<<<<<<<<<<<<< + * + * # Composite type + */ + __pyx_t_9 = __Pyx_PyObject_GetAttrStr(__pyx_kp_u_type_record_missing_field_types, __pyx_n_s_format); if (unlikely(!__pyx_t_9)) __PYX_ERR(2, 387, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_9); + __pyx_t_4 = NULL; + if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_9))) { + __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_9); + if (likely(__pyx_t_4)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_9); + __Pyx_INCREF(__pyx_t_4); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_9, function); + } + } + if (!__pyx_t_4) { + __pyx_t_8 = __Pyx_PyObject_CallOneArg(__pyx_t_9, __pyx_v_oid); if (unlikely(!__pyx_t_8)) __PYX_ERR(2, 387, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + } else { + #if CYTHON_FAST_PYCALL + if (PyFunction_Check(__pyx_t_9)) { + PyObject *__pyx_temp[2] = {__pyx_t_4, __pyx_v_oid}; + __pyx_t_8 = __Pyx_PyFunction_FastCall(__pyx_t_9, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_8)) __PYX_ERR(2, 387, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_GOTREF(__pyx_t_8); + } else + #endif + #if CYTHON_FAST_PYCCALL + if (__Pyx_PyFastCFunction_Check(__pyx_t_9)) { + PyObject *__pyx_temp[2] = {__pyx_t_4, __pyx_v_oid}; + __pyx_t_8 = __Pyx_PyCFunction_FastCall(__pyx_t_9, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_8)) __PYX_ERR(2, 387, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_GOTREF(__pyx_t_8); + } else + #endif + { + __pyx_t_10 = PyTuple_New(1+1); if (unlikely(!__pyx_t_10)) __PYX_ERR(2, 387, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_10); + __Pyx_GIVEREF(__pyx_t_4); PyTuple_SET_ITEM(__pyx_t_10, 0, __pyx_t_4); __pyx_t_4 = NULL; + __Pyx_INCREF(__pyx_v_oid); + __Pyx_GIVEREF(__pyx_v_oid); + PyTuple_SET_ITEM(__pyx_t_10, 0+1, __pyx_v_oid); + __pyx_t_8 = __Pyx_PyObject_Call(__pyx_t_9, __pyx_t_10, NULL); if (unlikely(!__pyx_t_8)) __PYX_ERR(2, 387, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; + } + } + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + + /* "asyncpg/protocol/codecs/base.pyx":385 + * elif ti['kind'] == b'c': + * if not comp_type_attrs: + * raise RuntimeError( # <<<<<<<<<<<<<< + * 'type record missing field types for ' + * 'composite {}'.format(oid)) + */ + __pyx_t_9 = PyTuple_New(1); if (unlikely(!__pyx_t_9)) __PYX_ERR(2, 385, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_9); + __Pyx_GIVEREF(__pyx_t_8); + PyTuple_SET_ITEM(__pyx_t_9, 0, __pyx_t_8); + __pyx_t_8 = 0; + __pyx_t_8 = __Pyx_PyObject_Call(__pyx_builtin_RuntimeError, __pyx_t_9, NULL); if (unlikely(!__pyx_t_8)) __PYX_ERR(2, 385, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + __Pyx_Raise(__pyx_t_8, 0, 0, 0); + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + __PYX_ERR(2, 385, __pyx_L1_error) + + /* "asyncpg/protocol/codecs/base.pyx":384 + * + * elif ti['kind'] == b'c': + * if not comp_type_attrs: # <<<<<<<<<<<<<< + * raise RuntimeError( + * 'type record missing field types for ' + */ + } + + /* "asyncpg/protocol/codecs/base.pyx":391 + * # Composite type + * + * comp_elem_codecs = [] # <<<<<<<<<<<<<< + * + * for typoid in comp_type_attrs: + */ + __pyx_t_8 = PyList_New(0); if (unlikely(!__pyx_t_8)) __PYX_ERR(2, 391, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __Pyx_XDECREF_SET(__pyx_v_comp_elem_codecs, ((PyObject*)__pyx_t_8)); + __pyx_t_8 = 0; + + /* "asyncpg/protocol/codecs/base.pyx":393 + * comp_elem_codecs = [] + * + * for typoid in comp_type_attrs: # <<<<<<<<<<<<<< + * elem_codec = self.get_codec(typoid, PG_FORMAT_BINARY) + * if elem_codec is None: + */ + if (likely(PyList_CheckExact(__pyx_v_comp_type_attrs)) || PyTuple_CheckExact(__pyx_v_comp_type_attrs)) { + __pyx_t_8 = __pyx_v_comp_type_attrs; __Pyx_INCREF(__pyx_t_8); __pyx_t_12 = 0; + __pyx_t_13 = NULL; + } else { + __pyx_t_12 = -1; __pyx_t_8 = PyObject_GetIter(__pyx_v_comp_type_attrs); if (unlikely(!__pyx_t_8)) __PYX_ERR(2, 393, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __pyx_t_13 = Py_TYPE(__pyx_t_8)->tp_iternext; if (unlikely(!__pyx_t_13)) __PYX_ERR(2, 393, __pyx_L1_error) + } + for (;;) { + if (likely(!__pyx_t_13)) { + if (likely(PyList_CheckExact(__pyx_t_8))) { + if (__pyx_t_12 >= PyList_GET_SIZE(__pyx_t_8)) break; + #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + __pyx_t_9 = PyList_GET_ITEM(__pyx_t_8, __pyx_t_12); __Pyx_INCREF(__pyx_t_9); __pyx_t_12++; if (unlikely(0 < 0)) __PYX_ERR(2, 393, __pyx_L1_error) + #else + __pyx_t_9 = PySequence_ITEM(__pyx_t_8, __pyx_t_12); __pyx_t_12++; if (unlikely(!__pyx_t_9)) __PYX_ERR(2, 393, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_9); + #endif + } else { + if (__pyx_t_12 >= PyTuple_GET_SIZE(__pyx_t_8)) break; + #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + __pyx_t_9 = PyTuple_GET_ITEM(__pyx_t_8, __pyx_t_12); __Pyx_INCREF(__pyx_t_9); __pyx_t_12++; if (unlikely(0 < 0)) __PYX_ERR(2, 393, __pyx_L1_error) + #else + __pyx_t_9 = PySequence_ITEM(__pyx_t_8, __pyx_t_12); __pyx_t_12++; if (unlikely(!__pyx_t_9)) __PYX_ERR(2, 393, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_9); + #endif + } + } else { + __pyx_t_9 = __pyx_t_13(__pyx_t_8); + if (unlikely(!__pyx_t_9)) { + PyObject* exc_type = PyErr_Occurred(); + if (exc_type) { + if (likely(exc_type == PyExc_StopIteration || PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) PyErr_Clear(); + else __PYX_ERR(2, 393, __pyx_L1_error) + } + break; + } + __Pyx_GOTREF(__pyx_t_9); + } + __Pyx_XDECREF_SET(__pyx_v_typoid, __pyx_t_9); + __pyx_t_9 = 0; + + /* "asyncpg/protocol/codecs/base.pyx":394 + * + * for typoid in comp_type_attrs: + * elem_codec = self.get_codec(typoid, PG_FORMAT_BINARY) # <<<<<<<<<<<<<< + * if elem_codec is None: + * elem_codec = self.get_codec(typoid, PG_FORMAT_TEXT) + */ + __pyx_t_7 = __Pyx_PyInt_As_uint32_t(__pyx_v_typoid); if (unlikely((__pyx_t_7 == ((uint32_t)-1)) && PyErr_Occurred())) __PYX_ERR(2, 394, __pyx_L1_error) + __pyx_t_9 = ((PyObject *)__pyx_f_7asyncpg_8protocol_8protocol_15DataCodecConfig_get_codec(__pyx_v_self, __pyx_t_7, __pyx_e_7asyncpg_8protocol_8protocol_PG_FORMAT_BINARY)); if (unlikely(!__pyx_t_9)) __PYX_ERR(2, 394, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_9); + __Pyx_XDECREF_SET(__pyx_v_elem_codec, ((struct __pyx_obj_7asyncpg_8protocol_8protocol_Codec *)__pyx_t_9)); + __pyx_t_9 = 0; + + /* "asyncpg/protocol/codecs/base.pyx":395 + * for typoid in comp_type_attrs: + * elem_codec = self.get_codec(typoid, PG_FORMAT_BINARY) + * if elem_codec is None: # <<<<<<<<<<<<<< + * elem_codec = self.get_codec(typoid, PG_FORMAT_TEXT) + * has_text_elements = True + */ + __pyx_t_5 = (((PyObject *)__pyx_v_elem_codec) == Py_None); + __pyx_t_6 = (__pyx_t_5 != 0); + if (__pyx_t_6) { + + /* "asyncpg/protocol/codecs/base.pyx":396 + * elem_codec = self.get_codec(typoid, PG_FORMAT_BINARY) + * if elem_codec is None: + * elem_codec = self.get_codec(typoid, PG_FORMAT_TEXT) # <<<<<<<<<<<<<< + * has_text_elements = True + * if elem_codec is None: + */ + __pyx_t_7 = __Pyx_PyInt_As_uint32_t(__pyx_v_typoid); if (unlikely((__pyx_t_7 == ((uint32_t)-1)) && PyErr_Occurred())) __PYX_ERR(2, 396, __pyx_L1_error) + __pyx_t_9 = ((PyObject *)__pyx_f_7asyncpg_8protocol_8protocol_15DataCodecConfig_get_codec(__pyx_v_self, __pyx_t_7, __pyx_e_7asyncpg_8protocol_8protocol_PG_FORMAT_TEXT)); if (unlikely(!__pyx_t_9)) __PYX_ERR(2, 396, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_9); + __Pyx_DECREF_SET(__pyx_v_elem_codec, ((struct __pyx_obj_7asyncpg_8protocol_8protocol_Codec *)__pyx_t_9)); + __pyx_t_9 = 0; + + /* "asyncpg/protocol/codecs/base.pyx":397 + * if elem_codec is None: + * elem_codec = self.get_codec(typoid, PG_FORMAT_TEXT) + * has_text_elements = True # <<<<<<<<<<<<<< + * if elem_codec is None: + * raise RuntimeError( + */ + __pyx_v_has_text_elements = 1; + + /* "asyncpg/protocol/codecs/base.pyx":395 + * for typoid in comp_type_attrs: + * elem_codec = self.get_codec(typoid, PG_FORMAT_BINARY) + * if elem_codec is None: # <<<<<<<<<<<<<< + * elem_codec = self.get_codec(typoid, PG_FORMAT_TEXT) + * has_text_elements = True + */ + } + + /* "asyncpg/protocol/codecs/base.pyx":398 + * elem_codec = self.get_codec(typoid, PG_FORMAT_TEXT) + * has_text_elements = True + * if elem_codec is None: # <<<<<<<<<<<<<< + * raise RuntimeError( + * 'no codec for composite attribute type {}'.format( + */ + __pyx_t_6 = (((PyObject *)__pyx_v_elem_codec) == Py_None); + __pyx_t_5 = (__pyx_t_6 != 0); + if (__pyx_t_5) { + + /* "asyncpg/protocol/codecs/base.pyx":400 + * if elem_codec is None: + * raise RuntimeError( + * 'no codec for composite attribute type {}'.format( # <<<<<<<<<<<<<< + * typoid)) + * comp_elem_codecs.append(elem_codec) + */ + __pyx_t_10 = __Pyx_PyObject_GetAttrStr(__pyx_kp_u_no_codec_for_composite_attribute, __pyx_n_s_format); if (unlikely(!__pyx_t_10)) __PYX_ERR(2, 400, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_10); + + /* "asyncpg/protocol/codecs/base.pyx":401 + * raise RuntimeError( + * 'no codec for composite attribute type {}'.format( + * typoid)) # <<<<<<<<<<<<<< + * comp_elem_codecs.append(elem_codec) + * + */ + __pyx_t_4 = NULL; + if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_10))) { + __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_10); + if (likely(__pyx_t_4)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_10); + __Pyx_INCREF(__pyx_t_4); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_10, function); + } + } + if (!__pyx_t_4) { + __pyx_t_9 = __Pyx_PyObject_CallOneArg(__pyx_t_10, __pyx_v_typoid); if (unlikely(!__pyx_t_9)) __PYX_ERR(2, 400, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_9); + } else { + #if CYTHON_FAST_PYCALL + if (PyFunction_Check(__pyx_t_10)) { + PyObject *__pyx_temp[2] = {__pyx_t_4, __pyx_v_typoid}; + __pyx_t_9 = __Pyx_PyFunction_FastCall(__pyx_t_10, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_9)) __PYX_ERR(2, 400, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_GOTREF(__pyx_t_9); + } else + #endif + #if CYTHON_FAST_PYCCALL + if (__Pyx_PyFastCFunction_Check(__pyx_t_10)) { + PyObject *__pyx_temp[2] = {__pyx_t_4, __pyx_v_typoid}; + __pyx_t_9 = __Pyx_PyCFunction_FastCall(__pyx_t_10, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_9)) __PYX_ERR(2, 400, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_GOTREF(__pyx_t_9); + } else + #endif + { + __pyx_t_14 = PyTuple_New(1+1); if (unlikely(!__pyx_t_14)) __PYX_ERR(2, 400, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_14); + __Pyx_GIVEREF(__pyx_t_4); PyTuple_SET_ITEM(__pyx_t_14, 0, __pyx_t_4); __pyx_t_4 = NULL; + __Pyx_INCREF(__pyx_v_typoid); + __Pyx_GIVEREF(__pyx_v_typoid); + PyTuple_SET_ITEM(__pyx_t_14, 0+1, __pyx_v_typoid); + __pyx_t_9 = __Pyx_PyObject_Call(__pyx_t_10, __pyx_t_14, NULL); if (unlikely(!__pyx_t_9)) __PYX_ERR(2, 400, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_9); + __Pyx_DECREF(__pyx_t_14); __pyx_t_14 = 0; + } + } + __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; + + /* "asyncpg/protocol/codecs/base.pyx":399 + * has_text_elements = True + * if elem_codec is None: + * raise RuntimeError( # <<<<<<<<<<<<<< + * 'no codec for composite attribute type {}'.format( + * typoid)) + */ + __pyx_t_10 = PyTuple_New(1); if (unlikely(!__pyx_t_10)) __PYX_ERR(2, 399, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_10); + __Pyx_GIVEREF(__pyx_t_9); + PyTuple_SET_ITEM(__pyx_t_10, 0, __pyx_t_9); + __pyx_t_9 = 0; + __pyx_t_9 = __Pyx_PyObject_Call(__pyx_builtin_RuntimeError, __pyx_t_10, NULL); if (unlikely(!__pyx_t_9)) __PYX_ERR(2, 399, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_9); + __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; + __Pyx_Raise(__pyx_t_9, 0, 0, 0); + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + __PYX_ERR(2, 399, __pyx_L1_error) + + /* "asyncpg/protocol/codecs/base.pyx":398 + * elem_codec = self.get_codec(typoid, PG_FORMAT_TEXT) + * has_text_elements = True + * if elem_codec is None: # <<<<<<<<<<<<<< + * raise RuntimeError( + * 'no codec for composite attribute type {}'.format( + */ + } + + /* "asyncpg/protocol/codecs/base.pyx":402 + * 'no codec for composite attribute type {}'.format( + * typoid)) + * comp_elem_codecs.append(elem_codec) # <<<<<<<<<<<<<< + * + * element_names = collections.OrderedDict() + */ + __pyx_t_15 = __Pyx_PyList_Append(__pyx_v_comp_elem_codecs, ((PyObject *)__pyx_v_elem_codec)); if (unlikely(__pyx_t_15 == -1)) __PYX_ERR(2, 402, __pyx_L1_error) + + /* "asyncpg/protocol/codecs/base.pyx":393 + * comp_elem_codecs = [] + * + * for typoid in comp_type_attrs: # <<<<<<<<<<<<<< + * elem_codec = self.get_codec(typoid, PG_FORMAT_BINARY) + * if elem_codec is None: + */ + } + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + + /* "asyncpg/protocol/codecs/base.pyx":404 + * comp_elem_codecs.append(elem_codec) + * + * element_names = collections.OrderedDict() # <<<<<<<<<<<<<< + * for i, attrname in enumerate(ti['attrnames']): + * element_names[attrname] = i + */ + __pyx_t_9 = __Pyx_GetModuleGlobalName(__pyx_n_s_collections); if (unlikely(!__pyx_t_9)) __PYX_ERR(2, 404, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_9); + __pyx_t_10 = __Pyx_PyObject_GetAttrStr(__pyx_t_9, __pyx_n_s_OrderedDict); if (unlikely(!__pyx_t_10)) __PYX_ERR(2, 404, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_10); + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + __pyx_t_9 = NULL; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_10))) { + __pyx_t_9 = PyMethod_GET_SELF(__pyx_t_10); + if (likely(__pyx_t_9)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_10); + __Pyx_INCREF(__pyx_t_9); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_10, function); + } + } + if (__pyx_t_9) { + __pyx_t_8 = __Pyx_PyObject_CallOneArg(__pyx_t_10, __pyx_t_9); if (unlikely(!__pyx_t_8)) __PYX_ERR(2, 404, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + } else { + __pyx_t_8 = __Pyx_PyObject_CallNoArg(__pyx_t_10); if (unlikely(!__pyx_t_8)) __PYX_ERR(2, 404, __pyx_L1_error) + } + __Pyx_GOTREF(__pyx_t_8); + __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; + __Pyx_XDECREF_SET(__pyx_v_element_names, __pyx_t_8); + __pyx_t_8 = 0; + + /* "asyncpg/protocol/codecs/base.pyx":405 + * + * element_names = collections.OrderedDict() + * for i, attrname in enumerate(ti['attrnames']): # <<<<<<<<<<<<<< + * element_names[attrname] = i + * + */ + __Pyx_INCREF(__pyx_int_0); + __pyx_t_8 = __pyx_int_0; + __pyx_t_10 = PyObject_GetItem(__pyx_v_ti, __pyx_n_u_attrnames); if (unlikely(!__pyx_t_10)) __PYX_ERR(2, 405, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_10); + if (likely(PyList_CheckExact(__pyx_t_10)) || PyTuple_CheckExact(__pyx_t_10)) { + __pyx_t_9 = __pyx_t_10; __Pyx_INCREF(__pyx_t_9); __pyx_t_12 = 0; + __pyx_t_13 = NULL; + } else { + __pyx_t_12 = -1; __pyx_t_9 = PyObject_GetIter(__pyx_t_10); if (unlikely(!__pyx_t_9)) __PYX_ERR(2, 405, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_9); + __pyx_t_13 = Py_TYPE(__pyx_t_9)->tp_iternext; if (unlikely(!__pyx_t_13)) __PYX_ERR(2, 405, __pyx_L1_error) + } + __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; + for (;;) { + if (likely(!__pyx_t_13)) { + if (likely(PyList_CheckExact(__pyx_t_9))) { + if (__pyx_t_12 >= PyList_GET_SIZE(__pyx_t_9)) break; + #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + __pyx_t_10 = PyList_GET_ITEM(__pyx_t_9, __pyx_t_12); __Pyx_INCREF(__pyx_t_10); __pyx_t_12++; if (unlikely(0 < 0)) __PYX_ERR(2, 405, __pyx_L1_error) + #else + __pyx_t_10 = PySequence_ITEM(__pyx_t_9, __pyx_t_12); __pyx_t_12++; if (unlikely(!__pyx_t_10)) __PYX_ERR(2, 405, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_10); + #endif + } else { + if (__pyx_t_12 >= PyTuple_GET_SIZE(__pyx_t_9)) break; + #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + __pyx_t_10 = PyTuple_GET_ITEM(__pyx_t_9, __pyx_t_12); __Pyx_INCREF(__pyx_t_10); __pyx_t_12++; if (unlikely(0 < 0)) __PYX_ERR(2, 405, __pyx_L1_error) + #else + __pyx_t_10 = PySequence_ITEM(__pyx_t_9, __pyx_t_12); __pyx_t_12++; if (unlikely(!__pyx_t_10)) __PYX_ERR(2, 405, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_10); + #endif + } + } else { + __pyx_t_10 = __pyx_t_13(__pyx_t_9); + if (unlikely(!__pyx_t_10)) { + PyObject* exc_type = PyErr_Occurred(); + if (exc_type) { + if (likely(exc_type == PyExc_StopIteration || PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) PyErr_Clear(); + else __PYX_ERR(2, 405, __pyx_L1_error) + } + break; + } + __Pyx_GOTREF(__pyx_t_10); + } + __Pyx_XDECREF_SET(__pyx_v_attrname, __pyx_t_10); + __pyx_t_10 = 0; + __Pyx_INCREF(__pyx_t_8); + __Pyx_XDECREF_SET(__pyx_v_i, __pyx_t_8); + __pyx_t_10 = __Pyx_PyInt_AddObjC(__pyx_t_8, __pyx_int_1, 1, 0); if (unlikely(!__pyx_t_10)) __PYX_ERR(2, 405, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_10); + __Pyx_DECREF(__pyx_t_8); + __pyx_t_8 = __pyx_t_10; + __pyx_t_10 = 0; + + /* "asyncpg/protocol/codecs/base.pyx":406 + * element_names = collections.OrderedDict() + * for i, attrname in enumerate(ti['attrnames']): + * element_names[attrname] = i # <<<<<<<<<<<<<< + * + * if has_text_elements: + */ + if (unlikely(PyObject_SetItem(__pyx_v_element_names, __pyx_v_attrname, __pyx_v_i) < 0)) __PYX_ERR(2, 406, __pyx_L1_error) + + /* "asyncpg/protocol/codecs/base.pyx":405 + * + * element_names = collections.OrderedDict() + * for i, attrname in enumerate(ti['attrnames']): # <<<<<<<<<<<<<< + * element_names[attrname] = i + * + */ + } + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + + /* "asyncpg/protocol/codecs/base.pyx":408 + * element_names[attrname] = i + * + * if has_text_elements: # <<<<<<<<<<<<<< + * format = PG_FORMAT_TEXT + * + */ + __pyx_t_5 = (__pyx_v_has_text_elements != 0); + if (__pyx_t_5) { + + /* "asyncpg/protocol/codecs/base.pyx":409 + * + * if has_text_elements: + * format = PG_FORMAT_TEXT # <<<<<<<<<<<<<< + * + * self._type_codecs_cache[oid, format] = \ + */ + __pyx_v_format = __pyx_e_7asyncpg_8protocol_8protocol_PG_FORMAT_TEXT; + + /* "asyncpg/protocol/codecs/base.pyx":408 + * element_names[attrname] = i + * + * if has_text_elements: # <<<<<<<<<<<<<< + * format = PG_FORMAT_TEXT + * + */ + } + + /* "asyncpg/protocol/codecs/base.pyx":413 + * self._type_codecs_cache[oid, format] = \ + * Codec.new_composite_codec( + * oid, name, schema, comp_elem_codecs, # <<<<<<<<<<<<<< + * comp_type_attrs, + * element_names) + */ + __pyx_t_7 = __Pyx_PyInt_As_uint32_t(__pyx_v_oid); if (unlikely((__pyx_t_7 == ((uint32_t)-1)) && PyErr_Occurred())) __PYX_ERR(2, 413, __pyx_L1_error) + if (!(likely(PyUnicode_CheckExact(__pyx_v_name))||((__pyx_v_name) == Py_None)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "unicode", Py_TYPE(__pyx_v_name)->tp_name), 0))) __PYX_ERR(2, 413, __pyx_L1_error) + if (!(likely(PyUnicode_CheckExact(__pyx_v_schema))||((__pyx_v_schema) == Py_None)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "unicode", Py_TYPE(__pyx_v_schema)->tp_name), 0))) __PYX_ERR(2, 413, __pyx_L1_error) + + /* "asyncpg/protocol/codecs/base.pyx":414 + * Codec.new_composite_codec( + * oid, name, schema, comp_elem_codecs, + * comp_type_attrs, # <<<<<<<<<<<<<< + * element_names) + * + */ + if (!(likely(PyTuple_CheckExact(__pyx_v_comp_type_attrs))||((__pyx_v_comp_type_attrs) == Py_None)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "tuple", Py_TYPE(__pyx_v_comp_type_attrs)->tp_name), 0))) __PYX_ERR(2, 414, __pyx_L1_error) + + /* "asyncpg/protocol/codecs/base.pyx":412 + * + * self._type_codecs_cache[oid, format] = \ + * Codec.new_composite_codec( # <<<<<<<<<<<<<< + * oid, name, schema, comp_elem_codecs, + * comp_type_attrs, + */ + __pyx_t_8 = ((PyObject *)__pyx_f_7asyncpg_8protocol_8protocol_5Codec_new_composite_codec(__pyx_t_7, ((PyObject*)__pyx_v_name), ((PyObject*)__pyx_v_schema), __pyx_v_comp_elem_codecs, ((PyObject*)__pyx_v_comp_type_attrs), __pyx_v_element_names)); if (unlikely(!__pyx_t_8)) __PYX_ERR(2, 412, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + + /* "asyncpg/protocol/codecs/base.pyx":411 + * format = PG_FORMAT_TEXT + * + * self._type_codecs_cache[oid, format] = \ # <<<<<<<<<<<<<< + * Codec.new_composite_codec( + * oid, name, schema, comp_elem_codecs, + */ + if (unlikely(__pyx_v_self->_type_codecs_cache == Py_None)) { + PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable"); + __PYX_ERR(2, 411, __pyx_L1_error) + } + __pyx_t_9 = __Pyx_PyInt_From_enum____pyx_t_7asyncpg_8protocol_8protocol_CodecFormat(__pyx_v_format); if (unlikely(!__pyx_t_9)) __PYX_ERR(2, 411, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_9); + __pyx_t_10 = PyTuple_New(2); if (unlikely(!__pyx_t_10)) __PYX_ERR(2, 411, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_10); + __Pyx_INCREF(__pyx_v_oid); + __Pyx_GIVEREF(__pyx_v_oid); + PyTuple_SET_ITEM(__pyx_t_10, 0, __pyx_v_oid); + __Pyx_GIVEREF(__pyx_t_9); + PyTuple_SET_ITEM(__pyx_t_10, 1, __pyx_t_9); + __pyx_t_9 = 0; + if (unlikely(PyDict_SetItem(__pyx_v_self->_type_codecs_cache, __pyx_t_10, __pyx_t_8) < 0)) __PYX_ERR(2, 411, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + + /* "asyncpg/protocol/codecs/base.pyx":383 + * oid, name, schema, elem_codec, elem_delim) + * + * elif ti['kind'] == b'c': # <<<<<<<<<<<<<< + * if not comp_type_attrs: + * raise RuntimeError( + */ + goto __pyx_L8; + } + + /* "asyncpg/protocol/codecs/base.pyx":417 + * element_names) + * + * elif ti['kind'] == b'd': # <<<<<<<<<<<<<< + * # Domain type + * + */ + __pyx_t_8 = PyObject_GetItem(__pyx_v_ti, __pyx_n_u_kind); if (unlikely(!__pyx_t_8)) __PYX_ERR(2, 417, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __pyx_t_5 = (__Pyx_PyBytes_Equals(__pyx_t_8, __pyx_n_b_d, Py_EQ)); if (unlikely(__pyx_t_5 < 0)) __PYX_ERR(2, 417, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + if (__pyx_t_5) { + + /* "asyncpg/protocol/codecs/base.pyx":420 + * # Domain type + * + * if not base_type: # <<<<<<<<<<<<<< + * raise RuntimeError( + * 'type record missing base type for domain {}'.format( + */ + __pyx_t_5 = __Pyx_PyObject_IsTrue(__pyx_v_base_type); if (unlikely(__pyx_t_5 < 0)) __PYX_ERR(2, 420, __pyx_L1_error) + __pyx_t_6 = ((!__pyx_t_5) != 0); + if (__pyx_t_6) { + + /* "asyncpg/protocol/codecs/base.pyx":422 + * if not base_type: + * raise RuntimeError( + * 'type record missing base type for domain {}'.format( # <<<<<<<<<<<<<< + * oid)) + * + */ + __pyx_t_10 = __Pyx_PyObject_GetAttrStr(__pyx_kp_u_type_record_missing_base_type_fo, __pyx_n_s_format); if (unlikely(!__pyx_t_10)) __PYX_ERR(2, 422, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_10); + + /* "asyncpg/protocol/codecs/base.pyx":423 + * raise RuntimeError( + * 'type record missing base type for domain {}'.format( + * oid)) # <<<<<<<<<<<<<< + * + * elem_codec = self.get_codec(base_type, format) + */ + __pyx_t_9 = NULL; + if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_10))) { + __pyx_t_9 = PyMethod_GET_SELF(__pyx_t_10); + if (likely(__pyx_t_9)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_10); + __Pyx_INCREF(__pyx_t_9); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_10, function); + } + } + if (!__pyx_t_9) { + __pyx_t_8 = __Pyx_PyObject_CallOneArg(__pyx_t_10, __pyx_v_oid); if (unlikely(!__pyx_t_8)) __PYX_ERR(2, 422, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + } else { + #if CYTHON_FAST_PYCALL + if (PyFunction_Check(__pyx_t_10)) { + PyObject *__pyx_temp[2] = {__pyx_t_9, __pyx_v_oid}; + __pyx_t_8 = __Pyx_PyFunction_FastCall(__pyx_t_10, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_8)) __PYX_ERR(2, 422, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0; + __Pyx_GOTREF(__pyx_t_8); + } else + #endif + #if CYTHON_FAST_PYCCALL + if (__Pyx_PyFastCFunction_Check(__pyx_t_10)) { + PyObject *__pyx_temp[2] = {__pyx_t_9, __pyx_v_oid}; + __pyx_t_8 = __Pyx_PyCFunction_FastCall(__pyx_t_10, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_8)) __PYX_ERR(2, 422, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0; + __Pyx_GOTREF(__pyx_t_8); + } else + #endif + { + __pyx_t_14 = PyTuple_New(1+1); if (unlikely(!__pyx_t_14)) __PYX_ERR(2, 422, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_14); + __Pyx_GIVEREF(__pyx_t_9); PyTuple_SET_ITEM(__pyx_t_14, 0, __pyx_t_9); __pyx_t_9 = NULL; + __Pyx_INCREF(__pyx_v_oid); + __Pyx_GIVEREF(__pyx_v_oid); + PyTuple_SET_ITEM(__pyx_t_14, 0+1, __pyx_v_oid); + __pyx_t_8 = __Pyx_PyObject_Call(__pyx_t_10, __pyx_t_14, NULL); if (unlikely(!__pyx_t_8)) __PYX_ERR(2, 422, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __Pyx_DECREF(__pyx_t_14); __pyx_t_14 = 0; + } + } + __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; + + /* "asyncpg/protocol/codecs/base.pyx":421 + * + * if not base_type: + * raise RuntimeError( # <<<<<<<<<<<<<< + * 'type record missing base type for domain {}'.format( + * oid)) + */ + __pyx_t_10 = PyTuple_New(1); if (unlikely(!__pyx_t_10)) __PYX_ERR(2, 421, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_10); + __Pyx_GIVEREF(__pyx_t_8); + PyTuple_SET_ITEM(__pyx_t_10, 0, __pyx_t_8); + __pyx_t_8 = 0; + __pyx_t_8 = __Pyx_PyObject_Call(__pyx_builtin_RuntimeError, __pyx_t_10, NULL); if (unlikely(!__pyx_t_8)) __PYX_ERR(2, 421, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; + __Pyx_Raise(__pyx_t_8, 0, 0, 0); + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + __PYX_ERR(2, 421, __pyx_L1_error) + + /* "asyncpg/protocol/codecs/base.pyx":420 + * # Domain type + * + * if not base_type: # <<<<<<<<<<<<<< + * raise RuntimeError( + * 'type record missing base type for domain {}'.format( + */ + } + + /* "asyncpg/protocol/codecs/base.pyx":425 + * oid)) + * + * elem_codec = self.get_codec(base_type, format) # <<<<<<<<<<<<<< + * if elem_codec is None: + * raise RuntimeError( + */ + __pyx_t_7 = __Pyx_PyInt_As_uint32_t(__pyx_v_base_type); if (unlikely((__pyx_t_7 == ((uint32_t)-1)) && PyErr_Occurred())) __PYX_ERR(2, 425, __pyx_L1_error) + __pyx_t_8 = ((PyObject *)__pyx_f_7asyncpg_8protocol_8protocol_15DataCodecConfig_get_codec(__pyx_v_self, __pyx_t_7, __pyx_v_format)); if (unlikely(!__pyx_t_8)) __PYX_ERR(2, 425, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __Pyx_XDECREF_SET(__pyx_v_elem_codec, ((struct __pyx_obj_7asyncpg_8protocol_8protocol_Codec *)__pyx_t_8)); + __pyx_t_8 = 0; + + /* "asyncpg/protocol/codecs/base.pyx":426 + * + * elem_codec = self.get_codec(base_type, format) + * if elem_codec is None: # <<<<<<<<<<<<<< + * raise RuntimeError( + * 'no codec for domain base type {}'.format(base_type)) + */ + __pyx_t_6 = (((PyObject *)__pyx_v_elem_codec) == Py_None); + __pyx_t_5 = (__pyx_t_6 != 0); + if (__pyx_t_5) { + + /* "asyncpg/protocol/codecs/base.pyx":428 + * if elem_codec is None: + * raise RuntimeError( + * 'no codec for domain base type {}'.format(base_type)) # <<<<<<<<<<<<<< + * + * self._type_codecs_cache[oid, format] = elem_codec + */ + __pyx_t_10 = __Pyx_PyObject_GetAttrStr(__pyx_kp_u_no_codec_for_domain_base_type, __pyx_n_s_format); if (unlikely(!__pyx_t_10)) __PYX_ERR(2, 428, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_10); + __pyx_t_14 = NULL; + if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_10))) { + __pyx_t_14 = PyMethod_GET_SELF(__pyx_t_10); + if (likely(__pyx_t_14)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_10); + __Pyx_INCREF(__pyx_t_14); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_10, function); + } + } + if (!__pyx_t_14) { + __pyx_t_8 = __Pyx_PyObject_CallOneArg(__pyx_t_10, __pyx_v_base_type); if (unlikely(!__pyx_t_8)) __PYX_ERR(2, 428, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + } else { + #if CYTHON_FAST_PYCALL + if (PyFunction_Check(__pyx_t_10)) { + PyObject *__pyx_temp[2] = {__pyx_t_14, __pyx_v_base_type}; + __pyx_t_8 = __Pyx_PyFunction_FastCall(__pyx_t_10, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_8)) __PYX_ERR(2, 428, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_14); __pyx_t_14 = 0; + __Pyx_GOTREF(__pyx_t_8); + } else + #endif + #if CYTHON_FAST_PYCCALL + if (__Pyx_PyFastCFunction_Check(__pyx_t_10)) { + PyObject *__pyx_temp[2] = {__pyx_t_14, __pyx_v_base_type}; + __pyx_t_8 = __Pyx_PyCFunction_FastCall(__pyx_t_10, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_8)) __PYX_ERR(2, 428, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_14); __pyx_t_14 = 0; + __Pyx_GOTREF(__pyx_t_8); + } else + #endif + { + __pyx_t_9 = PyTuple_New(1+1); if (unlikely(!__pyx_t_9)) __PYX_ERR(2, 428, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_9); + __Pyx_GIVEREF(__pyx_t_14); PyTuple_SET_ITEM(__pyx_t_9, 0, __pyx_t_14); __pyx_t_14 = NULL; + __Pyx_INCREF(__pyx_v_base_type); + __Pyx_GIVEREF(__pyx_v_base_type); + PyTuple_SET_ITEM(__pyx_t_9, 0+1, __pyx_v_base_type); + __pyx_t_8 = __Pyx_PyObject_Call(__pyx_t_10, __pyx_t_9, NULL); if (unlikely(!__pyx_t_8)) __PYX_ERR(2, 428, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + } + } + __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; + + /* "asyncpg/protocol/codecs/base.pyx":427 + * elem_codec = self.get_codec(base_type, format) + * if elem_codec is None: + * raise RuntimeError( # <<<<<<<<<<<<<< + * 'no codec for domain base type {}'.format(base_type)) + * + */ + __pyx_t_10 = PyTuple_New(1); if (unlikely(!__pyx_t_10)) __PYX_ERR(2, 427, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_10); + __Pyx_GIVEREF(__pyx_t_8); + PyTuple_SET_ITEM(__pyx_t_10, 0, __pyx_t_8); + __pyx_t_8 = 0; + __pyx_t_8 = __Pyx_PyObject_Call(__pyx_builtin_RuntimeError, __pyx_t_10, NULL); if (unlikely(!__pyx_t_8)) __PYX_ERR(2, 427, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; + __Pyx_Raise(__pyx_t_8, 0, 0, 0); + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + __PYX_ERR(2, 427, __pyx_L1_error) + + /* "asyncpg/protocol/codecs/base.pyx":426 + * + * elem_codec = self.get_codec(base_type, format) + * if elem_codec is None: # <<<<<<<<<<<<<< + * raise RuntimeError( + * 'no codec for domain base type {}'.format(base_type)) + */ + } + + /* "asyncpg/protocol/codecs/base.pyx":430 + * 'no codec for domain base type {}'.format(base_type)) + * + * self._type_codecs_cache[oid, format] = elem_codec # <<<<<<<<<<<<<< + * + * elif ti['kind'] == b'r': + */ + if (unlikely(__pyx_v_self->_type_codecs_cache == Py_None)) { + PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable"); + __PYX_ERR(2, 430, __pyx_L1_error) + } + __pyx_t_8 = __Pyx_PyInt_From_enum____pyx_t_7asyncpg_8protocol_8protocol_CodecFormat(__pyx_v_format); if (unlikely(!__pyx_t_8)) __PYX_ERR(2, 430, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __pyx_t_10 = PyTuple_New(2); if (unlikely(!__pyx_t_10)) __PYX_ERR(2, 430, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_10); + __Pyx_INCREF(__pyx_v_oid); + __Pyx_GIVEREF(__pyx_v_oid); + PyTuple_SET_ITEM(__pyx_t_10, 0, __pyx_v_oid); + __Pyx_GIVEREF(__pyx_t_8); + PyTuple_SET_ITEM(__pyx_t_10, 1, __pyx_t_8); + __pyx_t_8 = 0; + if (unlikely(PyDict_SetItem(__pyx_v_self->_type_codecs_cache, __pyx_t_10, ((PyObject *)__pyx_v_elem_codec)) < 0)) __PYX_ERR(2, 430, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; + + /* "asyncpg/protocol/codecs/base.pyx":417 + * element_names) + * + * elif ti['kind'] == b'd': # <<<<<<<<<<<<<< + * # Domain type + * + */ + goto __pyx_L8; + } + + /* "asyncpg/protocol/codecs/base.pyx":432 + * self._type_codecs_cache[oid, format] = elem_codec + * + * elif ti['kind'] == b'r': # <<<<<<<<<<<<<< + * # Range type + * + */ + __pyx_t_10 = PyObject_GetItem(__pyx_v_ti, __pyx_n_u_kind); if (unlikely(!__pyx_t_10)) __PYX_ERR(2, 432, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_10); + __pyx_t_5 = (__Pyx_PyBytes_Equals(__pyx_t_10, __pyx_n_b_r, Py_EQ)); if (unlikely(__pyx_t_5 < 0)) __PYX_ERR(2, 432, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; + if (__pyx_t_5) { + + /* "asyncpg/protocol/codecs/base.pyx":435 + * # Range type + * + * if not range_subtype_oid: # <<<<<<<<<<<<<< + * raise RuntimeError( + * 'type record missing base type for range {}'.format( + */ + __pyx_t_5 = __Pyx_PyObject_IsTrue(__pyx_v_range_subtype_oid); if (unlikely(__pyx_t_5 < 0)) __PYX_ERR(2, 435, __pyx_L1_error) + __pyx_t_6 = ((!__pyx_t_5) != 0); + if (__pyx_t_6) { + + /* "asyncpg/protocol/codecs/base.pyx":437 + * if not range_subtype_oid: + * raise RuntimeError( + * 'type record missing base type for range {}'.format( # <<<<<<<<<<<<<< + * oid)) + * + */ + __pyx_t_8 = __Pyx_PyObject_GetAttrStr(__pyx_kp_u_type_record_missing_base_type_fo_2, __pyx_n_s_format); if (unlikely(!__pyx_t_8)) __PYX_ERR(2, 437, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + + /* "asyncpg/protocol/codecs/base.pyx":438 + * raise RuntimeError( + * 'type record missing base type for range {}'.format( + * oid)) # <<<<<<<<<<<<<< + * + * if ti['elem_has_bin_io']: + */ + __pyx_t_9 = NULL; + if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_8))) { + __pyx_t_9 = PyMethod_GET_SELF(__pyx_t_8); + if (likely(__pyx_t_9)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_8); + __Pyx_INCREF(__pyx_t_9); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_8, function); + } + } + if (!__pyx_t_9) { + __pyx_t_10 = __Pyx_PyObject_CallOneArg(__pyx_t_8, __pyx_v_oid); if (unlikely(!__pyx_t_10)) __PYX_ERR(2, 437, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_10); + } else { + #if CYTHON_FAST_PYCALL + if (PyFunction_Check(__pyx_t_8)) { + PyObject *__pyx_temp[2] = {__pyx_t_9, __pyx_v_oid}; + __pyx_t_10 = __Pyx_PyFunction_FastCall(__pyx_t_8, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_10)) __PYX_ERR(2, 437, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0; + __Pyx_GOTREF(__pyx_t_10); + } else + #endif + #if CYTHON_FAST_PYCCALL + if (__Pyx_PyFastCFunction_Check(__pyx_t_8)) { + PyObject *__pyx_temp[2] = {__pyx_t_9, __pyx_v_oid}; + __pyx_t_10 = __Pyx_PyCFunction_FastCall(__pyx_t_8, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_10)) __PYX_ERR(2, 437, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0; + __Pyx_GOTREF(__pyx_t_10); + } else + #endif + { + __pyx_t_14 = PyTuple_New(1+1); if (unlikely(!__pyx_t_14)) __PYX_ERR(2, 437, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_14); + __Pyx_GIVEREF(__pyx_t_9); PyTuple_SET_ITEM(__pyx_t_14, 0, __pyx_t_9); __pyx_t_9 = NULL; + __Pyx_INCREF(__pyx_v_oid); + __Pyx_GIVEREF(__pyx_v_oid); + PyTuple_SET_ITEM(__pyx_t_14, 0+1, __pyx_v_oid); + __pyx_t_10 = __Pyx_PyObject_Call(__pyx_t_8, __pyx_t_14, NULL); if (unlikely(!__pyx_t_10)) __PYX_ERR(2, 437, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_10); + __Pyx_DECREF(__pyx_t_14); __pyx_t_14 = 0; + } + } + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + + /* "asyncpg/protocol/codecs/base.pyx":436 + * + * if not range_subtype_oid: + * raise RuntimeError( # <<<<<<<<<<<<<< + * 'type record missing base type for range {}'.format( + * oid)) + */ + __pyx_t_8 = PyTuple_New(1); if (unlikely(!__pyx_t_8)) __PYX_ERR(2, 436, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __Pyx_GIVEREF(__pyx_t_10); + PyTuple_SET_ITEM(__pyx_t_8, 0, __pyx_t_10); + __pyx_t_10 = 0; + __pyx_t_10 = __Pyx_PyObject_Call(__pyx_builtin_RuntimeError, __pyx_t_8, NULL); if (unlikely(!__pyx_t_10)) __PYX_ERR(2, 436, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_10); + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + __Pyx_Raise(__pyx_t_10, 0, 0, 0); + __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; + __PYX_ERR(2, 436, __pyx_L1_error) + + /* "asyncpg/protocol/codecs/base.pyx":435 + * # Range type + * + * if not range_subtype_oid: # <<<<<<<<<<<<<< + * raise RuntimeError( + * 'type record missing base type for range {}'.format( + */ + } + + /* "asyncpg/protocol/codecs/base.pyx":440 + * oid)) + * + * if ti['elem_has_bin_io']: # <<<<<<<<<<<<<< + * elem_format = PG_FORMAT_BINARY + * else: + */ + __pyx_t_10 = PyObject_GetItem(__pyx_v_ti, __pyx_n_u_elem_has_bin_io); if (unlikely(!__pyx_t_10)) __PYX_ERR(2, 440, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_10); + __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_10); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(2, 440, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; + if (__pyx_t_6) { + + /* "asyncpg/protocol/codecs/base.pyx":441 + * + * if ti['elem_has_bin_io']: + * elem_format = PG_FORMAT_BINARY # <<<<<<<<<<<<<< + * else: + * elem_format = PG_FORMAT_TEXT + */ + __pyx_v_elem_format = __pyx_e_7asyncpg_8protocol_8protocol_PG_FORMAT_BINARY; + + /* "asyncpg/protocol/codecs/base.pyx":440 + * oid)) + * + * if ti['elem_has_bin_io']: # <<<<<<<<<<<<<< + * elem_format = PG_FORMAT_BINARY + * else: + */ + goto __pyx_L23; + } + + /* "asyncpg/protocol/codecs/base.pyx":443 + * elem_format = PG_FORMAT_BINARY + * else: + * elem_format = PG_FORMAT_TEXT # <<<<<<<<<<<<<< + * elem_codec = self.get_codec(range_subtype_oid, elem_format) + * if elem_codec is None: + */ + /*else*/ { + __pyx_v_elem_format = __pyx_e_7asyncpg_8protocol_8protocol_PG_FORMAT_TEXT; + } + __pyx_L23:; + + /* "asyncpg/protocol/codecs/base.pyx":444 + * else: + * elem_format = PG_FORMAT_TEXT + * elem_codec = self.get_codec(range_subtype_oid, elem_format) # <<<<<<<<<<<<<< + * if elem_codec is None: + * raise RuntimeError( + */ + __pyx_t_7 = __Pyx_PyInt_As_uint32_t(__pyx_v_range_subtype_oid); if (unlikely((__pyx_t_7 == ((uint32_t)-1)) && PyErr_Occurred())) __PYX_ERR(2, 444, __pyx_L1_error) + __pyx_t_10 = ((PyObject *)__pyx_f_7asyncpg_8protocol_8protocol_15DataCodecConfig_get_codec(__pyx_v_self, __pyx_t_7, __pyx_v_elem_format)); if (unlikely(!__pyx_t_10)) __PYX_ERR(2, 444, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_10); + __Pyx_XDECREF_SET(__pyx_v_elem_codec, ((struct __pyx_obj_7asyncpg_8protocol_8protocol_Codec *)__pyx_t_10)); + __pyx_t_10 = 0; + + /* "asyncpg/protocol/codecs/base.pyx":445 + * elem_format = PG_FORMAT_TEXT + * elem_codec = self.get_codec(range_subtype_oid, elem_format) + * if elem_codec is None: # <<<<<<<<<<<<<< + * raise RuntimeError( + * 'no codec for range element type {}'.format( + */ + __pyx_t_6 = (((PyObject *)__pyx_v_elem_codec) == Py_None); + __pyx_t_5 = (__pyx_t_6 != 0); + if (__pyx_t_5) { + + /* "asyncpg/protocol/codecs/base.pyx":447 + * if elem_codec is None: + * raise RuntimeError( + * 'no codec for range element type {}'.format( # <<<<<<<<<<<<<< + * range_subtype_oid)) + * + */ + __pyx_t_8 = __Pyx_PyObject_GetAttrStr(__pyx_kp_u_no_codec_for_range_element_type, __pyx_n_s_format); if (unlikely(!__pyx_t_8)) __PYX_ERR(2, 447, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + + /* "asyncpg/protocol/codecs/base.pyx":448 + * raise RuntimeError( + * 'no codec for range element type {}'.format( + * range_subtype_oid)) # <<<<<<<<<<<<<< + * + * self._type_codecs_cache[oid, elem_format] = \ + */ + __pyx_t_14 = NULL; + if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_8))) { + __pyx_t_14 = PyMethod_GET_SELF(__pyx_t_8); + if (likely(__pyx_t_14)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_8); + __Pyx_INCREF(__pyx_t_14); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_8, function); + } + } + if (!__pyx_t_14) { + __pyx_t_10 = __Pyx_PyObject_CallOneArg(__pyx_t_8, __pyx_v_range_subtype_oid); if (unlikely(!__pyx_t_10)) __PYX_ERR(2, 447, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_10); + } else { + #if CYTHON_FAST_PYCALL + if (PyFunction_Check(__pyx_t_8)) { + PyObject *__pyx_temp[2] = {__pyx_t_14, __pyx_v_range_subtype_oid}; + __pyx_t_10 = __Pyx_PyFunction_FastCall(__pyx_t_8, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_10)) __PYX_ERR(2, 447, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_14); __pyx_t_14 = 0; + __Pyx_GOTREF(__pyx_t_10); + } else + #endif + #if CYTHON_FAST_PYCCALL + if (__Pyx_PyFastCFunction_Check(__pyx_t_8)) { + PyObject *__pyx_temp[2] = {__pyx_t_14, __pyx_v_range_subtype_oid}; + __pyx_t_10 = __Pyx_PyCFunction_FastCall(__pyx_t_8, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_10)) __PYX_ERR(2, 447, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_14); __pyx_t_14 = 0; + __Pyx_GOTREF(__pyx_t_10); + } else + #endif + { + __pyx_t_9 = PyTuple_New(1+1); if (unlikely(!__pyx_t_9)) __PYX_ERR(2, 447, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_9); + __Pyx_GIVEREF(__pyx_t_14); PyTuple_SET_ITEM(__pyx_t_9, 0, __pyx_t_14); __pyx_t_14 = NULL; + __Pyx_INCREF(__pyx_v_range_subtype_oid); + __Pyx_GIVEREF(__pyx_v_range_subtype_oid); + PyTuple_SET_ITEM(__pyx_t_9, 0+1, __pyx_v_range_subtype_oid); + __pyx_t_10 = __Pyx_PyObject_Call(__pyx_t_8, __pyx_t_9, NULL); if (unlikely(!__pyx_t_10)) __PYX_ERR(2, 447, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_10); + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + } + } + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + + /* "asyncpg/protocol/codecs/base.pyx":446 + * elem_codec = self.get_codec(range_subtype_oid, elem_format) + * if elem_codec is None: + * raise RuntimeError( # <<<<<<<<<<<<<< + * 'no codec for range element type {}'.format( + * range_subtype_oid)) + */ + __pyx_t_8 = PyTuple_New(1); if (unlikely(!__pyx_t_8)) __PYX_ERR(2, 446, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __Pyx_GIVEREF(__pyx_t_10); + PyTuple_SET_ITEM(__pyx_t_8, 0, __pyx_t_10); + __pyx_t_10 = 0; + __pyx_t_10 = __Pyx_PyObject_Call(__pyx_builtin_RuntimeError, __pyx_t_8, NULL); if (unlikely(!__pyx_t_10)) __PYX_ERR(2, 446, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_10); + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + __Pyx_Raise(__pyx_t_10, 0, 0, 0); + __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; + __PYX_ERR(2, 446, __pyx_L1_error) + + /* "asyncpg/protocol/codecs/base.pyx":445 + * elem_format = PG_FORMAT_TEXT + * elem_codec = self.get_codec(range_subtype_oid, elem_format) + * if elem_codec is None: # <<<<<<<<<<<<<< + * raise RuntimeError( + * 'no codec for range element type {}'.format( + */ + } + + /* "asyncpg/protocol/codecs/base.pyx":451 + * + * self._type_codecs_cache[oid, elem_format] = \ + * Codec.new_range_codec(oid, name, schema, elem_codec) # <<<<<<<<<<<<<< + * + * else: + */ + __pyx_t_7 = __Pyx_PyInt_As_uint32_t(__pyx_v_oid); if (unlikely((__pyx_t_7 == ((uint32_t)-1)) && PyErr_Occurred())) __PYX_ERR(2, 451, __pyx_L1_error) + if (!(likely(PyUnicode_CheckExact(__pyx_v_name))||((__pyx_v_name) == Py_None)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "unicode", Py_TYPE(__pyx_v_name)->tp_name), 0))) __PYX_ERR(2, 451, __pyx_L1_error) + if (!(likely(PyUnicode_CheckExact(__pyx_v_schema))||((__pyx_v_schema) == Py_None)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "unicode", Py_TYPE(__pyx_v_schema)->tp_name), 0))) __PYX_ERR(2, 451, __pyx_L1_error) + __pyx_t_10 = ((PyObject *)__pyx_f_7asyncpg_8protocol_8protocol_5Codec_new_range_codec(__pyx_t_7, ((PyObject*)__pyx_v_name), ((PyObject*)__pyx_v_schema), __pyx_v_elem_codec)); if (unlikely(!__pyx_t_10)) __PYX_ERR(2, 451, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_10); + + /* "asyncpg/protocol/codecs/base.pyx":450 + * range_subtype_oid)) + * + * self._type_codecs_cache[oid, elem_format] = \ # <<<<<<<<<<<<<< + * Codec.new_range_codec(oid, name, schema, elem_codec) + * + */ + if (unlikely(__pyx_v_self->_type_codecs_cache == Py_None)) { + PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable"); + __PYX_ERR(2, 450, __pyx_L1_error) + } + __pyx_t_8 = __Pyx_PyInt_From_enum____pyx_t_7asyncpg_8protocol_8protocol_CodecFormat(__pyx_v_elem_format); if (unlikely(!__pyx_t_8)) __PYX_ERR(2, 450, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __pyx_t_9 = PyTuple_New(2); if (unlikely(!__pyx_t_9)) __PYX_ERR(2, 450, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_9); + __Pyx_INCREF(__pyx_v_oid); + __Pyx_GIVEREF(__pyx_v_oid); + PyTuple_SET_ITEM(__pyx_t_9, 0, __pyx_v_oid); + __Pyx_GIVEREF(__pyx_t_8); + PyTuple_SET_ITEM(__pyx_t_9, 1, __pyx_t_8); + __pyx_t_8 = 0; + if (unlikely(PyDict_SetItem(__pyx_v_self->_type_codecs_cache, __pyx_t_9, __pyx_t_10) < 0)) __PYX_ERR(2, 450, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; + + /* "asyncpg/protocol/codecs/base.pyx":432 + * self._type_codecs_cache[oid, format] = elem_codec + * + * elif ti['kind'] == b'r': # <<<<<<<<<<<<<< + * # Range type + * + */ + goto __pyx_L8; + } + + /* "asyncpg/protocol/codecs/base.pyx":454 + * + * else: + * if oid <= MAXBUILTINOID: # <<<<<<<<<<<<<< + * # This is a non-BKI type, for which ayncpg has no + * # defined codec. This should only happen for newly + */ + /*else*/ { + __pyx_t_10 = PyObject_RichCompare(__pyx_v_oid, __pyx_int_9999, Py_LE); __Pyx_XGOTREF(__pyx_t_10); if (unlikely(!__pyx_t_10)) __PYX_ERR(2, 454, __pyx_L1_error) + __pyx_t_5 = __Pyx_PyObject_IsTrue(__pyx_t_10); if (unlikely(__pyx_t_5 < 0)) __PYX_ERR(2, 454, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; + if (__pyx_t_5) { + + /* "asyncpg/protocol/codecs/base.pyx":461 + * # + * raise NotImplementedError( + * 'unhandled standard data type {!r} (OID {})'.format( # <<<<<<<<<<<<<< + * name, oid)) + * else: + */ + __pyx_t_9 = __Pyx_PyObject_GetAttrStr(__pyx_kp_u_unhandled_standard_data_type_r_O, __pyx_n_s_format); if (unlikely(!__pyx_t_9)) __PYX_ERR(2, 461, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_9); + + /* "asyncpg/protocol/codecs/base.pyx":462 + * raise NotImplementedError( + * 'unhandled standard data type {!r} (OID {})'.format( + * name, oid)) # <<<<<<<<<<<<<< + * else: + * # This is a non-BKI type, and as such, has no + */ + __pyx_t_8 = NULL; + __pyx_t_16 = 0; + if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_9))) { + __pyx_t_8 = PyMethod_GET_SELF(__pyx_t_9); + if (likely(__pyx_t_8)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_9); + __Pyx_INCREF(__pyx_t_8); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_9, function); + __pyx_t_16 = 1; + } + } + #if CYTHON_FAST_PYCALL + if (PyFunction_Check(__pyx_t_9)) { + PyObject *__pyx_temp[3] = {__pyx_t_8, __pyx_v_name, __pyx_v_oid}; + __pyx_t_10 = __Pyx_PyFunction_FastCall(__pyx_t_9, __pyx_temp+1-__pyx_t_16, 2+__pyx_t_16); if (unlikely(!__pyx_t_10)) __PYX_ERR(2, 461, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; + __Pyx_GOTREF(__pyx_t_10); + } else + #endif + #if CYTHON_FAST_PYCCALL + if (__Pyx_PyFastCFunction_Check(__pyx_t_9)) { + PyObject *__pyx_temp[3] = {__pyx_t_8, __pyx_v_name, __pyx_v_oid}; + __pyx_t_10 = __Pyx_PyCFunction_FastCall(__pyx_t_9, __pyx_temp+1-__pyx_t_16, 2+__pyx_t_16); if (unlikely(!__pyx_t_10)) __PYX_ERR(2, 461, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; + __Pyx_GOTREF(__pyx_t_10); + } else + #endif + { + __pyx_t_14 = PyTuple_New(2+__pyx_t_16); if (unlikely(!__pyx_t_14)) __PYX_ERR(2, 461, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_14); + if (__pyx_t_8) { + __Pyx_GIVEREF(__pyx_t_8); PyTuple_SET_ITEM(__pyx_t_14, 0, __pyx_t_8); __pyx_t_8 = NULL; + } + __Pyx_INCREF(__pyx_v_name); + __Pyx_GIVEREF(__pyx_v_name); + PyTuple_SET_ITEM(__pyx_t_14, 0+__pyx_t_16, __pyx_v_name); + __Pyx_INCREF(__pyx_v_oid); + __Pyx_GIVEREF(__pyx_v_oid); + PyTuple_SET_ITEM(__pyx_t_14, 1+__pyx_t_16, __pyx_v_oid); + __pyx_t_10 = __Pyx_PyObject_Call(__pyx_t_9, __pyx_t_14, NULL); if (unlikely(!__pyx_t_10)) __PYX_ERR(2, 461, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_10); + __Pyx_DECREF(__pyx_t_14); __pyx_t_14 = 0; + } + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + + /* "asyncpg/protocol/codecs/base.pyx":460 + * # asyncpg is lacking support. + * # + * raise NotImplementedError( # <<<<<<<<<<<<<< + * 'unhandled standard data type {!r} (OID {})'.format( + * name, oid)) + */ + __pyx_t_9 = PyTuple_New(1); if (unlikely(!__pyx_t_9)) __PYX_ERR(2, 460, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_9); + __Pyx_GIVEREF(__pyx_t_10); + PyTuple_SET_ITEM(__pyx_t_9, 0, __pyx_t_10); + __pyx_t_10 = 0; + __pyx_t_10 = __Pyx_PyObject_Call(__pyx_builtin_NotImplementedError, __pyx_t_9, NULL); if (unlikely(!__pyx_t_10)) __PYX_ERR(2, 460, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_10); + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + __Pyx_Raise(__pyx_t_10, 0, 0, 0); + __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; + __PYX_ERR(2, 460, __pyx_L1_error) + + /* "asyncpg/protocol/codecs/base.pyx":454 + * + * else: + * if oid <= MAXBUILTINOID: # <<<<<<<<<<<<<< + * # This is a non-BKI type, for which ayncpg has no + * # defined codec. This should only happen for newly + */ + } + + /* "asyncpg/protocol/codecs/base.pyx":470 + * # using Connection.set_type_codec(). + * # + * self.set_builtin_type_codec(oid, name, schema, 'scalar', # <<<<<<<<<<<<<< + * UNKNOWNOID) + * + */ + /*else*/ { + __pyx_t_9 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_set_builtin_type_codec); if (unlikely(!__pyx_t_9)) __PYX_ERR(2, 470, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_9); + __pyx_t_14 = NULL; + __pyx_t_16 = 0; + if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_9))) { + __pyx_t_14 = PyMethod_GET_SELF(__pyx_t_9); + if (likely(__pyx_t_14)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_9); + __Pyx_INCREF(__pyx_t_14); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_9, function); + __pyx_t_16 = 1; + } + } + #if CYTHON_FAST_PYCALL + if (PyFunction_Check(__pyx_t_9)) { + PyObject *__pyx_temp[6] = {__pyx_t_14, __pyx_v_oid, __pyx_v_name, __pyx_v_schema, __pyx_n_u_scalar, __pyx_int_705}; + __pyx_t_10 = __Pyx_PyFunction_FastCall(__pyx_t_9, __pyx_temp+1-__pyx_t_16, 5+__pyx_t_16); if (unlikely(!__pyx_t_10)) __PYX_ERR(2, 470, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_14); __pyx_t_14 = 0; + __Pyx_GOTREF(__pyx_t_10); + } else + #endif + #if CYTHON_FAST_PYCCALL + if (__Pyx_PyFastCFunction_Check(__pyx_t_9)) { + PyObject *__pyx_temp[6] = {__pyx_t_14, __pyx_v_oid, __pyx_v_name, __pyx_v_schema, __pyx_n_u_scalar, __pyx_int_705}; + __pyx_t_10 = __Pyx_PyCFunction_FastCall(__pyx_t_9, __pyx_temp+1-__pyx_t_16, 5+__pyx_t_16); if (unlikely(!__pyx_t_10)) __PYX_ERR(2, 470, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_14); __pyx_t_14 = 0; + __Pyx_GOTREF(__pyx_t_10); + } else + #endif + { + __pyx_t_8 = PyTuple_New(5+__pyx_t_16); if (unlikely(!__pyx_t_8)) __PYX_ERR(2, 470, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + if (__pyx_t_14) { + __Pyx_GIVEREF(__pyx_t_14); PyTuple_SET_ITEM(__pyx_t_8, 0, __pyx_t_14); __pyx_t_14 = NULL; + } + __Pyx_INCREF(__pyx_v_oid); + __Pyx_GIVEREF(__pyx_v_oid); + PyTuple_SET_ITEM(__pyx_t_8, 0+__pyx_t_16, __pyx_v_oid); + __Pyx_INCREF(__pyx_v_name); + __Pyx_GIVEREF(__pyx_v_name); + PyTuple_SET_ITEM(__pyx_t_8, 1+__pyx_t_16, __pyx_v_name); + __Pyx_INCREF(__pyx_v_schema); + __Pyx_GIVEREF(__pyx_v_schema); + PyTuple_SET_ITEM(__pyx_t_8, 2+__pyx_t_16, __pyx_v_schema); + __Pyx_INCREF(__pyx_n_u_scalar); + __Pyx_GIVEREF(__pyx_n_u_scalar); + PyTuple_SET_ITEM(__pyx_t_8, 3+__pyx_t_16, __pyx_n_u_scalar); + __Pyx_INCREF(__pyx_int_705); + __Pyx_GIVEREF(__pyx_int_705); + PyTuple_SET_ITEM(__pyx_t_8, 4+__pyx_t_16, __pyx_int_705); + __pyx_t_10 = __Pyx_PyObject_Call(__pyx_t_9, __pyx_t_8, NULL); if (unlikely(!__pyx_t_10)) __PYX_ERR(2, 470, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_10); + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + } + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; + } + } + __pyx_L8:; + + /* "asyncpg/protocol/codecs/base.pyx":336 + * Py_UCS4 elem_delim + * + * for ti in types: # <<<<<<<<<<<<<< + * oid = ti['oid'] + * + */ + __pyx_L3_continue:; + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "asyncpg/protocol/codecs/base.pyx":327 + * self._local_type_codecs = {} + * + * def add_types(self, types): # <<<<<<<<<<<<<< + * cdef: + * Codec elem_codec + */ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_XDECREF(__pyx_t_8); + __Pyx_XDECREF(__pyx_t_9); + __Pyx_XDECREF(__pyx_t_10); + __Pyx_XDECREF(__pyx_t_14); + __Pyx_AddTraceback("asyncpg.protocol.protocol.DataCodecConfig.add_types", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XDECREF((PyObject *)__pyx_v_elem_codec); + __Pyx_XDECREF(__pyx_v_comp_elem_codecs); + __Pyx_XDECREF(__pyx_v_ti); + __Pyx_XDECREF(__pyx_v_oid); + __Pyx_XDECREF(__pyx_v_name); + __Pyx_XDECREF(__pyx_v_schema); + __Pyx_XDECREF(__pyx_v_array_element_oid); + __Pyx_XDECREF(__pyx_v_range_subtype_oid); + __Pyx_XDECREF(__pyx_v_comp_type_attrs); + __Pyx_XDECREF(__pyx_v_base_type); + __Pyx_XDECREF(__pyx_v_typoid); + __Pyx_XDECREF(__pyx_v_element_names); + __Pyx_XDECREF(__pyx_v_i); + __Pyx_XDECREF(__pyx_v_attrname); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "asyncpg/protocol/codecs/base.pyx":473 + * UNKNOWNOID) + * + * def add_python_codec(self, typeoid, typename, typeschema, typekind, # <<<<<<<<<<<<<< + * encoder, decoder, binary): + * format = PG_FORMAT_BINARY if binary else PG_FORMAT_TEXT + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_7asyncpg_8protocol_8protocol_15DataCodecConfig_5add_python_codec(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ +static PyObject *__pyx_pw_7asyncpg_8protocol_8protocol_15DataCodecConfig_5add_python_codec(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { + PyObject *__pyx_v_typeoid = 0; + PyObject *__pyx_v_typename = 0; + PyObject *__pyx_v_typeschema = 0; + PyObject *__pyx_v_typekind = 0; + PyObject *__pyx_v_encoder = 0; + PyObject *__pyx_v_decoder = 0; + PyObject *__pyx_v_binary = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("add_python_codec (wrapper)", 0); + { + static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_typeoid,&__pyx_n_s_typename,&__pyx_n_s_typeschema,&__pyx_n_s_typekind,&__pyx_n_s_encoder,&__pyx_n_s_decoder,&__pyx_n_s_binary,0}; + PyObject* values[7] = {0,0,0,0,0,0,0}; + if (unlikely(__pyx_kwds)) { + Py_ssize_t kw_args; + const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args); + switch (pos_args) { + case 7: values[6] = PyTuple_GET_ITEM(__pyx_args, 6); + case 6: values[5] = PyTuple_GET_ITEM(__pyx_args, 5); + case 5: values[4] = PyTuple_GET_ITEM(__pyx_args, 4); + case 4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3); + case 3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2); + case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); + case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = PyDict_Size(__pyx_kwds); + switch (pos_args) { + case 0: + if (likely((values[0] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_typeoid)) != 0)) kw_args--; + else goto __pyx_L5_argtuple_error; + case 1: + if (likely((values[1] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_typename)) != 0)) kw_args--; + else { + __Pyx_RaiseArgtupleInvalid("add_python_codec", 1, 7, 7, 1); __PYX_ERR(2, 473, __pyx_L3_error) + } + case 2: + if (likely((values[2] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_typeschema)) != 0)) kw_args--; + else { + __Pyx_RaiseArgtupleInvalid("add_python_codec", 1, 7, 7, 2); __PYX_ERR(2, 473, __pyx_L3_error) + } + case 3: + if (likely((values[3] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_typekind)) != 0)) kw_args--; + else { + __Pyx_RaiseArgtupleInvalid("add_python_codec", 1, 7, 7, 3); __PYX_ERR(2, 473, __pyx_L3_error) + } + case 4: + if (likely((values[4] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_encoder)) != 0)) kw_args--; + else { + __Pyx_RaiseArgtupleInvalid("add_python_codec", 1, 7, 7, 4); __PYX_ERR(2, 473, __pyx_L3_error) + } + case 5: + if (likely((values[5] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_decoder)) != 0)) kw_args--; + else { + __Pyx_RaiseArgtupleInvalid("add_python_codec", 1, 7, 7, 5); __PYX_ERR(2, 473, __pyx_L3_error) + } + case 6: + if (likely((values[6] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_binary)) != 0)) kw_args--; + else { + __Pyx_RaiseArgtupleInvalid("add_python_codec", 1, 7, 7, 6); __PYX_ERR(2, 473, __pyx_L3_error) + } + } + if (unlikely(kw_args > 0)) { + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "add_python_codec") < 0)) __PYX_ERR(2, 473, __pyx_L3_error) + } + } else if (PyTuple_GET_SIZE(__pyx_args) != 7) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + values[1] = PyTuple_GET_ITEM(__pyx_args, 1); + values[2] = PyTuple_GET_ITEM(__pyx_args, 2); + values[3] = PyTuple_GET_ITEM(__pyx_args, 3); + values[4] = PyTuple_GET_ITEM(__pyx_args, 4); + values[5] = PyTuple_GET_ITEM(__pyx_args, 5); + values[6] = PyTuple_GET_ITEM(__pyx_args, 6); + } + __pyx_v_typeoid = values[0]; + __pyx_v_typename = values[1]; + __pyx_v_typeschema = values[2]; + __pyx_v_typekind = values[3]; + __pyx_v_encoder = values[4]; + __pyx_v_decoder = values[5]; + __pyx_v_binary = values[6]; + } + goto __pyx_L4_argument_unpacking_done; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("add_python_codec", 1, 7, 7, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(2, 473, __pyx_L3_error) + __pyx_L3_error:; + __Pyx_AddTraceback("asyncpg.protocol.protocol.DataCodecConfig.add_python_codec", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_7asyncpg_8protocol_8protocol_15DataCodecConfig_4add_python_codec(((struct __pyx_obj_7asyncpg_8protocol_8protocol_DataCodecConfig *)__pyx_v_self), __pyx_v_typeoid, __pyx_v_typename, __pyx_v_typeschema, __pyx_v_typekind, __pyx_v_encoder, __pyx_v_decoder, __pyx_v_binary); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_7asyncpg_8protocol_8protocol_15DataCodecConfig_4add_python_codec(struct __pyx_obj_7asyncpg_8protocol_8protocol_DataCodecConfig *__pyx_v_self, PyObject *__pyx_v_typeoid, PyObject *__pyx_v_typename, PyObject *__pyx_v_typeschema, PyObject *__pyx_v_typekind, PyObject *__pyx_v_encoder, PyObject *__pyx_v_decoder, PyObject *__pyx_v_binary) { + enum __pyx_t_7asyncpg_8protocol_8protocol_CodecFormat __pyx_v_format; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + enum __pyx_t_7asyncpg_8protocol_8protocol_CodecFormat __pyx_t_1; + int __pyx_t_2; + uint32_t __pyx_t_3; + PyObject *__pyx_t_4 = NULL; + int __pyx_t_5; + PyObject *__pyx_t_6 = NULL; + PyObject *__pyx_t_7 = NULL; + PyObject *__pyx_t_8 = NULL; + __Pyx_RefNannySetupContext("add_python_codec", 0); + + /* "asyncpg/protocol/codecs/base.pyx":475 + * def add_python_codec(self, typeoid, typename, typeschema, typekind, + * encoder, decoder, binary): + * format = PG_FORMAT_BINARY if binary else PG_FORMAT_TEXT # <<<<<<<<<<<<<< + * + * if self.get_codec(typeoid, format) is not None: + */ + __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_v_binary); if (unlikely(__pyx_t_2 < 0)) __PYX_ERR(2, 475, __pyx_L1_error) + if (__pyx_t_2) { + __pyx_t_1 = __pyx_e_7asyncpg_8protocol_8protocol_PG_FORMAT_BINARY; + } else { + __pyx_t_1 = __pyx_e_7asyncpg_8protocol_8protocol_PG_FORMAT_TEXT; + } + __pyx_v_format = __pyx_t_1; + + /* "asyncpg/protocol/codecs/base.pyx":477 + * format = PG_FORMAT_BINARY if binary else PG_FORMAT_TEXT + * + * if self.get_codec(typeoid, format) is not None: # <<<<<<<<<<<<<< + * raise ValueError('cannot override codec for type {}'.format( + * typeoid)) + */ + __pyx_t_3 = __Pyx_PyInt_As_uint32_t(__pyx_v_typeoid); if (unlikely((__pyx_t_3 == ((uint32_t)-1)) && PyErr_Occurred())) __PYX_ERR(2, 477, __pyx_L1_error) + __pyx_t_4 = ((PyObject *)__pyx_f_7asyncpg_8protocol_8protocol_15DataCodecConfig_get_codec(__pyx_v_self, __pyx_t_3, __pyx_v_format)); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 477, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_2 = (__pyx_t_4 != Py_None); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_5 = (__pyx_t_2 != 0); + if (__pyx_t_5) { + + /* "asyncpg/protocol/codecs/base.pyx":478 + * + * if self.get_codec(typeoid, format) is not None: + * raise ValueError('cannot override codec for type {}'.format( # <<<<<<<<<<<<<< + * typeoid)) + * + */ + __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_kp_u_cannot_override_codec_for_type, __pyx_n_s_format); if (unlikely(!__pyx_t_6)) __PYX_ERR(2, 478, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + + /* "asyncpg/protocol/codecs/base.pyx":479 + * if self.get_codec(typeoid, format) is not None: + * raise ValueError('cannot override codec for type {}'.format( + * typeoid)) # <<<<<<<<<<<<<< + * + * self._local_type_codecs[typeoid, format] = \ + */ + __pyx_t_7 = NULL; + if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_6))) { + __pyx_t_7 = PyMethod_GET_SELF(__pyx_t_6); + if (likely(__pyx_t_7)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_6); + __Pyx_INCREF(__pyx_t_7); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_6, function); + } + } + if (!__pyx_t_7) { + __pyx_t_4 = __Pyx_PyObject_CallOneArg(__pyx_t_6, __pyx_v_typeoid); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 478, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + } else { + #if CYTHON_FAST_PYCALL + if (PyFunction_Check(__pyx_t_6)) { + PyObject *__pyx_temp[2] = {__pyx_t_7, __pyx_v_typeoid}; + __pyx_t_4 = __Pyx_PyFunction_FastCall(__pyx_t_6, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 478, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_GOTREF(__pyx_t_4); + } else + #endif + #if CYTHON_FAST_PYCCALL + if (__Pyx_PyFastCFunction_Check(__pyx_t_6)) { + PyObject *__pyx_temp[2] = {__pyx_t_7, __pyx_v_typeoid}; + __pyx_t_4 = __Pyx_PyCFunction_FastCall(__pyx_t_6, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 478, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_GOTREF(__pyx_t_4); + } else + #endif + { + __pyx_t_8 = PyTuple_New(1+1); if (unlikely(!__pyx_t_8)) __PYX_ERR(2, 478, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __Pyx_GIVEREF(__pyx_t_7); PyTuple_SET_ITEM(__pyx_t_8, 0, __pyx_t_7); __pyx_t_7 = NULL; + __Pyx_INCREF(__pyx_v_typeoid); + __Pyx_GIVEREF(__pyx_v_typeoid); + PyTuple_SET_ITEM(__pyx_t_8, 0+1, __pyx_v_typeoid); + __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_6, __pyx_t_8, NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 478, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + } + } + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + + /* "asyncpg/protocol/codecs/base.pyx":478 + * + * if self.get_codec(typeoid, format) is not None: + * raise ValueError('cannot override codec for type {}'.format( # <<<<<<<<<<<<<< + * typeoid)) + * + */ + __pyx_t_6 = PyTuple_New(1); if (unlikely(!__pyx_t_6)) __PYX_ERR(2, 478, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_GIVEREF(__pyx_t_4); + PyTuple_SET_ITEM(__pyx_t_6, 0, __pyx_t_4); + __pyx_t_4 = 0; + __pyx_t_4 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_t_6, NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 478, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_Raise(__pyx_t_4, 0, 0, 0); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __PYX_ERR(2, 478, __pyx_L1_error) + + /* "asyncpg/protocol/codecs/base.pyx":477 + * format = PG_FORMAT_BINARY if binary else PG_FORMAT_TEXT + * + * if self.get_codec(typeoid, format) is not None: # <<<<<<<<<<<<<< + * raise ValueError('cannot override codec for type {}'.format( + * typeoid)) + */ + } + + /* "asyncpg/protocol/codecs/base.pyx":482 + * + * self._local_type_codecs[typeoid, format] = \ + * Codec.new_python_codec(typeoid, typename, typeschema, typekind, # <<<<<<<<<<<<<< + * encoder, decoder, format) + * + */ + __pyx_t_3 = __Pyx_PyInt_As_uint32_t(__pyx_v_typeoid); if (unlikely((__pyx_t_3 == ((uint32_t)-1)) && PyErr_Occurred())) __PYX_ERR(2, 482, __pyx_L1_error) + if (!(likely(PyUnicode_CheckExact(__pyx_v_typename))||((__pyx_v_typename) == Py_None)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "unicode", Py_TYPE(__pyx_v_typename)->tp_name), 0))) __PYX_ERR(2, 482, __pyx_L1_error) + if (!(likely(PyUnicode_CheckExact(__pyx_v_typeschema))||((__pyx_v_typeschema) == Py_None)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "unicode", Py_TYPE(__pyx_v_typeschema)->tp_name), 0))) __PYX_ERR(2, 482, __pyx_L1_error) + if (!(likely(PyUnicode_CheckExact(__pyx_v_typekind))||((__pyx_v_typekind) == Py_None)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "unicode", Py_TYPE(__pyx_v_typekind)->tp_name), 0))) __PYX_ERR(2, 482, __pyx_L1_error) + + /* "asyncpg/protocol/codecs/base.pyx":483 + * self._local_type_codecs[typeoid, format] = \ + * Codec.new_python_codec(typeoid, typename, typeschema, typekind, + * encoder, decoder, format) # <<<<<<<<<<<<<< + * + * def set_builtin_type_codec(self, typeoid, typename, typeschema, typekind, + */ + __pyx_t_4 = ((PyObject *)__pyx_f_7asyncpg_8protocol_8protocol_5Codec_new_python_codec(__pyx_t_3, ((PyObject*)__pyx_v_typename), ((PyObject*)__pyx_v_typeschema), ((PyObject*)__pyx_v_typekind), __pyx_v_encoder, __pyx_v_decoder, __pyx_v_format)); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 482, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + + /* "asyncpg/protocol/codecs/base.pyx":481 + * typeoid)) + * + * self._local_type_codecs[typeoid, format] = \ # <<<<<<<<<<<<<< + * Codec.new_python_codec(typeoid, typename, typeschema, typekind, + * encoder, decoder, format) + */ + if (unlikely(__pyx_v_self->_local_type_codecs == Py_None)) { + PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable"); + __PYX_ERR(2, 481, __pyx_L1_error) + } + __pyx_t_6 = __Pyx_PyInt_From_enum____pyx_t_7asyncpg_8protocol_8protocol_CodecFormat(__pyx_v_format); if (unlikely(!__pyx_t_6)) __PYX_ERR(2, 481, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_8 = PyTuple_New(2); if (unlikely(!__pyx_t_8)) __PYX_ERR(2, 481, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __Pyx_INCREF(__pyx_v_typeoid); + __Pyx_GIVEREF(__pyx_v_typeoid); + PyTuple_SET_ITEM(__pyx_t_8, 0, __pyx_v_typeoid); + __Pyx_GIVEREF(__pyx_t_6); + PyTuple_SET_ITEM(__pyx_t_8, 1, __pyx_t_6); + __pyx_t_6 = 0; + if (unlikely(PyDict_SetItem(__pyx_v_self->_local_type_codecs, __pyx_t_8, __pyx_t_4) < 0)) __PYX_ERR(2, 481, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + + /* "asyncpg/protocol/codecs/base.pyx":473 + * UNKNOWNOID) + * + * def add_python_codec(self, typeoid, typename, typeschema, typekind, # <<<<<<<<<<<<<< + * encoder, decoder, binary): + * format = PG_FORMAT_BINARY if binary else PG_FORMAT_TEXT + */ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_4); + __Pyx_XDECREF(__pyx_t_6); + __Pyx_XDECREF(__pyx_t_7); + __Pyx_XDECREF(__pyx_t_8); + __Pyx_AddTraceback("asyncpg.protocol.protocol.DataCodecConfig.add_python_codec", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "asyncpg/protocol/codecs/base.pyx":485 + * encoder, decoder, format) + * + * def set_builtin_type_codec(self, typeoid, typename, typeschema, typekind, # <<<<<<<<<<<<<< + * alias_to): + * cdef: + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_7asyncpg_8protocol_8protocol_15DataCodecConfig_7set_builtin_type_codec(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ +static PyObject *__pyx_pw_7asyncpg_8protocol_8protocol_15DataCodecConfig_7set_builtin_type_codec(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { + PyObject *__pyx_v_typeoid = 0; + PyObject *__pyx_v_typename = 0; + PyObject *__pyx_v_typeschema = 0; + PyObject *__pyx_v_typekind = 0; + PyObject *__pyx_v_alias_to = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("set_builtin_type_codec (wrapper)", 0); + { + static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_typeoid,&__pyx_n_s_typename,&__pyx_n_s_typeschema,&__pyx_n_s_typekind,&__pyx_n_s_alias_to,0}; + PyObject* values[5] = {0,0,0,0,0}; + if (unlikely(__pyx_kwds)) { + Py_ssize_t kw_args; + const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args); + switch (pos_args) { + case 5: values[4] = PyTuple_GET_ITEM(__pyx_args, 4); + case 4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3); + case 3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2); + case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); + case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = PyDict_Size(__pyx_kwds); + switch (pos_args) { + case 0: + if (likely((values[0] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_typeoid)) != 0)) kw_args--; + else goto __pyx_L5_argtuple_error; + case 1: + if (likely((values[1] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_typename)) != 0)) kw_args--; + else { + __Pyx_RaiseArgtupleInvalid("set_builtin_type_codec", 1, 5, 5, 1); __PYX_ERR(2, 485, __pyx_L3_error) + } + case 2: + if (likely((values[2] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_typeschema)) != 0)) kw_args--; + else { + __Pyx_RaiseArgtupleInvalid("set_builtin_type_codec", 1, 5, 5, 2); __PYX_ERR(2, 485, __pyx_L3_error) + } + case 3: + if (likely((values[3] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_typekind)) != 0)) kw_args--; + else { + __Pyx_RaiseArgtupleInvalid("set_builtin_type_codec", 1, 5, 5, 3); __PYX_ERR(2, 485, __pyx_L3_error) + } + case 4: + if (likely((values[4] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_alias_to)) != 0)) kw_args--; + else { + __Pyx_RaiseArgtupleInvalid("set_builtin_type_codec", 1, 5, 5, 4); __PYX_ERR(2, 485, __pyx_L3_error) + } + } + if (unlikely(kw_args > 0)) { + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "set_builtin_type_codec") < 0)) __PYX_ERR(2, 485, __pyx_L3_error) + } + } else if (PyTuple_GET_SIZE(__pyx_args) != 5) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + values[1] = PyTuple_GET_ITEM(__pyx_args, 1); + values[2] = PyTuple_GET_ITEM(__pyx_args, 2); + values[3] = PyTuple_GET_ITEM(__pyx_args, 3); + values[4] = PyTuple_GET_ITEM(__pyx_args, 4); + } + __pyx_v_typeoid = values[0]; + __pyx_v_typename = values[1]; + __pyx_v_typeschema = values[2]; + __pyx_v_typekind = values[3]; + __pyx_v_alias_to = values[4]; + } + goto __pyx_L4_argument_unpacking_done; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("set_builtin_type_codec", 1, 5, 5, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(2, 485, __pyx_L3_error) + __pyx_L3_error:; + __Pyx_AddTraceback("asyncpg.protocol.protocol.DataCodecConfig.set_builtin_type_codec", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_7asyncpg_8protocol_8protocol_15DataCodecConfig_6set_builtin_type_codec(((struct __pyx_obj_7asyncpg_8protocol_8protocol_DataCodecConfig *)__pyx_v_self), __pyx_v_typeoid, __pyx_v_typename, __pyx_v_typeschema, __pyx_v_typekind, __pyx_v_alias_to); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_7asyncpg_8protocol_8protocol_15DataCodecConfig_6set_builtin_type_codec(struct __pyx_obj_7asyncpg_8protocol_8protocol_DataCodecConfig *__pyx_v_self, PyObject *__pyx_v_typeoid, PyObject *__pyx_v_typename, PyObject *__pyx_v_typeschema, PyObject *__pyx_v_typekind, PyObject *__pyx_v_alias_to) { + struct __pyx_obj_7asyncpg_8protocol_8protocol_Codec *__pyx_v_codec = 0; + struct __pyx_obj_7asyncpg_8protocol_8protocol_Codec *__pyx_v_target_codec = 0; + PyObject *__pyx_v_format = NULL; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + Py_ssize_t __pyx_t_4; + uint32_t __pyx_t_5; + enum __pyx_t_7asyncpg_8protocol_8protocol_CodecFormat __pyx_t_6; + int __pyx_t_7; + int __pyx_t_8; + PyObject *__pyx_t_9 = NULL; + PyObject *__pyx_t_10 = NULL; + int __pyx_t_11; + __Pyx_RefNannySetupContext("set_builtin_type_codec", 0); + + /* "asyncpg/protocol/codecs/base.pyx":491 + * Codec target_codec + * + * for format in (PG_FORMAT_BINARY, PG_FORMAT_TEXT): # <<<<<<<<<<<<<< + * if self.get_codec(typeoid, format) is not None: + * raise ValueError('cannot override codec for type {}'.format( + */ + __pyx_t_1 = __Pyx_PyInt_From_enum____pyx_t_7asyncpg_8protocol_8protocol_CodecFormat(__pyx_e_7asyncpg_8protocol_8protocol_PG_FORMAT_BINARY); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 491, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = __Pyx_PyInt_From_enum____pyx_t_7asyncpg_8protocol_8protocol_CodecFormat(__pyx_e_7asyncpg_8protocol_8protocol_PG_FORMAT_TEXT); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 491, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = PyTuple_New(2); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 491, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_GIVEREF(__pyx_t_1); + PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_t_1); + __Pyx_GIVEREF(__pyx_t_2); + PyTuple_SET_ITEM(__pyx_t_3, 1, __pyx_t_2); + __pyx_t_1 = 0; + __pyx_t_2 = 0; + __pyx_t_2 = __pyx_t_3; __Pyx_INCREF(__pyx_t_2); __pyx_t_4 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + for (;;) { + if (__pyx_t_4 >= 2) break; + #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + __pyx_t_3 = PyTuple_GET_ITEM(__pyx_t_2, __pyx_t_4); __Pyx_INCREF(__pyx_t_3); __pyx_t_4++; if (unlikely(0 < 0)) __PYX_ERR(2, 491, __pyx_L1_error) + #else + __pyx_t_3 = PySequence_ITEM(__pyx_t_2, __pyx_t_4); __pyx_t_4++; if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 491, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + #endif + __Pyx_XDECREF_SET(__pyx_v_format, __pyx_t_3); + __pyx_t_3 = 0; + + /* "asyncpg/protocol/codecs/base.pyx":492 + * + * for format in (PG_FORMAT_BINARY, PG_FORMAT_TEXT): + * if self.get_codec(typeoid, format) is not None: # <<<<<<<<<<<<<< + * raise ValueError('cannot override codec for type {}'.format( + * typeoid)) + */ + __pyx_t_5 = __Pyx_PyInt_As_uint32_t(__pyx_v_typeoid); if (unlikely((__pyx_t_5 == ((uint32_t)-1)) && PyErr_Occurred())) __PYX_ERR(2, 492, __pyx_L1_error) + __pyx_t_6 = ((enum __pyx_t_7asyncpg_8protocol_8protocol_CodecFormat)__Pyx_PyInt_As_enum____pyx_t_7asyncpg_8protocol_8protocol_CodecFormat(__pyx_v_format)); if (unlikely(PyErr_Occurred())) __PYX_ERR(2, 492, __pyx_L1_error) + __pyx_t_3 = ((PyObject *)__pyx_f_7asyncpg_8protocol_8protocol_15DataCodecConfig_get_codec(__pyx_v_self, __pyx_t_5, __pyx_t_6)); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 492, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_7 = (__pyx_t_3 != Py_None); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_8 = (__pyx_t_7 != 0); + if (__pyx_t_8) { + + /* "asyncpg/protocol/codecs/base.pyx":493 + * for format in (PG_FORMAT_BINARY, PG_FORMAT_TEXT): + * if self.get_codec(typeoid, format) is not None: + * raise ValueError('cannot override codec for type {}'.format( # <<<<<<<<<<<<<< + * typeoid)) + * + */ + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_kp_u_cannot_override_codec_for_type, __pyx_n_s_format); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 493, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + + /* "asyncpg/protocol/codecs/base.pyx":494 + * if self.get_codec(typeoid, format) is not None: + * raise ValueError('cannot override codec for type {}'.format( + * typeoid)) # <<<<<<<<<<<<<< + * + * if isinstance(alias_to, int): + */ + __pyx_t_9 = NULL; + if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_1))) { + __pyx_t_9 = PyMethod_GET_SELF(__pyx_t_1); + if (likely(__pyx_t_9)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_1); + __Pyx_INCREF(__pyx_t_9); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_1, function); + } + } + if (!__pyx_t_9) { + __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_t_1, __pyx_v_typeoid); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 493, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + } else { + #if CYTHON_FAST_PYCALL + if (PyFunction_Check(__pyx_t_1)) { + PyObject *__pyx_temp[2] = {__pyx_t_9, __pyx_v_typeoid}; + __pyx_t_3 = __Pyx_PyFunction_FastCall(__pyx_t_1, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 493, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0; + __Pyx_GOTREF(__pyx_t_3); + } else + #endif + #if CYTHON_FAST_PYCCALL + if (__Pyx_PyFastCFunction_Check(__pyx_t_1)) { + PyObject *__pyx_temp[2] = {__pyx_t_9, __pyx_v_typeoid}; + __pyx_t_3 = __Pyx_PyCFunction_FastCall(__pyx_t_1, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 493, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0; + __Pyx_GOTREF(__pyx_t_3); + } else + #endif + { + __pyx_t_10 = PyTuple_New(1+1); if (unlikely(!__pyx_t_10)) __PYX_ERR(2, 493, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_10); + __Pyx_GIVEREF(__pyx_t_9); PyTuple_SET_ITEM(__pyx_t_10, 0, __pyx_t_9); __pyx_t_9 = NULL; + __Pyx_INCREF(__pyx_v_typeoid); + __Pyx_GIVEREF(__pyx_v_typeoid); + PyTuple_SET_ITEM(__pyx_t_10, 0+1, __pyx_v_typeoid); + __pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_t_10, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 493, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; + } + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "asyncpg/protocol/codecs/base.pyx":493 + * for format in (PG_FORMAT_BINARY, PG_FORMAT_TEXT): + * if self.get_codec(typeoid, format) is not None: + * raise ValueError('cannot override codec for type {}'.format( # <<<<<<<<<<<<<< + * typeoid)) + * + */ + __pyx_t_1 = PyTuple_New(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 493, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_GIVEREF(__pyx_t_3); + PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_t_3); + __pyx_t_3 = 0; + __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_t_1, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 493, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_Raise(__pyx_t_3, 0, 0, 0); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __PYX_ERR(2, 493, __pyx_L1_error) + + /* "asyncpg/protocol/codecs/base.pyx":492 + * + * for format in (PG_FORMAT_BINARY, PG_FORMAT_TEXT): + * if self.get_codec(typeoid, format) is not None: # <<<<<<<<<<<<<< + * raise ValueError('cannot override codec for type {}'.format( + * typeoid)) + */ + } + + /* "asyncpg/protocol/codecs/base.pyx":496 + * typeoid)) + * + * if isinstance(alias_to, int): # <<<<<<<<<<<<<< + * target_codec = self.get_codec(alias_to, format) + * else: + */ + __pyx_t_8 = PyInt_Check(__pyx_v_alias_to); + __pyx_t_7 = (__pyx_t_8 != 0); + if (__pyx_t_7) { + + /* "asyncpg/protocol/codecs/base.pyx":497 + * + * if isinstance(alias_to, int): + * target_codec = self.get_codec(alias_to, format) # <<<<<<<<<<<<<< + * else: + * target_codec = get_extra_codec(alias_to, format) + */ + __pyx_t_5 = __Pyx_PyInt_As_uint32_t(__pyx_v_alias_to); if (unlikely((__pyx_t_5 == ((uint32_t)-1)) && PyErr_Occurred())) __PYX_ERR(2, 497, __pyx_L1_error) + __pyx_t_6 = ((enum __pyx_t_7asyncpg_8protocol_8protocol_CodecFormat)__Pyx_PyInt_As_enum____pyx_t_7asyncpg_8protocol_8protocol_CodecFormat(__pyx_v_format)); if (unlikely(PyErr_Occurred())) __PYX_ERR(2, 497, __pyx_L1_error) + __pyx_t_3 = ((PyObject *)__pyx_f_7asyncpg_8protocol_8protocol_15DataCodecConfig_get_codec(__pyx_v_self, __pyx_t_5, __pyx_t_6)); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 497, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_XDECREF_SET(__pyx_v_target_codec, ((struct __pyx_obj_7asyncpg_8protocol_8protocol_Codec *)__pyx_t_3)); + __pyx_t_3 = 0; + + /* "asyncpg/protocol/codecs/base.pyx":496 + * typeoid)) + * + * if isinstance(alias_to, int): # <<<<<<<<<<<<<< + * target_codec = self.get_codec(alias_to, format) + * else: + */ + goto __pyx_L6; + } + + /* "asyncpg/protocol/codecs/base.pyx":499 + * target_codec = self.get_codec(alias_to, format) + * else: + * target_codec = get_extra_codec(alias_to, format) # <<<<<<<<<<<<<< + * + * if target_codec is None: + */ + /*else*/ { + if (!(likely(PyUnicode_CheckExact(__pyx_v_alias_to))||((__pyx_v_alias_to) == Py_None)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "unicode", Py_TYPE(__pyx_v_alias_to)->tp_name), 0))) __PYX_ERR(2, 499, __pyx_L1_error) + __pyx_t_6 = ((enum __pyx_t_7asyncpg_8protocol_8protocol_CodecFormat)__Pyx_PyInt_As_enum____pyx_t_7asyncpg_8protocol_8protocol_CodecFormat(__pyx_v_format)); if (unlikely(PyErr_Occurred())) __PYX_ERR(2, 499, __pyx_L1_error) + __pyx_t_3 = ((PyObject *)__pyx_f_7asyncpg_8protocol_8protocol_get_extra_codec(((PyObject*)__pyx_v_alias_to), __pyx_t_6)); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 499, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_XDECREF_SET(__pyx_v_target_codec, ((struct __pyx_obj_7asyncpg_8protocol_8protocol_Codec *)__pyx_t_3)); + __pyx_t_3 = 0; + } + __pyx_L6:; + + /* "asyncpg/protocol/codecs/base.pyx":501 + * target_codec = get_extra_codec(alias_to, format) + * + * if target_codec is None: # <<<<<<<<<<<<<< + * continue + * + */ + __pyx_t_7 = (((PyObject *)__pyx_v_target_codec) == Py_None); + __pyx_t_8 = (__pyx_t_7 != 0); + if (__pyx_t_8) { + + /* "asyncpg/protocol/codecs/base.pyx":502 + * + * if target_codec is None: + * continue # <<<<<<<<<<<<<< + * + * codec = target_codec.copy() + */ + goto __pyx_L3_continue; + + /* "asyncpg/protocol/codecs/base.pyx":501 + * target_codec = get_extra_codec(alias_to, format) + * + * if target_codec is None: # <<<<<<<<<<<<<< + * continue + * + */ + } + + /* "asyncpg/protocol/codecs/base.pyx":504 + * continue + * + * codec = target_codec.copy() # <<<<<<<<<<<<<< + * codec.oid = typeoid + * codec.name = typename + */ + __pyx_t_3 = ((PyObject *)__pyx_f_7asyncpg_8protocol_8protocol_5Codec_copy(__pyx_v_target_codec)); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 504, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_XDECREF_SET(__pyx_v_codec, ((struct __pyx_obj_7asyncpg_8protocol_8protocol_Codec *)__pyx_t_3)); + __pyx_t_3 = 0; + + /* "asyncpg/protocol/codecs/base.pyx":505 + * + * codec = target_codec.copy() + * codec.oid = typeoid # <<<<<<<<<<<<<< + * codec.name = typename + * codec.schema = typeschema + */ + __pyx_t_5 = __Pyx_PyInt_As_uint32_t(__pyx_v_typeoid); if (unlikely((__pyx_t_5 == ((uint32_t)-1)) && PyErr_Occurred())) __PYX_ERR(2, 505, __pyx_L1_error) + __pyx_v_codec->oid = __pyx_t_5; + + /* "asyncpg/protocol/codecs/base.pyx":506 + * codec = target_codec.copy() + * codec.oid = typeoid + * codec.name = typename # <<<<<<<<<<<<<< + * codec.schema = typeschema + * codec.kind = typekind + */ + if (!(likely(PyUnicode_CheckExact(__pyx_v_typename))||((__pyx_v_typename) == Py_None)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "unicode", Py_TYPE(__pyx_v_typename)->tp_name), 0))) __PYX_ERR(2, 506, __pyx_L1_error) + __pyx_t_3 = __pyx_v_typename; + __Pyx_INCREF(__pyx_t_3); + __Pyx_GIVEREF(__pyx_t_3); + __Pyx_GOTREF(__pyx_v_codec->name); + __Pyx_DECREF(__pyx_v_codec->name); + __pyx_v_codec->name = ((PyObject*)__pyx_t_3); + __pyx_t_3 = 0; + + /* "asyncpg/protocol/codecs/base.pyx":507 + * codec.oid = typeoid + * codec.name = typename + * codec.schema = typeschema # <<<<<<<<<<<<<< + * codec.kind = typekind + * + */ + if (!(likely(PyUnicode_CheckExact(__pyx_v_typeschema))||((__pyx_v_typeschema) == Py_None)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "unicode", Py_TYPE(__pyx_v_typeschema)->tp_name), 0))) __PYX_ERR(2, 507, __pyx_L1_error) + __pyx_t_3 = __pyx_v_typeschema; + __Pyx_INCREF(__pyx_t_3); + __Pyx_GIVEREF(__pyx_t_3); + __Pyx_GOTREF(__pyx_v_codec->schema); + __Pyx_DECREF(__pyx_v_codec->schema); + __pyx_v_codec->schema = ((PyObject*)__pyx_t_3); + __pyx_t_3 = 0; + + /* "asyncpg/protocol/codecs/base.pyx":508 + * codec.name = typename + * codec.schema = typeschema + * codec.kind = typekind # <<<<<<<<<<<<<< + * + * self._local_type_codecs[typeoid, format] = codec + */ + if (!(likely(PyUnicode_CheckExact(__pyx_v_typekind))||((__pyx_v_typekind) == Py_None)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "unicode", Py_TYPE(__pyx_v_typekind)->tp_name), 0))) __PYX_ERR(2, 508, __pyx_L1_error) + __pyx_t_3 = __pyx_v_typekind; + __Pyx_INCREF(__pyx_t_3); + __Pyx_GIVEREF(__pyx_t_3); + __Pyx_GOTREF(__pyx_v_codec->kind); + __Pyx_DECREF(__pyx_v_codec->kind); + __pyx_v_codec->kind = ((PyObject*)__pyx_t_3); + __pyx_t_3 = 0; + + /* "asyncpg/protocol/codecs/base.pyx":510 + * codec.kind = typekind + * + * self._local_type_codecs[typeoid, format] = codec # <<<<<<<<<<<<<< + * + * if ((typeoid, PG_FORMAT_BINARY) not in self._local_type_codecs and + */ + if (unlikely(__pyx_v_self->_local_type_codecs == Py_None)) { + PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable"); + __PYX_ERR(2, 510, __pyx_L1_error) + } + __pyx_t_3 = PyTuple_New(2); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 510, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_INCREF(__pyx_v_typeoid); + __Pyx_GIVEREF(__pyx_v_typeoid); + PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_v_typeoid); + __Pyx_INCREF(__pyx_v_format); + __Pyx_GIVEREF(__pyx_v_format); + PyTuple_SET_ITEM(__pyx_t_3, 1, __pyx_v_format); + if (unlikely(PyDict_SetItem(__pyx_v_self->_local_type_codecs, __pyx_t_3, ((PyObject *)__pyx_v_codec)) < 0)) __PYX_ERR(2, 510, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + + /* "asyncpg/protocol/codecs/base.pyx":491 + * Codec target_codec + * + * for format in (PG_FORMAT_BINARY, PG_FORMAT_TEXT): # <<<<<<<<<<<<<< + * if self.get_codec(typeoid, format) is not None: + * raise ValueError('cannot override codec for type {}'.format( + */ + __pyx_L3_continue:; + } + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "asyncpg/protocol/codecs/base.pyx":512 + * self._local_type_codecs[typeoid, format] = codec + * + * if ((typeoid, PG_FORMAT_BINARY) not in self._local_type_codecs and # <<<<<<<<<<<<<< + * (typeoid, PG_FORMAT_TEXT) not in self._local_type_codecs): + * raise ValueError('unknown alias target: {}'.format(alias_to)) + */ + __pyx_t_2 = __Pyx_PyInt_From_enum____pyx_t_7asyncpg_8protocol_8protocol_CodecFormat(__pyx_e_7asyncpg_8protocol_8protocol_PG_FORMAT_BINARY); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 512, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = PyTuple_New(2); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 512, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_INCREF(__pyx_v_typeoid); + __Pyx_GIVEREF(__pyx_v_typeoid); + PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_v_typeoid); + __Pyx_GIVEREF(__pyx_t_2); + PyTuple_SET_ITEM(__pyx_t_3, 1, __pyx_t_2); + __pyx_t_2 = 0; + if (unlikely(__pyx_v_self->_local_type_codecs == Py_None)) { + PyErr_SetString(PyExc_TypeError, "'NoneType' object is not iterable"); + __PYX_ERR(2, 512, __pyx_L1_error) + } + __pyx_t_7 = (__Pyx_PyDict_ContainsTF(__pyx_t_3, __pyx_v_self->_local_type_codecs, Py_NE)); if (unlikely(__pyx_t_7 < 0)) __PYX_ERR(2, 512, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_11 = (__pyx_t_7 != 0); + if (__pyx_t_11) { + } else { + __pyx_t_8 = __pyx_t_11; + goto __pyx_L9_bool_binop_done; + } + + /* "asyncpg/protocol/codecs/base.pyx":513 + * + * if ((typeoid, PG_FORMAT_BINARY) not in self._local_type_codecs and + * (typeoid, PG_FORMAT_TEXT) not in self._local_type_codecs): # <<<<<<<<<<<<<< + * raise ValueError('unknown alias target: {}'.format(alias_to)) + * + */ + __pyx_t_3 = __Pyx_PyInt_From_enum____pyx_t_7asyncpg_8protocol_8protocol_CodecFormat(__pyx_e_7asyncpg_8protocol_8protocol_PG_FORMAT_TEXT); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 513, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_2 = PyTuple_New(2); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 513, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_INCREF(__pyx_v_typeoid); + __Pyx_GIVEREF(__pyx_v_typeoid); + PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_v_typeoid); + __Pyx_GIVEREF(__pyx_t_3); + PyTuple_SET_ITEM(__pyx_t_2, 1, __pyx_t_3); + __pyx_t_3 = 0; + if (unlikely(__pyx_v_self->_local_type_codecs == Py_None)) { + PyErr_SetString(PyExc_TypeError, "'NoneType' object is not iterable"); + __PYX_ERR(2, 513, __pyx_L1_error) + } + __pyx_t_11 = (__Pyx_PyDict_ContainsTF(__pyx_t_2, __pyx_v_self->_local_type_codecs, Py_NE)); if (unlikely(__pyx_t_11 < 0)) __PYX_ERR(2, 513, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_7 = (__pyx_t_11 != 0); + __pyx_t_8 = __pyx_t_7; + __pyx_L9_bool_binop_done:; + + /* "asyncpg/protocol/codecs/base.pyx":512 + * self._local_type_codecs[typeoid, format] = codec + * + * if ((typeoid, PG_FORMAT_BINARY) not in self._local_type_codecs and # <<<<<<<<<<<<<< + * (typeoid, PG_FORMAT_TEXT) not in self._local_type_codecs): + * raise ValueError('unknown alias target: {}'.format(alias_to)) + */ + if (__pyx_t_8) { + + /* "asyncpg/protocol/codecs/base.pyx":514 + * if ((typeoid, PG_FORMAT_BINARY) not in self._local_type_codecs and + * (typeoid, PG_FORMAT_TEXT) not in self._local_type_codecs): + * raise ValueError('unknown alias target: {}'.format(alias_to)) # <<<<<<<<<<<<<< + * + * def clear_type_cache(self): + */ + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_kp_u_unknown_alias_target, __pyx_n_s_format); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 514, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_1 = NULL; + if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_3))) { + __pyx_t_1 = PyMethod_GET_SELF(__pyx_t_3); + if (likely(__pyx_t_1)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); + __Pyx_INCREF(__pyx_t_1); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_3, function); + } + } + if (!__pyx_t_1) { + __pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_v_alias_to); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 514, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + } else { + #if CYTHON_FAST_PYCALL + if (PyFunction_Check(__pyx_t_3)) { + PyObject *__pyx_temp[2] = {__pyx_t_1, __pyx_v_alias_to}; + __pyx_t_2 = __Pyx_PyFunction_FastCall(__pyx_t_3, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 514, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_GOTREF(__pyx_t_2); + } else + #endif + #if CYTHON_FAST_PYCCALL + if (__Pyx_PyFastCFunction_Check(__pyx_t_3)) { + PyObject *__pyx_temp[2] = {__pyx_t_1, __pyx_v_alias_to}; + __pyx_t_2 = __Pyx_PyCFunction_FastCall(__pyx_t_3, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 514, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_GOTREF(__pyx_t_2); + } else + #endif + { + __pyx_t_10 = PyTuple_New(1+1); if (unlikely(!__pyx_t_10)) __PYX_ERR(2, 514, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_10); + __Pyx_GIVEREF(__pyx_t_1); PyTuple_SET_ITEM(__pyx_t_10, 0, __pyx_t_1); __pyx_t_1 = NULL; + __Pyx_INCREF(__pyx_v_alias_to); + __Pyx_GIVEREF(__pyx_v_alias_to); + PyTuple_SET_ITEM(__pyx_t_10, 0+1, __pyx_v_alias_to); + __pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_t_10, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 514, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; + } + } + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_3 = PyTuple_New(1); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 514, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_GIVEREF(__pyx_t_2); + PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_t_2); + __pyx_t_2 = 0; + __pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_t_3, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 514, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_Raise(__pyx_t_2, 0, 0, 0); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __PYX_ERR(2, 514, __pyx_L1_error) + + /* "asyncpg/protocol/codecs/base.pyx":512 + * self._local_type_codecs[typeoid, format] = codec + * + * if ((typeoid, PG_FORMAT_BINARY) not in self._local_type_codecs and # <<<<<<<<<<<<<< + * (typeoid, PG_FORMAT_TEXT) not in self._local_type_codecs): + * raise ValueError('unknown alias target: {}'.format(alias_to)) + */ + } + + /* "asyncpg/protocol/codecs/base.pyx":485 + * encoder, decoder, format) + * + * def set_builtin_type_codec(self, typeoid, typename, typeschema, typekind, # <<<<<<<<<<<<<< + * alias_to): + * cdef: + */ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_9); + __Pyx_XDECREF(__pyx_t_10); + __Pyx_AddTraceback("asyncpg.protocol.protocol.DataCodecConfig.set_builtin_type_codec", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XDECREF((PyObject *)__pyx_v_codec); + __Pyx_XDECREF((PyObject *)__pyx_v_target_codec); + __Pyx_XDECREF(__pyx_v_format); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "asyncpg/protocol/codecs/base.pyx":516 + * raise ValueError('unknown alias target: {}'.format(alias_to)) + * + * def clear_type_cache(self): # <<<<<<<<<<<<<< + * self._type_codecs_cache.clear() + * + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_7asyncpg_8protocol_8protocol_15DataCodecConfig_9clear_type_cache(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/ +static PyObject *__pyx_pw_7asyncpg_8protocol_8protocol_15DataCodecConfig_9clear_type_cache(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("clear_type_cache (wrapper)", 0); + __pyx_r = __pyx_pf_7asyncpg_8protocol_8protocol_15DataCodecConfig_8clear_type_cache(((struct __pyx_obj_7asyncpg_8protocol_8protocol_DataCodecConfig *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_7asyncpg_8protocol_8protocol_15DataCodecConfig_8clear_type_cache(struct __pyx_obj_7asyncpg_8protocol_8protocol_DataCodecConfig *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + __Pyx_RefNannySetupContext("clear_type_cache", 0); + + /* "asyncpg/protocol/codecs/base.pyx":517 + * + * def clear_type_cache(self): + * self._type_codecs_cache.clear() # <<<<<<<<<<<<<< + * + * cdef inline Codec get_codec(self, uint32_t oid, CodecFormat format): + */ + if (unlikely(__pyx_v_self->_type_codecs_cache == Py_None)) { + PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%s'", "clear"); + __PYX_ERR(2, 517, __pyx_L1_error) + } + __pyx_t_1 = __Pyx_PyDict_Clear(__pyx_v_self->_type_codecs_cache); if (unlikely(__pyx_t_1 == -1)) __PYX_ERR(2, 517, __pyx_L1_error) + + /* "asyncpg/protocol/codecs/base.pyx":516 + * raise ValueError('unknown alias target: {}'.format(alias_to)) + * + * def clear_type_cache(self): # <<<<<<<<<<<<<< + * self._type_codecs_cache.clear() + * + */ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_AddTraceback("asyncpg.protocol.protocol.DataCodecConfig.clear_type_cache", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "asyncpg/protocol/codecs/base.pyx":519 + * self._type_codecs_cache.clear() + * + * cdef inline Codec get_codec(self, uint32_t oid, CodecFormat format): # <<<<<<<<<<<<<< + * cdef Codec codec + * + */ + +static CYTHON_INLINE struct __pyx_obj_7asyncpg_8protocol_8protocol_Codec *__pyx_f_7asyncpg_8protocol_8protocol_15DataCodecConfig_get_codec(struct __pyx_obj_7asyncpg_8protocol_8protocol_DataCodecConfig *__pyx_v_self, uint32_t __pyx_v_oid, enum __pyx_t_7asyncpg_8protocol_8protocol_CodecFormat __pyx_v_format) { + struct __pyx_obj_7asyncpg_8protocol_8protocol_Codec *__pyx_v_codec = 0; + struct __pyx_obj_7asyncpg_8protocol_8protocol_Codec *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_t_2; + int __pyx_t_3; + PyObject *__pyx_t_4 = NULL; + PyObject *__pyx_t_5 = NULL; + PyObject *__pyx_t_6 = NULL; + PyObject *__pyx_t_7 = NULL; + PyObject *__pyx_t_8 = NULL; + int __pyx_t_9; + PyObject *__pyx_t_10 = NULL; + PyObject *__pyx_t_11 = NULL; + PyObject *__pyx_t_12 = NULL; + PyObject *__pyx_t_13 = NULL; + PyObject *__pyx_t_14 = NULL; + PyObject *__pyx_t_15 = NULL; + __Pyx_RefNannySetupContext("get_codec", 0); + + /* "asyncpg/protocol/codecs/base.pyx":522 + * cdef Codec codec + * + * codec = get_core_codec(oid, format) # <<<<<<<<<<<<<< + * if codec is not None: + * return codec + */ + __pyx_t_1 = ((PyObject *)__pyx_f_7asyncpg_8protocol_8protocol_get_core_codec(__pyx_v_oid, __pyx_v_format)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 522, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_v_codec = ((struct __pyx_obj_7asyncpg_8protocol_8protocol_Codec *)__pyx_t_1); + __pyx_t_1 = 0; + + /* "asyncpg/protocol/codecs/base.pyx":523 + * + * codec = get_core_codec(oid, format) + * if codec is not None: # <<<<<<<<<<<<<< + * return codec + * + */ + __pyx_t_2 = (((PyObject *)__pyx_v_codec) != Py_None); + __pyx_t_3 = (__pyx_t_2 != 0); + if (__pyx_t_3) { + + /* "asyncpg/protocol/codecs/base.pyx":524 + * codec = get_core_codec(oid, format) + * if codec is not None: + * return codec # <<<<<<<<<<<<<< + * + * try: + */ + __Pyx_XDECREF(((PyObject *)__pyx_r)); + __Pyx_INCREF(((PyObject *)__pyx_v_codec)); + __pyx_r = __pyx_v_codec; + goto __pyx_L0; + + /* "asyncpg/protocol/codecs/base.pyx":523 + * + * codec = get_core_codec(oid, format) + * if codec is not None: # <<<<<<<<<<<<<< + * return codec + * + */ + } + + /* "asyncpg/protocol/codecs/base.pyx":526 + * return codec + * + * try: # <<<<<<<<<<<<<< + * return self._type_codecs_cache[oid, format] + * except KeyError: + */ + { + __Pyx_PyThreadState_declare + __Pyx_PyThreadState_assign + __Pyx_ExceptionSave(&__pyx_t_4, &__pyx_t_5, &__pyx_t_6); + __Pyx_XGOTREF(__pyx_t_4); + __Pyx_XGOTREF(__pyx_t_5); + __Pyx_XGOTREF(__pyx_t_6); + /*try:*/ { + + /* "asyncpg/protocol/codecs/base.pyx":527 + * + * try: + * return self._type_codecs_cache[oid, format] # <<<<<<<<<<<<<< + * except KeyError: + * try: + */ + __Pyx_XDECREF(((PyObject *)__pyx_r)); + if (unlikely(__pyx_v_self->_type_codecs_cache == Py_None)) { + PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable"); + __PYX_ERR(2, 527, __pyx_L4_error) + } + __pyx_t_1 = __Pyx_PyInt_From_uint32_t(__pyx_v_oid); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 527, __pyx_L4_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_7 = __Pyx_PyInt_From_enum____pyx_t_7asyncpg_8protocol_8protocol_CodecFormat(__pyx_v_format); if (unlikely(!__pyx_t_7)) __PYX_ERR(2, 527, __pyx_L4_error) + __Pyx_GOTREF(__pyx_t_7); + __pyx_t_8 = PyTuple_New(2); if (unlikely(!__pyx_t_8)) __PYX_ERR(2, 527, __pyx_L4_error) + __Pyx_GOTREF(__pyx_t_8); + __Pyx_GIVEREF(__pyx_t_1); + PyTuple_SET_ITEM(__pyx_t_8, 0, __pyx_t_1); + __Pyx_GIVEREF(__pyx_t_7); + PyTuple_SET_ITEM(__pyx_t_8, 1, __pyx_t_7); + __pyx_t_1 = 0; + __pyx_t_7 = 0; + __pyx_t_7 = __Pyx_PyDict_GetItem(__pyx_v_self->_type_codecs_cache, __pyx_t_8); if (unlikely(!__pyx_t_7)) __PYX_ERR(2, 527, __pyx_L4_error) + __Pyx_GOTREF(__pyx_t_7); + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + if (!(likely(((__pyx_t_7) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_7, __pyx_ptype_7asyncpg_8protocol_8protocol_Codec))))) __PYX_ERR(2, 527, __pyx_L4_error) + __pyx_r = ((struct __pyx_obj_7asyncpg_8protocol_8protocol_Codec *)__pyx_t_7); + __pyx_t_7 = 0; + goto __pyx_L8_try_return; + + /* "asyncpg/protocol/codecs/base.pyx":526 + * return codec + * + * try: # <<<<<<<<<<<<<< + * return self._type_codecs_cache[oid, format] + * except KeyError: + */ + } + __pyx_L4_error:; + __Pyx_PyThreadState_assign + __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; + __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; + + /* "asyncpg/protocol/codecs/base.pyx":528 + * try: + * return self._type_codecs_cache[oid, format] + * except KeyError: # <<<<<<<<<<<<<< + * try: + * return self._local_type_codecs[oid, format] + */ + __pyx_t_9 = __Pyx_PyErr_ExceptionMatches(__pyx_builtin_KeyError); + if (__pyx_t_9) { + __Pyx_AddTraceback("asyncpg.protocol.protocol.DataCodecConfig.get_codec", __pyx_clineno, __pyx_lineno, __pyx_filename); + if (__Pyx_GetException(&__pyx_t_7, &__pyx_t_8, &__pyx_t_1) < 0) __PYX_ERR(2, 528, __pyx_L6_except_error) + __Pyx_GOTREF(__pyx_t_7); + __Pyx_GOTREF(__pyx_t_8); + __Pyx_GOTREF(__pyx_t_1); + + /* "asyncpg/protocol/codecs/base.pyx":529 + * return self._type_codecs_cache[oid, format] + * except KeyError: + * try: # <<<<<<<<<<<<<< + * return self._local_type_codecs[oid, format] + * except KeyError: + */ + { + __Pyx_PyThreadState_declare + __Pyx_PyThreadState_assign + __Pyx_ExceptionSave(&__pyx_t_10, &__pyx_t_11, &__pyx_t_12); + __Pyx_XGOTREF(__pyx_t_10); + __Pyx_XGOTREF(__pyx_t_11); + __Pyx_XGOTREF(__pyx_t_12); + /*try:*/ { + + /* "asyncpg/protocol/codecs/base.pyx":530 + * except KeyError: + * try: + * return self._local_type_codecs[oid, format] # <<<<<<<<<<<<<< + * except KeyError: + * return None + */ + __Pyx_XDECREF(((PyObject *)__pyx_r)); + if (unlikely(__pyx_v_self->_local_type_codecs == Py_None)) { + PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable"); + __PYX_ERR(2, 530, __pyx_L14_error) + } + __pyx_t_13 = __Pyx_PyInt_From_uint32_t(__pyx_v_oid); if (unlikely(!__pyx_t_13)) __PYX_ERR(2, 530, __pyx_L14_error) + __Pyx_GOTREF(__pyx_t_13); + __pyx_t_14 = __Pyx_PyInt_From_enum____pyx_t_7asyncpg_8protocol_8protocol_CodecFormat(__pyx_v_format); if (unlikely(!__pyx_t_14)) __PYX_ERR(2, 530, __pyx_L14_error) + __Pyx_GOTREF(__pyx_t_14); + __pyx_t_15 = PyTuple_New(2); if (unlikely(!__pyx_t_15)) __PYX_ERR(2, 530, __pyx_L14_error) + __Pyx_GOTREF(__pyx_t_15); + __Pyx_GIVEREF(__pyx_t_13); + PyTuple_SET_ITEM(__pyx_t_15, 0, __pyx_t_13); + __Pyx_GIVEREF(__pyx_t_14); + PyTuple_SET_ITEM(__pyx_t_15, 1, __pyx_t_14); + __pyx_t_13 = 0; + __pyx_t_14 = 0; + __pyx_t_14 = __Pyx_PyDict_GetItem(__pyx_v_self->_local_type_codecs, __pyx_t_15); if (unlikely(!__pyx_t_14)) __PYX_ERR(2, 530, __pyx_L14_error) + __Pyx_GOTREF(__pyx_t_14); + __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0; + if (!(likely(((__pyx_t_14) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_14, __pyx_ptype_7asyncpg_8protocol_8protocol_Codec))))) __PYX_ERR(2, 530, __pyx_L14_error) + __pyx_r = ((struct __pyx_obj_7asyncpg_8protocol_8protocol_Codec *)__pyx_t_14); + __pyx_t_14 = 0; + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + goto __pyx_L18_try_return; + + /* "asyncpg/protocol/codecs/base.pyx":529 + * return self._type_codecs_cache[oid, format] + * except KeyError: + * try: # <<<<<<<<<<<<<< + * return self._local_type_codecs[oid, format] + * except KeyError: + */ + } + __pyx_L14_error:; + __Pyx_PyThreadState_assign + __Pyx_XDECREF(__pyx_t_13); __pyx_t_13 = 0; + __Pyx_XDECREF(__pyx_t_15); __pyx_t_15 = 0; + __Pyx_XDECREF(__pyx_t_14); __pyx_t_14 = 0; + + /* "asyncpg/protocol/codecs/base.pyx":531 + * try: + * return self._local_type_codecs[oid, format] + * except KeyError: # <<<<<<<<<<<<<< + * return None + * + */ + __pyx_t_9 = __Pyx_PyErr_ExceptionMatches(__pyx_builtin_KeyError); + if (__pyx_t_9) { + __Pyx_AddTraceback("asyncpg.protocol.protocol.DataCodecConfig.get_codec", __pyx_clineno, __pyx_lineno, __pyx_filename); + if (__Pyx_GetException(&__pyx_t_14, &__pyx_t_15, &__pyx_t_13) < 0) __PYX_ERR(2, 531, __pyx_L16_except_error) + __Pyx_GOTREF(__pyx_t_14); + __Pyx_GOTREF(__pyx_t_15); + __Pyx_GOTREF(__pyx_t_13); + + /* "asyncpg/protocol/codecs/base.pyx":532 + * return self._local_type_codecs[oid, format] + * except KeyError: + * return None # <<<<<<<<<<<<<< + * + * + */ + __Pyx_XDECREF(((PyObject *)__pyx_r)); + __Pyx_INCREF(Py_None); + __pyx_r = ((struct __pyx_obj_7asyncpg_8protocol_8protocol_Codec *)Py_None); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0; + __Pyx_DECREF(__pyx_t_14); __pyx_t_14 = 0; + __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0; + goto __pyx_L17_except_return; + } + goto __pyx_L16_except_error; + __pyx_L16_except_error:; + + /* "asyncpg/protocol/codecs/base.pyx":529 + * return self._type_codecs_cache[oid, format] + * except KeyError: + * try: # <<<<<<<<<<<<<< + * return self._local_type_codecs[oid, format] + * except KeyError: + */ + __Pyx_PyThreadState_assign + __Pyx_XGIVEREF(__pyx_t_10); + __Pyx_XGIVEREF(__pyx_t_11); + __Pyx_XGIVEREF(__pyx_t_12); + __Pyx_ExceptionReset(__pyx_t_10, __pyx_t_11, __pyx_t_12); + goto __pyx_L6_except_error; + __pyx_L18_try_return:; + __Pyx_PyThreadState_assign + __Pyx_XGIVEREF(__pyx_t_10); + __Pyx_XGIVEREF(__pyx_t_11); + __Pyx_XGIVEREF(__pyx_t_12); + __Pyx_ExceptionReset(__pyx_t_10, __pyx_t_11, __pyx_t_12); + goto __pyx_L7_except_return; + __pyx_L17_except_return:; + __Pyx_PyThreadState_assign + __Pyx_XGIVEREF(__pyx_t_10); + __Pyx_XGIVEREF(__pyx_t_11); + __Pyx_XGIVEREF(__pyx_t_12); + __Pyx_ExceptionReset(__pyx_t_10, __pyx_t_11, __pyx_t_12); + goto __pyx_L7_except_return; + } + } + goto __pyx_L6_except_error; + __pyx_L6_except_error:; + + /* "asyncpg/protocol/codecs/base.pyx":526 + * return codec + * + * try: # <<<<<<<<<<<<<< + * return self._type_codecs_cache[oid, format] + * except KeyError: + */ + __Pyx_PyThreadState_assign + __Pyx_XGIVEREF(__pyx_t_4); + __Pyx_XGIVEREF(__pyx_t_5); + __Pyx_XGIVEREF(__pyx_t_6); + __Pyx_ExceptionReset(__pyx_t_4, __pyx_t_5, __pyx_t_6); + goto __pyx_L1_error; + __pyx_L8_try_return:; + __Pyx_PyThreadState_assign + __Pyx_XGIVEREF(__pyx_t_4); + __Pyx_XGIVEREF(__pyx_t_5); + __Pyx_XGIVEREF(__pyx_t_6); + __Pyx_ExceptionReset(__pyx_t_4, __pyx_t_5, __pyx_t_6); + goto __pyx_L0; + __pyx_L7_except_return:; + __Pyx_PyThreadState_assign + __Pyx_XGIVEREF(__pyx_t_4); + __Pyx_XGIVEREF(__pyx_t_5); + __Pyx_XGIVEREF(__pyx_t_6); + __Pyx_ExceptionReset(__pyx_t_4, __pyx_t_5, __pyx_t_6); + goto __pyx_L0; + } + + /* "asyncpg/protocol/codecs/base.pyx":519 + * self._type_codecs_cache.clear() + * + * cdef inline Codec get_codec(self, uint32_t oid, CodecFormat format): # <<<<<<<<<<<<<< + * cdef Codec codec + * + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_7); + __Pyx_XDECREF(__pyx_t_8); + __Pyx_XDECREF(__pyx_t_13); + __Pyx_XDECREF(__pyx_t_14); + __Pyx_XDECREF(__pyx_t_15); + __Pyx_AddTraceback("asyncpg.protocol.protocol.DataCodecConfig.get_codec", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XDECREF((PyObject *)__pyx_v_codec); + __Pyx_XGIVEREF((PyObject *)__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "asyncpg/protocol/codecs/base.pyx":535 + * + * + * cdef inline Codec get_core_codec(uint32_t oid, CodecFormat format): # <<<<<<<<<<<<<< + * cdef void *ptr + * if oid > MAXSUPPORTEDOID: + */ + +static CYTHON_INLINE struct __pyx_obj_7asyncpg_8protocol_8protocol_Codec *__pyx_f_7asyncpg_8protocol_8protocol_get_core_codec(uint32_t __pyx_v_oid, enum __pyx_t_7asyncpg_8protocol_8protocol_CodecFormat __pyx_v_format) { + void *__pyx_v_ptr; + struct __pyx_obj_7asyncpg_8protocol_8protocol_Codec *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + __Pyx_RefNannySetupContext("get_core_codec", 0); + + /* "asyncpg/protocol/codecs/base.pyx":537 + * cdef inline Codec get_core_codec(uint32_t oid, CodecFormat format): + * cdef void *ptr + * if oid > MAXSUPPORTEDOID: # <<<<<<<<<<<<<< + * return None + * if format == PG_FORMAT_BINARY: + */ + __pyx_t_1 = ((__pyx_v_oid > 0x1000) != 0); + if (__pyx_t_1) { + + /* "asyncpg/protocol/codecs/base.pyx":538 + * cdef void *ptr + * if oid > MAXSUPPORTEDOID: + * return None # <<<<<<<<<<<<<< + * if format == PG_FORMAT_BINARY: + * ptr = binary_codec_map[oid] + */ + __Pyx_XDECREF(((PyObject *)__pyx_r)); + __Pyx_INCREF(Py_None); + __pyx_r = ((struct __pyx_obj_7asyncpg_8protocol_8protocol_Codec *)Py_None); + goto __pyx_L0; + + /* "asyncpg/protocol/codecs/base.pyx":537 + * cdef inline Codec get_core_codec(uint32_t oid, CodecFormat format): + * cdef void *ptr + * if oid > MAXSUPPORTEDOID: # <<<<<<<<<<<<<< + * return None + * if format == PG_FORMAT_BINARY: + */ + } + + /* "asyncpg/protocol/codecs/base.pyx":539 + * if oid > MAXSUPPORTEDOID: + * return None + * if format == PG_FORMAT_BINARY: # <<<<<<<<<<<<<< + * ptr = binary_codec_map[oid] + * else: + */ + __pyx_t_1 = ((__pyx_v_format == __pyx_e_7asyncpg_8protocol_8protocol_PG_FORMAT_BINARY) != 0); + if (__pyx_t_1) { + + /* "asyncpg/protocol/codecs/base.pyx":540 + * return None + * if format == PG_FORMAT_BINARY: + * ptr = binary_codec_map[oid] # <<<<<<<<<<<<<< + * else: + * ptr = text_codec_map[oid] + */ + __pyx_v_ptr = (__pyx_v_7asyncpg_8protocol_8protocol_binary_codec_map[__pyx_v_oid]); + + /* "asyncpg/protocol/codecs/base.pyx":539 + * if oid > MAXSUPPORTEDOID: + * return None + * if format == PG_FORMAT_BINARY: # <<<<<<<<<<<<<< + * ptr = binary_codec_map[oid] + * else: + */ + goto __pyx_L4; + } + + /* "asyncpg/protocol/codecs/base.pyx":542 + * ptr = binary_codec_map[oid] + * else: + * ptr = text_codec_map[oid] # <<<<<<<<<<<<<< + * if ptr is NULL: + * return None + */ + /*else*/ { + __pyx_v_ptr = (__pyx_v_7asyncpg_8protocol_8protocol_text_codec_map[__pyx_v_oid]); + } + __pyx_L4:; + + /* "asyncpg/protocol/codecs/base.pyx":543 + * else: + * ptr = text_codec_map[oid] + * if ptr is NULL: # <<<<<<<<<<<<<< + * return None + * return ptr + */ + __pyx_t_1 = ((__pyx_v_ptr == NULL) != 0); + if (__pyx_t_1) { + + /* "asyncpg/protocol/codecs/base.pyx":544 + * ptr = text_codec_map[oid] + * if ptr is NULL: + * return None # <<<<<<<<<<<<<< + * return ptr + * + */ + __Pyx_XDECREF(((PyObject *)__pyx_r)); + __Pyx_INCREF(Py_None); + __pyx_r = ((struct __pyx_obj_7asyncpg_8protocol_8protocol_Codec *)Py_None); + goto __pyx_L0; + + /* "asyncpg/protocol/codecs/base.pyx":543 + * else: + * ptr = text_codec_map[oid] + * if ptr is NULL: # <<<<<<<<<<<<<< + * return None + * return ptr + */ + } + + /* "asyncpg/protocol/codecs/base.pyx":545 + * if ptr is NULL: + * return None + * return ptr # <<<<<<<<<<<<<< + * + * + */ + __Pyx_XDECREF(((PyObject *)__pyx_r)); + __Pyx_INCREF(((PyObject *)((struct __pyx_obj_7asyncpg_8protocol_8protocol_Codec *)__pyx_v_ptr))); + __pyx_r = ((struct __pyx_obj_7asyncpg_8protocol_8protocol_Codec *)__pyx_v_ptr); + goto __pyx_L0; + + /* "asyncpg/protocol/codecs/base.pyx":535 + * + * + * cdef inline Codec get_core_codec(uint32_t oid, CodecFormat format): # <<<<<<<<<<<<<< + * cdef void *ptr + * if oid > MAXSUPPORTEDOID: + */ + + /* function exit code */ + __pyx_L0:; + __Pyx_XGIVEREF((PyObject *)__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "asyncpg/protocol/codecs/base.pyx":548 + * + * + * cdef inline int has_core_codec(uint32_t oid): # <<<<<<<<<<<<<< + * return binary_codec_map[oid] != NULL or text_codec_map[oid] != NULL + * + */ + +static CYTHON_INLINE int __pyx_f_7asyncpg_8protocol_8protocol_has_core_codec(uint32_t __pyx_v_oid) { + int __pyx_r; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + int __pyx_t_2; + __Pyx_RefNannySetupContext("has_core_codec", 0); + + /* "asyncpg/protocol/codecs/base.pyx":549 + * + * cdef inline int has_core_codec(uint32_t oid): + * return binary_codec_map[oid] != NULL or text_codec_map[oid] != NULL # <<<<<<<<<<<<<< + * + * + */ + __pyx_t_2 = ((__pyx_v_7asyncpg_8protocol_8protocol_binary_codec_map[__pyx_v_oid]) != NULL); + if (!__pyx_t_2) { + } else { + __pyx_t_1 = __pyx_t_2; + goto __pyx_L3_bool_binop_done; + } + __pyx_t_2 = ((__pyx_v_7asyncpg_8protocol_8protocol_text_codec_map[__pyx_v_oid]) != NULL); + __pyx_t_1 = __pyx_t_2; + __pyx_L3_bool_binop_done:; + __pyx_r = __pyx_t_1; + goto __pyx_L0; + + /* "asyncpg/protocol/codecs/base.pyx":548 + * + * + * cdef inline int has_core_codec(uint32_t oid): # <<<<<<<<<<<<<< + * return binary_codec_map[oid] != NULL or text_codec_map[oid] != NULL + * + */ + + /* function exit code */ + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "asyncpg/protocol/codecs/base.pyx":552 + * + * + * cdef register_core_codec(uint32_t oid, # <<<<<<<<<<<<<< + * encode_func encode, + * decode_func decode, + */ + +static PyObject *__pyx_f_7asyncpg_8protocol_8protocol_register_core_codec(uint32_t __pyx_v_oid, __pyx_t_7asyncpg_8protocol_8protocol_encode_func __pyx_v_encode, __pyx_t_7asyncpg_8protocol_8protocol_decode_func __pyx_v_decode, enum __pyx_t_7asyncpg_8protocol_8protocol_CodecFormat __pyx_v_format) { + struct __pyx_obj_7asyncpg_8protocol_8protocol_Codec *__pyx_v_codec = 0; + PyObject *__pyx_v_name = 0; + PyObject *__pyx_v_kind = 0; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + PyObject *__pyx_t_5 = NULL; + int __pyx_t_6; + PyObject *__pyx_t_7 = NULL; + __Pyx_RefNannySetupContext("register_core_codec", 0); + + /* "asyncpg/protocol/codecs/base.pyx":557 + * CodecFormat format): + * + * if oid > MAXSUPPORTEDOID: # <<<<<<<<<<<<<< + * raise RuntimeError( + * 'cannot register core codec for OID {}: it is greater ' + */ + __pyx_t_1 = ((__pyx_v_oid > 0x1000) != 0); + if (__pyx_t_1) { + + /* "asyncpg/protocol/codecs/base.pyx":560 + * raise RuntimeError( + * 'cannot register core codec for OID {}: it is greater ' + * 'than MAXSUPPORTEDOID ({})'.format(oid, MAXSUPPORTEDOID)) # <<<<<<<<<<<<<< + * + * cdef: + */ + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_kp_u_cannot_register_core_codec_for_O, __pyx_n_s_format); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 560, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = __Pyx_PyInt_From_uint32_t(__pyx_v_oid); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 560, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_5 = NULL; + __pyx_t_6 = 0; + if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_3))) { + __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_3); + if (likely(__pyx_t_5)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); + __Pyx_INCREF(__pyx_t_5); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_3, function); + __pyx_t_6 = 1; + } + } + #if CYTHON_FAST_PYCALL + if (PyFunction_Check(__pyx_t_3)) { + PyObject *__pyx_temp[3] = {__pyx_t_5, __pyx_t_4, __pyx_int_4096}; + __pyx_t_2 = __Pyx_PyFunction_FastCall(__pyx_t_3, __pyx_temp+1-__pyx_t_6, 2+__pyx_t_6); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 560, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + } else + #endif + #if CYTHON_FAST_PYCCALL + if (__Pyx_PyFastCFunction_Check(__pyx_t_3)) { + PyObject *__pyx_temp[3] = {__pyx_t_5, __pyx_t_4, __pyx_int_4096}; + __pyx_t_2 = __Pyx_PyCFunction_FastCall(__pyx_t_3, __pyx_temp+1-__pyx_t_6, 2+__pyx_t_6); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 560, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + } else + #endif + { + __pyx_t_7 = PyTuple_New(2+__pyx_t_6); if (unlikely(!__pyx_t_7)) __PYX_ERR(2, 560, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + if (__pyx_t_5) { + __Pyx_GIVEREF(__pyx_t_5); PyTuple_SET_ITEM(__pyx_t_7, 0, __pyx_t_5); __pyx_t_5 = NULL; + } + __Pyx_GIVEREF(__pyx_t_4); + PyTuple_SET_ITEM(__pyx_t_7, 0+__pyx_t_6, __pyx_t_4); + __Pyx_INCREF(__pyx_int_4096); + __Pyx_GIVEREF(__pyx_int_4096); + PyTuple_SET_ITEM(__pyx_t_7, 1+__pyx_t_6, __pyx_int_4096); + __pyx_t_4 = 0; + __pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_t_7, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 560, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + } + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + + /* "asyncpg/protocol/codecs/base.pyx":558 + * + * if oid > MAXSUPPORTEDOID: + * raise RuntimeError( # <<<<<<<<<<<<<< + * 'cannot register core codec for OID {}: it is greater ' + * 'than MAXSUPPORTEDOID ({})'.format(oid, MAXSUPPORTEDOID)) + */ + __pyx_t_3 = PyTuple_New(1); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 558, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_GIVEREF(__pyx_t_2); + PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_t_2); + __pyx_t_2 = 0; + __pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_RuntimeError, __pyx_t_3, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 558, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_Raise(__pyx_t_2, 0, 0, 0); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __PYX_ERR(2, 558, __pyx_L1_error) + + /* "asyncpg/protocol/codecs/base.pyx":557 + * CodecFormat format): + * + * if oid > MAXSUPPORTEDOID: # <<<<<<<<<<<<<< + * raise RuntimeError( + * 'cannot register core codec for OID {}: it is greater ' + */ + } + + /* "asyncpg/protocol/codecs/base.pyx":567 + * str kind + * + * name = TYPEMAP[oid] # <<<<<<<<<<<<<< + * kind = 'array' if oid in ARRAY_TYPES else 'scalar' + * + */ + __pyx_t_2 = __Pyx_GetModuleGlobalName(__pyx_n_s_TYPEMAP); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 567, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = __Pyx_GetItemInt(__pyx_t_2, __pyx_v_oid, uint32_t, 0, __Pyx_PyInt_From_uint32_t, 0, 0, 1); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 567, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + if (!(likely(PyUnicode_CheckExact(__pyx_t_3))||((__pyx_t_3) == Py_None)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "unicode", Py_TYPE(__pyx_t_3)->tp_name), 0))) __PYX_ERR(2, 567, __pyx_L1_error) + __pyx_v_name = ((PyObject*)__pyx_t_3); + __pyx_t_3 = 0; + + /* "asyncpg/protocol/codecs/base.pyx":568 + * + * name = TYPEMAP[oid] + * kind = 'array' if oid in ARRAY_TYPES else 'scalar' # <<<<<<<<<<<<<< + * + * codec = Codec(oid) + */ + __pyx_t_2 = __Pyx_PyInt_From_uint32_t(__pyx_v_oid); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 568, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_1 = (__Pyx_PySequence_ContainsTF(__pyx_t_2, __pyx_v_7asyncpg_8protocol_8protocol_ARRAY_TYPES, Py_EQ)); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(2, 568, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + if ((__pyx_t_1 != 0)) { + __Pyx_INCREF(__pyx_n_u_array); + __pyx_t_3 = __pyx_n_u_array; + } else { + __Pyx_INCREF(__pyx_n_u_scalar); + __pyx_t_3 = __pyx_n_u_scalar; + } + __pyx_v_kind = ((PyObject*)__pyx_t_3); + __pyx_t_3 = 0; + + /* "asyncpg/protocol/codecs/base.pyx":570 + * kind = 'array' if oid in ARRAY_TYPES else 'scalar' + * + * codec = Codec(oid) # <<<<<<<<<<<<<< + * codec.init(name, 'pg_catalog', kind, CODEC_C, format, encode, + * decode, None, None, None, None, None, None, 0) + */ + __pyx_t_3 = __Pyx_PyInt_From_uint32_t(__pyx_v_oid); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 570, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_2 = PyTuple_New(1); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 570, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_GIVEREF(__pyx_t_3); + PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_t_3); + __pyx_t_3 = 0; + __pyx_t_3 = __Pyx_PyObject_Call(((PyObject *)__pyx_ptype_7asyncpg_8protocol_8protocol_Codec), __pyx_t_2, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 570, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_v_codec = ((struct __pyx_obj_7asyncpg_8protocol_8protocol_Codec *)__pyx_t_3); + __pyx_t_3 = 0; + + /* "asyncpg/protocol/codecs/base.pyx":571 + * + * codec = Codec(oid) + * codec.init(name, 'pg_catalog', kind, CODEC_C, format, encode, # <<<<<<<<<<<<<< + * decode, None, None, None, None, None, None, 0) + * cpython.Py_INCREF(codec) # immortalize + */ + __pyx_t_3 = __pyx_f_7asyncpg_8protocol_8protocol_5Codec_init(__pyx_v_codec, __pyx_v_name, __pyx_n_u_pg_catalog, __pyx_v_kind, __pyx_e_7asyncpg_8protocol_8protocol_CODEC_C, __pyx_v_format, __pyx_v_encode, __pyx_v_decode, Py_None, Py_None, ((struct __pyx_obj_7asyncpg_8protocol_8protocol_Codec *)Py_None), ((PyObject*)Py_None), Py_None, ((PyObject*)Py_None), 0); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 571, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + + /* "asyncpg/protocol/codecs/base.pyx":573 + * codec.init(name, 'pg_catalog', kind, CODEC_C, format, encode, + * decode, None, None, None, None, None, None, 0) + * cpython.Py_INCREF(codec) # immortalize # <<<<<<<<<<<<<< + * + * if format == PG_FORMAT_BINARY: + */ + Py_INCREF(((PyObject *)__pyx_v_codec)); + + /* "asyncpg/protocol/codecs/base.pyx":575 + * cpython.Py_INCREF(codec) # immortalize + * + * if format == PG_FORMAT_BINARY: # <<<<<<<<<<<<<< + * binary_codec_map[oid] = codec + * else: + */ + __pyx_t_1 = ((__pyx_v_format == __pyx_e_7asyncpg_8protocol_8protocol_PG_FORMAT_BINARY) != 0); + if (__pyx_t_1) { + + /* "asyncpg/protocol/codecs/base.pyx":576 + * + * if format == PG_FORMAT_BINARY: + * binary_codec_map[oid] = codec # <<<<<<<<<<<<<< + * else: + * text_codec_map[oid] = codec + */ + (__pyx_v_7asyncpg_8protocol_8protocol_binary_codec_map[__pyx_v_oid]) = ((void *)__pyx_v_codec); + + /* "asyncpg/protocol/codecs/base.pyx":575 + * cpython.Py_INCREF(codec) # immortalize + * + * if format == PG_FORMAT_BINARY: # <<<<<<<<<<<<<< + * binary_codec_map[oid] = codec + * else: + */ + goto __pyx_L4; + } + + /* "asyncpg/protocol/codecs/base.pyx":578 + * binary_codec_map[oid] = codec + * else: + * text_codec_map[oid] = codec # <<<<<<<<<<<<<< + * + * + */ + /*else*/ { + (__pyx_v_7asyncpg_8protocol_8protocol_text_codec_map[__pyx_v_oid]) = ((void *)__pyx_v_codec); + } + __pyx_L4:; + + /* "asyncpg/protocol/codecs/base.pyx":552 + * + * + * cdef register_core_codec(uint32_t oid, # <<<<<<<<<<<<<< + * encode_func encode, + * decode_func decode, + */ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_XDECREF(__pyx_t_7); + __Pyx_AddTraceback("asyncpg.protocol.protocol.register_core_codec", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XDECREF((PyObject *)__pyx_v_codec); + __Pyx_XDECREF(__pyx_v_name); + __Pyx_XDECREF(__pyx_v_kind); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "asyncpg/protocol/codecs/base.pyx":581 + * + * + * cdef register_extra_codec(str name, # <<<<<<<<<<<<<< + * encode_func encode, + * decode_func decode, + */ + +static PyObject *__pyx_f_7asyncpg_8protocol_8protocol_register_extra_codec(PyObject *__pyx_v_name, __pyx_t_7asyncpg_8protocol_8protocol_encode_func __pyx_v_encode, __pyx_t_7asyncpg_8protocol_8protocol_decode_func __pyx_v_decode, enum __pyx_t_7asyncpg_8protocol_8protocol_CodecFormat __pyx_v_format) { + struct __pyx_obj_7asyncpg_8protocol_8protocol_Codec *__pyx_v_codec = 0; + PyObject *__pyx_v_kind = 0; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + __Pyx_RefNannySetupContext("register_extra_codec", 0); + + /* "asyncpg/protocol/codecs/base.pyx":589 + * str kind + * + * kind = 'scalar' # <<<<<<<<<<<<<< + * + * codec = Codec(INVALIDOID) + */ + __Pyx_INCREF(__pyx_n_u_scalar); + __pyx_v_kind = __pyx_n_u_scalar; + + /* "asyncpg/protocol/codecs/base.pyx":591 + * kind = 'scalar' + * + * codec = Codec(INVALIDOID) # <<<<<<<<<<<<<< + * codec.init(name, None, kind, CODEC_C, format, encode, + * decode, None, None, None, None, None, None, 0) + */ + __pyx_t_1 = __Pyx_PyObject_Call(((PyObject *)__pyx_ptype_7asyncpg_8protocol_8protocol_Codec), __pyx_tuple__29, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 591, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_v_codec = ((struct __pyx_obj_7asyncpg_8protocol_8protocol_Codec *)__pyx_t_1); + __pyx_t_1 = 0; + + /* "asyncpg/protocol/codecs/base.pyx":592 + * + * codec = Codec(INVALIDOID) + * codec.init(name, None, kind, CODEC_C, format, encode, # <<<<<<<<<<<<<< + * decode, None, None, None, None, None, None, 0) + * EXTRA_CODECS[name, format] = codec + */ + __pyx_t_1 = __pyx_f_7asyncpg_8protocol_8protocol_5Codec_init(__pyx_v_codec, __pyx_v_name, ((PyObject*)Py_None), __pyx_v_kind, __pyx_e_7asyncpg_8protocol_8protocol_CODEC_C, __pyx_v_format, __pyx_v_encode, __pyx_v_decode, Py_None, Py_None, ((struct __pyx_obj_7asyncpg_8protocol_8protocol_Codec *)Py_None), ((PyObject*)Py_None), Py_None, ((PyObject*)Py_None), 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 592, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "asyncpg/protocol/codecs/base.pyx":594 + * codec.init(name, None, kind, CODEC_C, format, encode, + * decode, None, None, None, None, None, None, 0) + * EXTRA_CODECS[name, format] = codec # <<<<<<<<<<<<<< + * + * + */ + if (unlikely(__pyx_v_7asyncpg_8protocol_8protocol_EXTRA_CODECS == Py_None)) { + PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable"); + __PYX_ERR(2, 594, __pyx_L1_error) + } + __pyx_t_1 = __Pyx_PyInt_From_enum____pyx_t_7asyncpg_8protocol_8protocol_CodecFormat(__pyx_v_format); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 594, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = PyTuple_New(2); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 594, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_INCREF(__pyx_v_name); + __Pyx_GIVEREF(__pyx_v_name); + PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_v_name); + __Pyx_GIVEREF(__pyx_t_1); + PyTuple_SET_ITEM(__pyx_t_2, 1, __pyx_t_1); + __pyx_t_1 = 0; + if (unlikely(PyDict_SetItem(__pyx_v_7asyncpg_8protocol_8protocol_EXTRA_CODECS, __pyx_t_2, ((PyObject *)__pyx_v_codec)) < 0)) __PYX_ERR(2, 594, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "asyncpg/protocol/codecs/base.pyx":581 + * + * + * cdef register_extra_codec(str name, # <<<<<<<<<<<<<< + * encode_func encode, + * decode_func decode, + */ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_AddTraceback("asyncpg.protocol.protocol.register_extra_codec", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XDECREF((PyObject *)__pyx_v_codec); + __Pyx_XDECREF(__pyx_v_kind); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "asyncpg/protocol/codecs/base.pyx":597 + * + * + * cdef inline Codec get_extra_codec(str name, CodecFormat format): # <<<<<<<<<<<<<< + * return EXTRA_CODECS.get((name, format)) + */ + +static CYTHON_INLINE struct __pyx_obj_7asyncpg_8protocol_8protocol_Codec *__pyx_f_7asyncpg_8protocol_8protocol_get_extra_codec(PyObject *__pyx_v_name, enum __pyx_t_7asyncpg_8protocol_8protocol_CodecFormat __pyx_v_format) { + struct __pyx_obj_7asyncpg_8protocol_8protocol_Codec *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + __Pyx_RefNannySetupContext("get_extra_codec", 0); + + /* "asyncpg/protocol/codecs/base.pyx":598 + * + * cdef inline Codec get_extra_codec(str name, CodecFormat format): + * return EXTRA_CODECS.get((name, format)) # <<<<<<<<<<<<<< + */ + __Pyx_XDECREF(((PyObject *)__pyx_r)); + if (unlikely(__pyx_v_7asyncpg_8protocol_8protocol_EXTRA_CODECS == Py_None)) { + PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%s'", "get"); + __PYX_ERR(2, 598, __pyx_L1_error) + } + __pyx_t_1 = __Pyx_PyInt_From_enum____pyx_t_7asyncpg_8protocol_8protocol_CodecFormat(__pyx_v_format); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 598, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = PyTuple_New(2); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 598, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_INCREF(__pyx_v_name); + __Pyx_GIVEREF(__pyx_v_name); + PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_v_name); + __Pyx_GIVEREF(__pyx_t_1); + PyTuple_SET_ITEM(__pyx_t_2, 1, __pyx_t_1); + __pyx_t_1 = 0; + __pyx_t_1 = __Pyx_PyDict_GetItemDefault(__pyx_v_7asyncpg_8protocol_8protocol_EXTRA_CODECS, __pyx_t_2, Py_None); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 598, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + if (!(likely(((__pyx_t_1) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_1, __pyx_ptype_7asyncpg_8protocol_8protocol_Codec))))) __PYX_ERR(2, 598, __pyx_L1_error) + __pyx_r = ((struct __pyx_obj_7asyncpg_8protocol_8protocol_Codec *)__pyx_t_1); + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "asyncpg/protocol/codecs/base.pyx":597 + * + * + * cdef inline Codec get_extra_codec(str name, CodecFormat format): # <<<<<<<<<<<<<< + * return EXTRA_CODECS.get((name, format)) + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_AddTraceback("asyncpg.protocol.protocol.get_extra_codec", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XGIVEREF((PyObject *)__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "asyncpg/protocol/codecs/textutils.pyx":9 + * + * + * cdef int apg_strcasecmp(const Py_UCS4 *s1, const Py_UCS4 *s2): # <<<<<<<<<<<<<< + * cdef: + * uint32_t c1 + */ + +static int __pyx_f_7asyncpg_8protocol_8protocol_apg_strcasecmp(Py_UCS4 const *__pyx_v_s1, Py_UCS4 const *__pyx_v_s2) { + uint32_t __pyx_v_c1; + uint32_t __pyx_v_c2; + int __pyx_v_i; + int __pyx_r; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + int __pyx_t_2; + __Pyx_RefNannySetupContext("apg_strcasecmp", 0); + + /* "asyncpg/protocol/codecs/textutils.pyx":13 + * uint32_t c1 + * uint32_t c2 + * int i = 0 # <<<<<<<<<<<<<< + * + * while True: + */ + __pyx_v_i = 0; + + /* "asyncpg/protocol/codecs/textutils.pyx":15 + * int i = 0 + * + * while True: # <<<<<<<<<<<<<< + * c1 = s1[i] + * c2 = s2[i] + */ + while (1) { + + /* "asyncpg/protocol/codecs/textutils.pyx":16 + * + * while True: + * c1 = s1[i] # <<<<<<<<<<<<<< + * c2 = s2[i] + * + */ + __pyx_v_c1 = (__pyx_v_s1[__pyx_v_i]); + + /* "asyncpg/protocol/codecs/textutils.pyx":17 + * while True: + * c1 = s1[i] + * c2 = s2[i] # <<<<<<<<<<<<<< + * + * if c1 != c2: + */ + __pyx_v_c2 = (__pyx_v_s2[__pyx_v_i]); + + /* "asyncpg/protocol/codecs/textutils.pyx":19 + * c2 = s2[i] + * + * if c1 != c2: # <<<<<<<<<<<<<< + * if c1 >= 'A' and c1 <= 'Z': + * c1 += 'a' - 'A' + */ + __pyx_t_1 = ((__pyx_v_c1 != __pyx_v_c2) != 0); + if (__pyx_t_1) { + + /* "asyncpg/protocol/codecs/textutils.pyx":20 + * + * if c1 != c2: + * if c1 >= 'A' and c1 <= 'Z': # <<<<<<<<<<<<<< + * c1 += 'a' - 'A' + * if c2 >= 'A' and c2 <= 'Z': + */ + __pyx_t_2 = ((__pyx_v_c1 >= ((uint32_t)((Py_UCS4)65))) != 0); + if (__pyx_t_2) { + } else { + __pyx_t_1 = __pyx_t_2; + goto __pyx_L7_bool_binop_done; + } + __pyx_t_2 = ((__pyx_v_c1 <= ((uint32_t)((Py_UCS4)90))) != 0); + __pyx_t_1 = __pyx_t_2; + __pyx_L7_bool_binop_done:; + if (__pyx_t_1) { + + /* "asyncpg/protocol/codecs/textutils.pyx":21 + * if c1 != c2: + * if c1 >= 'A' and c1 <= 'Z': + * c1 += 'a' - 'A' # <<<<<<<<<<<<<< + * if c2 >= 'A' and c2 <= 'Z': + * c2 += 'a' - 'A' + */ + __pyx_v_c1 = (__pyx_v_c1 + (((uint32_t)((Py_UCS4)97)) - ((uint32_t)((Py_UCS4)65)))); + + /* "asyncpg/protocol/codecs/textutils.pyx":20 + * + * if c1 != c2: + * if c1 >= 'A' and c1 <= 'Z': # <<<<<<<<<<<<<< + * c1 += 'a' - 'A' + * if c2 >= 'A' and c2 <= 'Z': + */ + } + + /* "asyncpg/protocol/codecs/textutils.pyx":22 + * if c1 >= 'A' and c1 <= 'Z': + * c1 += 'a' - 'A' + * if c2 >= 'A' and c2 <= 'Z': # <<<<<<<<<<<<<< + * c2 += 'a' - 'A' + * + */ + __pyx_t_2 = ((__pyx_v_c2 >= ((uint32_t)((Py_UCS4)65))) != 0); + if (__pyx_t_2) { + } else { + __pyx_t_1 = __pyx_t_2; + goto __pyx_L10_bool_binop_done; + } + __pyx_t_2 = ((__pyx_v_c2 <= ((uint32_t)((Py_UCS4)90))) != 0); + __pyx_t_1 = __pyx_t_2; + __pyx_L10_bool_binop_done:; + if (__pyx_t_1) { + + /* "asyncpg/protocol/codecs/textutils.pyx":23 + * c1 += 'a' - 'A' + * if c2 >= 'A' and c2 <= 'Z': + * c2 += 'a' - 'A' # <<<<<<<<<<<<<< + * + * if c1 != c2: + */ + __pyx_v_c2 = (__pyx_v_c2 + (((uint32_t)((Py_UCS4)97)) - ((uint32_t)((Py_UCS4)65)))); + + /* "asyncpg/protocol/codecs/textutils.pyx":22 + * if c1 >= 'A' and c1 <= 'Z': + * c1 += 'a' - 'A' + * if c2 >= 'A' and c2 <= 'Z': # <<<<<<<<<<<<<< + * c2 += 'a' - 'A' + * + */ + } + + /* "asyncpg/protocol/codecs/textutils.pyx":25 + * c2 += 'a' - 'A' + * + * if c1 != c2: # <<<<<<<<<<<<<< + * return c1 - c2 + * + */ + __pyx_t_1 = ((__pyx_v_c1 != __pyx_v_c2) != 0); + if (__pyx_t_1) { + + /* "asyncpg/protocol/codecs/textutils.pyx":26 + * + * if c1 != c2: + * return c1 - c2 # <<<<<<<<<<<<<< + * + * if c1 == 0 or c2 == 0: + */ + __pyx_r = (((int32_t)__pyx_v_c1) - ((int32_t)__pyx_v_c2)); + goto __pyx_L0; + + /* "asyncpg/protocol/codecs/textutils.pyx":25 + * c2 += 'a' - 'A' + * + * if c1 != c2: # <<<<<<<<<<<<<< + * return c1 - c2 + * + */ + } + + /* "asyncpg/protocol/codecs/textutils.pyx":19 + * c2 = s2[i] + * + * if c1 != c2: # <<<<<<<<<<<<<< + * if c1 >= 'A' and c1 <= 'Z': + * c1 += 'a' - 'A' + */ + } + + /* "asyncpg/protocol/codecs/textutils.pyx":28 + * return c1 - c2 + * + * if c1 == 0 or c2 == 0: # <<<<<<<<<<<<<< + * break + * + */ + __pyx_t_2 = ((__pyx_v_c1 == 0) != 0); + if (!__pyx_t_2) { + } else { + __pyx_t_1 = __pyx_t_2; + goto __pyx_L14_bool_binop_done; + } + __pyx_t_2 = ((__pyx_v_c2 == 0) != 0); + __pyx_t_1 = __pyx_t_2; + __pyx_L14_bool_binop_done:; + if (__pyx_t_1) { + + /* "asyncpg/protocol/codecs/textutils.pyx":29 + * + * if c1 == 0 or c2 == 0: + * break # <<<<<<<<<<<<<< + * + * i += 1 + */ + goto __pyx_L4_break; + + /* "asyncpg/protocol/codecs/textutils.pyx":28 + * return c1 - c2 + * + * if c1 == 0 or c2 == 0: # <<<<<<<<<<<<<< + * break + * + */ + } + + /* "asyncpg/protocol/codecs/textutils.pyx":31 + * break + * + * i += 1 # <<<<<<<<<<<<<< + * + * return 0 + */ + __pyx_v_i = (__pyx_v_i + 1); + } + __pyx_L4_break:; + + /* "asyncpg/protocol/codecs/textutils.pyx":33 + * i += 1 + * + * return 0 # <<<<<<<<<<<<<< + * + * + */ + __pyx_r = 0; + goto __pyx_L0; + + /* "asyncpg/protocol/codecs/textutils.pyx":9 + * + * + * cdef int apg_strcasecmp(const Py_UCS4 *s1, const Py_UCS4 *s2): # <<<<<<<<<<<<<< + * cdef: + * uint32_t c1 + */ + + /* function exit code */ + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "asyncpg/protocol/codecs/textutils.pyx":36 + * + * + * cdef inline bint apg_ascii_isspace(Py_UCS4 ch): # <<<<<<<<<<<<<< + * return ( + * ch == ' ' or + */ + +static CYTHON_INLINE int __pyx_f_7asyncpg_8protocol_8protocol_apg_ascii_isspace(Py_UCS4 __pyx_v_ch) { + int __pyx_r; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + __Pyx_RefNannySetupContext("apg_ascii_isspace", 0); + + /* "asyncpg/protocol/codecs/textutils.pyx":38 + * cdef inline bint apg_ascii_isspace(Py_UCS4 ch): + * return ( + * ch == ' ' or # <<<<<<<<<<<<<< + * ch == '\n' or + * ch == '\r' or + */ + switch (__pyx_v_ch) { + case 32: + + /* "asyncpg/protocol/codecs/textutils.pyx":39 + * return ( + * ch == ' ' or + * ch == '\n' or # <<<<<<<<<<<<<< + * ch == '\r' or + * ch == '\t' or + */ + case 10: + + /* "asyncpg/protocol/codecs/textutils.pyx":40 + * ch == ' ' or + * ch == '\n' or + * ch == '\r' or # <<<<<<<<<<<<<< + * ch == '\t' or + * ch == '\v' or + */ + case 13: + + /* "asyncpg/protocol/codecs/textutils.pyx":41 + * ch == '\n' or + * ch == '\r' or + * ch == '\t' or # <<<<<<<<<<<<<< + * ch == '\v' or + * ch == '\f' + */ + case 9: + + /* "asyncpg/protocol/codecs/textutils.pyx":42 + * ch == '\r' or + * ch == '\t' or + * ch == '\v' or # <<<<<<<<<<<<<< + * ch == '\f' + * ) + */ + case 11: + + /* "asyncpg/protocol/codecs/textutils.pyx":43 + * ch == '\t' or + * ch == '\v' or + * ch == '\f' # <<<<<<<<<<<<<< + * ) + * + */ + case 12: + + /* "asyncpg/protocol/codecs/textutils.pyx":38 + * cdef inline bint apg_ascii_isspace(Py_UCS4 ch): + * return ( + * ch == ' ' or # <<<<<<<<<<<<<< + * ch == '\n' or + * ch == '\r' or + */ + __pyx_t_1 = 1; + break; + default: + __pyx_t_1 = 0; + break; + } + __pyx_r = __pyx_t_1; + goto __pyx_L0; + + /* "asyncpg/protocol/codecs/textutils.pyx":36 + * + * + * cdef inline bint apg_ascii_isspace(Py_UCS4 ch): # <<<<<<<<<<<<<< + * return ( + * ch == ' ' or + */ + + /* function exit code */ + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "asyncpg/protocol/codecs/textutils.pyx":47 + * + * + * cdef Py_UCS4 *apg_parse_int32(Py_UCS4 *buf, int32_t *num): # <<<<<<<<<<<<<< + * cdef: + * Py_UCS4 *p + */ + +static Py_UCS4 *__pyx_f_7asyncpg_8protocol_8protocol_apg_parse_int32(Py_UCS4 *__pyx_v_buf, int32_t *__pyx_v_num) { + Py_UCS4 *__pyx_v_p; + int32_t __pyx_v_n; + int32_t __pyx_v_neg; + Py_UCS4 *__pyx_r; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + int __pyx_t_2; + __Pyx_RefNannySetupContext("apg_parse_int32", 0); + + /* "asyncpg/protocol/codecs/textutils.pyx":50 + * cdef: + * Py_UCS4 *p + * int32_t n = 0 # <<<<<<<<<<<<<< + * int32_t neg = 0 + * + */ + __pyx_v_n = 0; + + /* "asyncpg/protocol/codecs/textutils.pyx":51 + * Py_UCS4 *p + * int32_t n = 0 + * int32_t neg = 0 # <<<<<<<<<<<<<< + * + * if buf[0] == '-': + */ + __pyx_v_neg = 0; + + /* "asyncpg/protocol/codecs/textutils.pyx":53 + * int32_t neg = 0 + * + * if buf[0] == '-': # <<<<<<<<<<<<<< + * neg = 1 + * buf += 1 + */ + __pyx_t_1 = (((__pyx_v_buf[0]) == 45) != 0); + if (__pyx_t_1) { + + /* "asyncpg/protocol/codecs/textutils.pyx":54 + * + * if buf[0] == '-': + * neg = 1 # <<<<<<<<<<<<<< + * buf += 1 + * elif buf[0] == '+': + */ + __pyx_v_neg = 1; + + /* "asyncpg/protocol/codecs/textutils.pyx":55 + * if buf[0] == '-': + * neg = 1 + * buf += 1 # <<<<<<<<<<<<<< + * elif buf[0] == '+': + * buf += 1 + */ + __pyx_v_buf = (__pyx_v_buf + 1); + + /* "asyncpg/protocol/codecs/textutils.pyx":53 + * int32_t neg = 0 + * + * if buf[0] == '-': # <<<<<<<<<<<<<< + * neg = 1 + * buf += 1 + */ + goto __pyx_L3; + } + + /* "asyncpg/protocol/codecs/textutils.pyx":56 + * neg = 1 + * buf += 1 + * elif buf[0] == '+': # <<<<<<<<<<<<<< + * buf += 1 + * + */ + __pyx_t_1 = (((__pyx_v_buf[0]) == 43) != 0); + if (__pyx_t_1) { + + /* "asyncpg/protocol/codecs/textutils.pyx":57 + * buf += 1 + * elif buf[0] == '+': + * buf += 1 # <<<<<<<<<<<<<< + * + * p = buf + */ + __pyx_v_buf = (__pyx_v_buf + 1); + + /* "asyncpg/protocol/codecs/textutils.pyx":56 + * neg = 1 + * buf += 1 + * elif buf[0] == '+': # <<<<<<<<<<<<<< + * buf += 1 + * + */ + } + __pyx_L3:; + + /* "asyncpg/protocol/codecs/textutils.pyx":59 + * buf += 1 + * + * p = buf # <<<<<<<<<<<<<< + * while p[0] >= '0' and p[0] <= '9': + * n = 10 * n - (p[0] - '0') + */ + __pyx_v_p = __pyx_v_buf; + + /* "asyncpg/protocol/codecs/textutils.pyx":60 + * + * p = buf + * while p[0] >= '0' and p[0] <= '9': # <<<<<<<<<<<<<< + * n = 10 * n - (p[0] - '0') + * p += 1 + */ + while (1) { + __pyx_t_2 = ((((int)(__pyx_v_p[0])) >= ((int)((Py_UCS4)48))) != 0); + if (__pyx_t_2) { + } else { + __pyx_t_1 = __pyx_t_2; + goto __pyx_L6_bool_binop_done; + } + __pyx_t_2 = ((((int)(__pyx_v_p[0])) <= ((int)((Py_UCS4)57))) != 0); + __pyx_t_1 = __pyx_t_2; + __pyx_L6_bool_binop_done:; + if (!__pyx_t_1) break; + + /* "asyncpg/protocol/codecs/textutils.pyx":61 + * p = buf + * while p[0] >= '0' and p[0] <= '9': + * n = 10 * n - (p[0] - '0') # <<<<<<<<<<<<<< + * p += 1 + * + */ + __pyx_v_n = ((10 * __pyx_v_n) - (((int)(__pyx_v_p[0])) - ((int32_t)((Py_UCS4)48)))); + + /* "asyncpg/protocol/codecs/textutils.pyx":62 + * while p[0] >= '0' and p[0] <= '9': + * n = 10 * n - (p[0] - '0') + * p += 1 # <<<<<<<<<<<<<< + * + * if p == buf: + */ + __pyx_v_p = (__pyx_v_p + 1); + } + + /* "asyncpg/protocol/codecs/textutils.pyx":64 + * p += 1 + * + * if p == buf: # <<<<<<<<<<<<<< + * return NULL + * + */ + __pyx_t_1 = ((__pyx_v_p == __pyx_v_buf) != 0); + if (__pyx_t_1) { + + /* "asyncpg/protocol/codecs/textutils.pyx":65 + * + * if p == buf: + * return NULL # <<<<<<<<<<<<<< + * + * if not neg: + */ + __pyx_r = NULL; + goto __pyx_L0; + + /* "asyncpg/protocol/codecs/textutils.pyx":64 + * p += 1 + * + * if p == buf: # <<<<<<<<<<<<<< + * return NULL + * + */ + } + + /* "asyncpg/protocol/codecs/textutils.pyx":67 + * return NULL + * + * if not neg: # <<<<<<<<<<<<<< + * n = -n + * + */ + __pyx_t_1 = ((!(__pyx_v_neg != 0)) != 0); + if (__pyx_t_1) { + + /* "asyncpg/protocol/codecs/textutils.pyx":68 + * + * if not neg: + * n = -n # <<<<<<<<<<<<<< + * + * num[0] = n + */ + __pyx_v_n = (-__pyx_v_n); + + /* "asyncpg/protocol/codecs/textutils.pyx":67 + * return NULL + * + * if not neg: # <<<<<<<<<<<<<< + * n = -n + * + */ + } + + /* "asyncpg/protocol/codecs/textutils.pyx":70 + * n = -n + * + * num[0] = n # <<<<<<<<<<<<<< + * + * return p + */ + (__pyx_v_num[0]) = __pyx_v_n; + + /* "asyncpg/protocol/codecs/textutils.pyx":72 + * num[0] = n + * + * return p # <<<<<<<<<<<<<< + */ + __pyx_r = __pyx_v_p; + goto __pyx_L0; + + /* "asyncpg/protocol/codecs/textutils.pyx":47 + * + * + * cdef Py_UCS4 *apg_parse_int32(Py_UCS4 *buf, int32_t *num): # <<<<<<<<<<<<<< + * cdef: + * Py_UCS4 *p + */ + + /* function exit code */ + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "asyncpg/protocol/codecs/bytea.pyx":8 + * + * + * cdef bytea_encode(ConnectionSettings settings, WriteBuffer wbuf, obj): # <<<<<<<<<<<<<< + * cdef: + * Py_buffer pybuf + */ + +static PyObject *__pyx_f_7asyncpg_8protocol_8protocol_bytea_encode(CYTHON_UNUSED struct __pyx_obj_7asyncpg_8protocol_8protocol_ConnectionSettings *__pyx_v_settings, struct __pyx_obj_7asyncpg_8protocol_8protocol_WriteBuffer *__pyx_v_wbuf, PyObject *__pyx_v_obj) { + Py_buffer __pyx_v_pybuf; + int __pyx_v_pybuf_used; + char *__pyx_v_buf; + Py_ssize_t __pyx_v_len; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + int __pyx_t_2; + Py_ssize_t __pyx_t_3; + PyObject *__pyx_t_4 = NULL; + int __pyx_t_5; + char const *__pyx_t_6; + PyObject *__pyx_t_7 = NULL; + PyObject *__pyx_t_8 = NULL; + PyObject *__pyx_t_9 = NULL; + PyObject *__pyx_t_10 = NULL; + PyObject *__pyx_t_11 = NULL; + PyObject *__pyx_t_12 = NULL; + __Pyx_RefNannySetupContext("bytea_encode", 0); + + /* "asyncpg/protocol/codecs/bytea.pyx":11 + * cdef: + * Py_buffer pybuf + * bint pybuf_used = False # <<<<<<<<<<<<<< + * char *buf + * ssize_t len + */ + __pyx_v_pybuf_used = 0; + + /* "asyncpg/protocol/codecs/bytea.pyx":15 + * ssize_t len + * + * if cpython.PyBytes_CheckExact(obj): # <<<<<<<<<<<<<< + * buf = cpython.PyBytes_AS_STRING(obj) + * len = cpython.Py_SIZE(obj) + */ + __pyx_t_1 = (PyBytes_CheckExact(__pyx_v_obj) != 0); + if (__pyx_t_1) { + + /* "asyncpg/protocol/codecs/bytea.pyx":16 + * + * if cpython.PyBytes_CheckExact(obj): + * buf = cpython.PyBytes_AS_STRING(obj) # <<<<<<<<<<<<<< + * len = cpython.Py_SIZE(obj) + * else: + */ + __pyx_v_buf = PyBytes_AS_STRING(__pyx_v_obj); + + /* "asyncpg/protocol/codecs/bytea.pyx":17 + * if cpython.PyBytes_CheckExact(obj): + * buf = cpython.PyBytes_AS_STRING(obj) + * len = cpython.Py_SIZE(obj) # <<<<<<<<<<<<<< + * else: + * cpython.PyObject_GetBuffer(obj, &pybuf, cpython.PyBUF_SIMPLE) + */ + __pyx_v_len = Py_SIZE(__pyx_v_obj); + + /* "asyncpg/protocol/codecs/bytea.pyx":15 + * ssize_t len + * + * if cpython.PyBytes_CheckExact(obj): # <<<<<<<<<<<<<< + * buf = cpython.PyBytes_AS_STRING(obj) + * len = cpython.Py_SIZE(obj) + */ + goto __pyx_L3; + } + + /* "asyncpg/protocol/codecs/bytea.pyx":19 + * len = cpython.Py_SIZE(obj) + * else: + * cpython.PyObject_GetBuffer(obj, &pybuf, cpython.PyBUF_SIMPLE) # <<<<<<<<<<<<<< + * pybuf_used = True + * buf = pybuf.buf + */ + /*else*/ { + __pyx_t_2 = PyObject_GetBuffer(__pyx_v_obj, (&__pyx_v_pybuf), PyBUF_SIMPLE); if (unlikely(__pyx_t_2 == -1)) __PYX_ERR(6, 19, __pyx_L1_error) + + /* "asyncpg/protocol/codecs/bytea.pyx":20 + * else: + * cpython.PyObject_GetBuffer(obj, &pybuf, cpython.PyBUF_SIMPLE) + * pybuf_used = True # <<<<<<<<<<<<<< + * buf = pybuf.buf + * len = pybuf.len + */ + __pyx_v_pybuf_used = 1; + + /* "asyncpg/protocol/codecs/bytea.pyx":21 + * cpython.PyObject_GetBuffer(obj, &pybuf, cpython.PyBUF_SIMPLE) + * pybuf_used = True + * buf = pybuf.buf # <<<<<<<<<<<<<< + * len = pybuf.len + * + */ + __pyx_v_buf = ((char *)__pyx_v_pybuf.buf); + + /* "asyncpg/protocol/codecs/bytea.pyx":22 + * pybuf_used = True + * buf = pybuf.buf + * len = pybuf.len # <<<<<<<<<<<<<< + * + * try: + */ + __pyx_t_3 = __pyx_v_pybuf.len; + __pyx_v_len = __pyx_t_3; + } + __pyx_L3:; + + /* "asyncpg/protocol/codecs/bytea.pyx":24 + * len = pybuf.len + * + * try: # <<<<<<<<<<<<<< + * wbuf.write_int32(len) + * wbuf.write_cstr(buf, len) + */ + /*try:*/ { + + /* "asyncpg/protocol/codecs/bytea.pyx":25 + * + * try: + * wbuf.write_int32(len) # <<<<<<<<<<<<<< + * wbuf.write_cstr(buf, len) + * finally: + */ + __pyx_t_4 = __pyx_f_7asyncpg_8protocol_8protocol_11WriteBuffer_write_int32(__pyx_v_wbuf, ((int32_t)__pyx_v_len)); if (unlikely(!__pyx_t_4)) __PYX_ERR(6, 25, __pyx_L5_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + + /* "asyncpg/protocol/codecs/bytea.pyx":26 + * try: + * wbuf.write_int32(len) + * wbuf.write_cstr(buf, len) # <<<<<<<<<<<<<< + * finally: + * if pybuf_used: + */ + __pyx_t_4 = __pyx_f_7asyncpg_8protocol_8protocol_11WriteBuffer_write_cstr(__pyx_v_wbuf, __pyx_v_buf, __pyx_v_len); if (unlikely(!__pyx_t_4)) __PYX_ERR(6, 26, __pyx_L5_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + } + + /* "asyncpg/protocol/codecs/bytea.pyx":28 + * wbuf.write_cstr(buf, len) + * finally: + * if pybuf_used: # <<<<<<<<<<<<<< + * cpython.PyBuffer_Release(&pybuf) + * + */ + /*finally:*/ { + /*normal exit:*/{ + __pyx_t_1 = (__pyx_v_pybuf_used != 0); + if (__pyx_t_1) { + + /* "asyncpg/protocol/codecs/bytea.pyx":29 + * finally: + * if pybuf_used: + * cpython.PyBuffer_Release(&pybuf) # <<<<<<<<<<<<<< + * + * + */ + PyBuffer_Release((&__pyx_v_pybuf)); + + /* "asyncpg/protocol/codecs/bytea.pyx":28 + * wbuf.write_cstr(buf, len) + * finally: + * if pybuf_used: # <<<<<<<<<<<<<< + * cpython.PyBuffer_Release(&pybuf) + * + */ + } + goto __pyx_L6; + } + /*exception exit:*/{ + __Pyx_PyThreadState_declare + __pyx_L5_error:; + __pyx_t_7 = 0; __pyx_t_8 = 0; __pyx_t_9 = 0; __pyx_t_10 = 0; __pyx_t_11 = 0; __pyx_t_12 = 0; + __Pyx_PyThreadState_assign + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + if (PY_MAJOR_VERSION >= 3) __Pyx_ExceptionSwap(&__pyx_t_10, &__pyx_t_11, &__pyx_t_12); + if ((PY_MAJOR_VERSION < 3) || unlikely(__Pyx_GetException(&__pyx_t_7, &__pyx_t_8, &__pyx_t_9) < 0)) __Pyx_ErrFetch(&__pyx_t_7, &__pyx_t_8, &__pyx_t_9); + __Pyx_XGOTREF(__pyx_t_7); + __Pyx_XGOTREF(__pyx_t_8); + __Pyx_XGOTREF(__pyx_t_9); + __Pyx_XGOTREF(__pyx_t_10); + __Pyx_XGOTREF(__pyx_t_11); + __Pyx_XGOTREF(__pyx_t_12); + __pyx_t_2 = __pyx_lineno; __pyx_t_5 = __pyx_clineno; __pyx_t_6 = __pyx_filename; + { + __pyx_t_1 = (__pyx_v_pybuf_used != 0); + if (__pyx_t_1) { + + /* "asyncpg/protocol/codecs/bytea.pyx":29 + * finally: + * if pybuf_used: + * cpython.PyBuffer_Release(&pybuf) # <<<<<<<<<<<<<< + * + * + */ + PyBuffer_Release((&__pyx_v_pybuf)); + + /* "asyncpg/protocol/codecs/bytea.pyx":28 + * wbuf.write_cstr(buf, len) + * finally: + * if pybuf_used: # <<<<<<<<<<<<<< + * cpython.PyBuffer_Release(&pybuf) + * + */ + } + } + __Pyx_PyThreadState_assign + if (PY_MAJOR_VERSION >= 3) { + __Pyx_XGIVEREF(__pyx_t_10); + __Pyx_XGIVEREF(__pyx_t_11); + __Pyx_XGIVEREF(__pyx_t_12); + __Pyx_ExceptionReset(__pyx_t_10, __pyx_t_11, __pyx_t_12); + } + __Pyx_XGIVEREF(__pyx_t_7); + __Pyx_XGIVEREF(__pyx_t_8); + __Pyx_XGIVEREF(__pyx_t_9); + __Pyx_ErrRestore(__pyx_t_7, __pyx_t_8, __pyx_t_9); + __pyx_t_7 = 0; __pyx_t_8 = 0; __pyx_t_9 = 0; __pyx_t_10 = 0; __pyx_t_11 = 0; __pyx_t_12 = 0; + __pyx_lineno = __pyx_t_2; __pyx_clineno = __pyx_t_5; __pyx_filename = __pyx_t_6; + goto __pyx_L1_error; + } + __pyx_L6:; + } + + /* "asyncpg/protocol/codecs/bytea.pyx":8 + * + * + * cdef bytea_encode(ConnectionSettings settings, WriteBuffer wbuf, obj): # <<<<<<<<<<<<<< + * cdef: + * Py_buffer pybuf + */ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_4); + __Pyx_AddTraceback("asyncpg.protocol.protocol.bytea_encode", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "asyncpg/protocol/codecs/bytea.pyx":32 + * + * + * cdef bytea_decode(ConnectionSettings settings, FastReadBuffer buf): # <<<<<<<<<<<<<< + * cdef ssize_t buf_len = buf.len + * return cpython.PyBytes_FromStringAndSize(buf.read_all(), buf_len) + */ + +static PyObject *__pyx_f_7asyncpg_8protocol_8protocol_bytea_decode(CYTHON_UNUSED struct __pyx_obj_7asyncpg_8protocol_8protocol_ConnectionSettings *__pyx_v_settings, struct __pyx_obj_7asyncpg_8protocol_8protocol_FastReadBuffer *__pyx_v_buf) { + Py_ssize_t __pyx_v_buf_len; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + Py_ssize_t __pyx_t_1; + PyObject *__pyx_t_2 = NULL; + __Pyx_RefNannySetupContext("bytea_decode", 0); + + /* "asyncpg/protocol/codecs/bytea.pyx":33 + * + * cdef bytea_decode(ConnectionSettings settings, FastReadBuffer buf): + * cdef ssize_t buf_len = buf.len # <<<<<<<<<<<<<< + * return cpython.PyBytes_FromStringAndSize(buf.read_all(), buf_len) + * + */ + __pyx_t_1 = __pyx_v_buf->len; + __pyx_v_buf_len = __pyx_t_1; + + /* "asyncpg/protocol/codecs/bytea.pyx":34 + * cdef bytea_decode(ConnectionSettings settings, FastReadBuffer buf): + * cdef ssize_t buf_len = buf.len + * return cpython.PyBytes_FromStringAndSize(buf.read_all(), buf_len) # <<<<<<<<<<<<<< + * + * + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_2 = PyBytes_FromStringAndSize(__pyx_f_7asyncpg_8protocol_8protocol_14FastReadBuffer_read_all(__pyx_v_buf), __pyx_v_buf_len); if (unlikely(!__pyx_t_2)) __PYX_ERR(6, 34, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_r = __pyx_t_2; + __pyx_t_2 = 0; + goto __pyx_L0; + + /* "asyncpg/protocol/codecs/bytea.pyx":32 + * + * + * cdef bytea_decode(ConnectionSettings settings, FastReadBuffer buf): # <<<<<<<<<<<<<< + * cdef ssize_t buf_len = buf.len + * return cpython.PyBytes_FromStringAndSize(buf.read_all(), buf_len) + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_2); + __Pyx_AddTraceback("asyncpg.protocol.protocol.bytea_decode", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "asyncpg/protocol/codecs/bytea.pyx":37 + * + * + * cdef init_bytea_codecs(): # <<<<<<<<<<<<<< + * register_core_codec(BYTEAOID, + * &bytea_encode, + */ + +static PyObject *__pyx_f_7asyncpg_8protocol_8protocol_init_bytea_codecs(void) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + __Pyx_RefNannySetupContext("init_bytea_codecs", 0); + + /* "asyncpg/protocol/codecs/bytea.pyx":38 + * + * cdef init_bytea_codecs(): + * register_core_codec(BYTEAOID, # <<<<<<<<<<<<<< + * &bytea_encode, + * &bytea_decode, + */ + __pyx_t_1 = __pyx_f_7asyncpg_8protocol_8protocol_register_core_codec(17, ((__pyx_t_7asyncpg_8protocol_8protocol_encode_func)(&__pyx_f_7asyncpg_8protocol_8protocol_bytea_encode)), ((__pyx_t_7asyncpg_8protocol_8protocol_decode_func)(&__pyx_f_7asyncpg_8protocol_8protocol_bytea_decode)), __pyx_e_7asyncpg_8protocol_8protocol_PG_FORMAT_BINARY); if (unlikely(!__pyx_t_1)) __PYX_ERR(6, 38, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "asyncpg/protocol/codecs/bytea.pyx":43 + * PG_FORMAT_BINARY) + * + * register_core_codec(CHAROID, # <<<<<<<<<<<<<< + * &bytea_encode, + * &bytea_decode, + */ + __pyx_t_1 = __pyx_f_7asyncpg_8protocol_8protocol_register_core_codec(18, ((__pyx_t_7asyncpg_8protocol_8protocol_encode_func)(&__pyx_f_7asyncpg_8protocol_8protocol_bytea_encode)), ((__pyx_t_7asyncpg_8protocol_8protocol_decode_func)(&__pyx_f_7asyncpg_8protocol_8protocol_bytea_decode)), __pyx_e_7asyncpg_8protocol_8protocol_PG_FORMAT_BINARY); if (unlikely(!__pyx_t_1)) __PYX_ERR(6, 43, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "asyncpg/protocol/codecs/bytea.pyx":37 + * + * + * cdef init_bytea_codecs(): # <<<<<<<<<<<<<< + * register_core_codec(BYTEAOID, + * &bytea_encode, + */ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("asyncpg.protocol.protocol.init_bytea_codecs", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "asyncpg/protocol/codecs/text.pyx":8 + * + * + * cdef inline as_pg_string_and_size( # <<<<<<<<<<<<<< + * ConnectionSettings settings, obj, char **cstr, ssize_t *size): + * + */ + +static CYTHON_INLINE PyObject *__pyx_f_7asyncpg_8protocol_8protocol_as_pg_string_and_size(struct __pyx_obj_7asyncpg_8protocol_8protocol_ConnectionSettings *__pyx_v_settings, PyObject *__pyx_v_obj, char **__pyx_v_cstr, Py_ssize_t *__pyx_v_size) { + PyObject *__pyx_v_encoded = NULL; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + char *__pyx_t_4; + PyObject *__pyx_t_5 = NULL; + PyObject *__pyx_t_6 = NULL; + int __pyx_t_7; + __Pyx_RefNannySetupContext("as_pg_string_and_size", 0); + __Pyx_INCREF(__pyx_v_obj); + + /* "asyncpg/protocol/codecs/text.pyx":11 + * ConnectionSettings settings, obj, char **cstr, ssize_t *size): + * + * if not cpython.PyUnicode_Check(obj): # <<<<<<<<<<<<<< + * obj = str(obj) + * + */ + __pyx_t_1 = ((!(PyUnicode_Check(__pyx_v_obj) != 0)) != 0); + if (__pyx_t_1) { + + /* "asyncpg/protocol/codecs/text.pyx":12 + * + * if not cpython.PyUnicode_Check(obj): + * obj = str(obj) # <<<<<<<<<<<<<< + * + * if settings.is_encoding_utf8(): + */ + __pyx_t_2 = PyTuple_New(1); if (unlikely(!__pyx_t_2)) __PYX_ERR(7, 12, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_INCREF(__pyx_v_obj); + __Pyx_GIVEREF(__pyx_v_obj); + PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_v_obj); + __pyx_t_3 = __Pyx_PyObject_Call(((PyObject *)(&PyUnicode_Type)), __pyx_t_2, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(7, 12, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_DECREF_SET(__pyx_v_obj, __pyx_t_3); + __pyx_t_3 = 0; + + /* "asyncpg/protocol/codecs/text.pyx":11 + * ConnectionSettings settings, obj, char **cstr, ssize_t *size): + * + * if not cpython.PyUnicode_Check(obj): # <<<<<<<<<<<<<< + * obj = str(obj) + * + */ + } + + /* "asyncpg/protocol/codecs/text.pyx":14 + * obj = str(obj) + * + * if settings.is_encoding_utf8(): # <<<<<<<<<<<<<< + * cstr[0] = PyUnicode_AsUTF8AndSize(obj, size) + * else: + */ + __pyx_t_3 = __pyx_f_7asyncpg_8protocol_8protocol_18ConnectionSettings_is_encoding_utf8(__pyx_v_settings); if (unlikely(!__pyx_t_3)) __PYX_ERR(7, 14, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(7, 14, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (__pyx_t_1) { + + /* "asyncpg/protocol/codecs/text.pyx":15 + * + * if settings.is_encoding_utf8(): + * cstr[0] = PyUnicode_AsUTF8AndSize(obj, size) # <<<<<<<<<<<<<< + * else: + * encoded = settings.get_text_codec().encode(obj) + */ + __pyx_t_4 = PyUnicode_AsUTF8AndSize(__pyx_v_obj, __pyx_v_size); if (unlikely(__pyx_t_4 == NULL)) __PYX_ERR(7, 15, __pyx_L1_error) + (__pyx_v_cstr[0]) = __pyx_t_4; + + /* "asyncpg/protocol/codecs/text.pyx":14 + * obj = str(obj) + * + * if settings.is_encoding_utf8(): # <<<<<<<<<<<<<< + * cstr[0] = PyUnicode_AsUTF8AndSize(obj, size) + * else: + */ + goto __pyx_L4; + } + + /* "asyncpg/protocol/codecs/text.pyx":17 + * cstr[0] = PyUnicode_AsUTF8AndSize(obj, size) + * else: + * encoded = settings.get_text_codec().encode(obj) # <<<<<<<<<<<<<< + * cpython.PyBytes_AsStringAndSize(encoded, cstr, size) + * + */ + /*else*/ { + __pyx_t_2 = __pyx_f_7asyncpg_8protocol_8protocol_18ConnectionSettings_get_text_codec(__pyx_v_settings, 0); if (unlikely(!__pyx_t_2)) __PYX_ERR(7, 17, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_encode); if (unlikely(!__pyx_t_5)) __PYX_ERR(7, 17, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_2 = NULL; + if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_5))) { + __pyx_t_2 = PyMethod_GET_SELF(__pyx_t_5); + if (likely(__pyx_t_2)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_5); + __Pyx_INCREF(__pyx_t_2); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_5, function); + } + } + if (!__pyx_t_2) { + __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_t_5, __pyx_v_obj); if (unlikely(!__pyx_t_3)) __PYX_ERR(7, 17, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + } else { + #if CYTHON_FAST_PYCALL + if (PyFunction_Check(__pyx_t_5)) { + PyObject *__pyx_temp[2] = {__pyx_t_2, __pyx_v_obj}; + __pyx_t_3 = __Pyx_PyFunction_FastCall(__pyx_t_5, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_3)) __PYX_ERR(7, 17, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_GOTREF(__pyx_t_3); + } else + #endif + #if CYTHON_FAST_PYCCALL + if (__Pyx_PyFastCFunction_Check(__pyx_t_5)) { + PyObject *__pyx_temp[2] = {__pyx_t_2, __pyx_v_obj}; + __pyx_t_3 = __Pyx_PyCFunction_FastCall(__pyx_t_5, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_3)) __PYX_ERR(7, 17, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_GOTREF(__pyx_t_3); + } else + #endif + { + __pyx_t_6 = PyTuple_New(1+1); if (unlikely(!__pyx_t_6)) __PYX_ERR(7, 17, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_GIVEREF(__pyx_t_2); PyTuple_SET_ITEM(__pyx_t_6, 0, __pyx_t_2); __pyx_t_2 = NULL; + __Pyx_INCREF(__pyx_v_obj); + __Pyx_GIVEREF(__pyx_v_obj); + PyTuple_SET_ITEM(__pyx_t_6, 0+1, __pyx_v_obj); + __pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_5, __pyx_t_6, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(7, 17, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + } + } + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __pyx_v_encoded = __pyx_t_3; + __pyx_t_3 = 0; + + /* "asyncpg/protocol/codecs/text.pyx":18 + * else: + * encoded = settings.get_text_codec().encode(obj) + * cpython.PyBytes_AsStringAndSize(encoded, cstr, size) # <<<<<<<<<<<<<< + * + * if size[0] > 0x7fffffff: + */ + __pyx_t_7 = PyBytes_AsStringAndSize(__pyx_v_encoded, __pyx_v_cstr, ((Py_ssize_t *)__pyx_v_size)); if (unlikely(__pyx_t_7 == -1)) __PYX_ERR(7, 18, __pyx_L1_error) + } + __pyx_L4:; + + /* "asyncpg/protocol/codecs/text.pyx":20 + * cpython.PyBytes_AsStringAndSize(encoded, cstr, size) + * + * if size[0] > 0x7fffffff: # <<<<<<<<<<<<<< + * raise ValueError('string too long') + * + */ + __pyx_t_1 = (((__pyx_v_size[0]) > 0x7fffffff) != 0); + if (__pyx_t_1) { + + /* "asyncpg/protocol/codecs/text.pyx":21 + * + * if size[0] > 0x7fffffff: + * raise ValueError('string too long') # <<<<<<<<<<<<<< + * + * + */ + __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__30, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(7, 21, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_Raise(__pyx_t_3, 0, 0, 0); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __PYX_ERR(7, 21, __pyx_L1_error) + + /* "asyncpg/protocol/codecs/text.pyx":20 + * cpython.PyBytes_AsStringAndSize(encoded, cstr, size) + * + * if size[0] > 0x7fffffff: # <<<<<<<<<<<<<< + * raise ValueError('string too long') + * + */ + } + + /* "asyncpg/protocol/codecs/text.pyx":8 + * + * + * cdef inline as_pg_string_and_size( # <<<<<<<<<<<<<< + * ConnectionSettings settings, obj, char **cstr, ssize_t *size): + * + */ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_XDECREF(__pyx_t_6); + __Pyx_AddTraceback("asyncpg.protocol.protocol.as_pg_string_and_size", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XDECREF(__pyx_v_encoded); + __Pyx_XDECREF(__pyx_v_obj); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "asyncpg/protocol/codecs/text.pyx":24 + * + * + * cdef text_encode(ConnectionSettings settings, WriteBuffer buf, obj): # <<<<<<<<<<<<<< + * cdef: + * char *str + */ + +static PyObject *__pyx_f_7asyncpg_8protocol_8protocol_text_encode(struct __pyx_obj_7asyncpg_8protocol_8protocol_ConnectionSettings *__pyx_v_settings, struct __pyx_obj_7asyncpg_8protocol_8protocol_WriteBuffer *__pyx_v_buf, PyObject *__pyx_v_obj) { + char *__pyx_v_str; + Py_ssize_t __pyx_v_size; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + __Pyx_RefNannySetupContext("text_encode", 0); + + /* "asyncpg/protocol/codecs/text.pyx":29 + * ssize_t size + * + * as_pg_string_and_size(settings, obj, &str, &size) # <<<<<<<<<<<<<< + * + * buf.write_int32(size) + */ + __pyx_t_1 = __pyx_f_7asyncpg_8protocol_8protocol_as_pg_string_and_size(__pyx_v_settings, __pyx_v_obj, (&__pyx_v_str), (&__pyx_v_size)); if (unlikely(!__pyx_t_1)) __PYX_ERR(7, 29, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "asyncpg/protocol/codecs/text.pyx":31 + * as_pg_string_and_size(settings, obj, &str, &size) + * + * buf.write_int32(size) # <<<<<<<<<<<<<< + * buf.write_cstr(str, size) + * + */ + __pyx_t_1 = __pyx_f_7asyncpg_8protocol_8protocol_11WriteBuffer_write_int32(__pyx_v_buf, ((int32_t)__pyx_v_size)); if (unlikely(!__pyx_t_1)) __PYX_ERR(7, 31, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "asyncpg/protocol/codecs/text.pyx":32 + * + * buf.write_int32(size) + * buf.write_cstr(str, size) # <<<<<<<<<<<<<< + * + * + */ + __pyx_t_1 = __pyx_f_7asyncpg_8protocol_8protocol_11WriteBuffer_write_cstr(__pyx_v_buf, __pyx_v_str, __pyx_v_size); if (unlikely(!__pyx_t_1)) __PYX_ERR(7, 32, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "asyncpg/protocol/codecs/text.pyx":24 + * + * + * cdef text_encode(ConnectionSettings settings, WriteBuffer buf, obj): # <<<<<<<<<<<<<< + * cdef: + * char *str + */ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("asyncpg.protocol.protocol.text_encode", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "asyncpg/protocol/codecs/text.pyx":35 + * + * + * cdef inline decode_pg_string(ConnectionSettings settings, const char* data, # <<<<<<<<<<<<<< + * ssize_t len): + * + */ + +static CYTHON_INLINE PyObject *__pyx_f_7asyncpg_8protocol_8protocol_decode_pg_string(struct __pyx_obj_7asyncpg_8protocol_8protocol_ConnectionSettings *__pyx_v_settings, char const *__pyx_v_data, Py_ssize_t __pyx_v_len) { + PyObject *__pyx_v_bytes = NULL; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_t_2; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + PyObject *__pyx_t_5 = NULL; + __Pyx_RefNannySetupContext("decode_pg_string", 0); + + /* "asyncpg/protocol/codecs/text.pyx":38 + * ssize_t len): + * + * if settings.is_encoding_utf8(): # <<<<<<<<<<<<<< + * # decode UTF-8 in strict mode + * return cpython.PyUnicode_DecodeUTF8(data, len, NULL) + */ + __pyx_t_1 = __pyx_f_7asyncpg_8protocol_8protocol_18ConnectionSettings_is_encoding_utf8(__pyx_v_settings); if (unlikely(!__pyx_t_1)) __PYX_ERR(7, 38, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_t_1); if (unlikely(__pyx_t_2 < 0)) __PYX_ERR(7, 38, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + if (__pyx_t_2) { + + /* "asyncpg/protocol/codecs/text.pyx":40 + * if settings.is_encoding_utf8(): + * # decode UTF-8 in strict mode + * return cpython.PyUnicode_DecodeUTF8(data, len, NULL) # <<<<<<<<<<<<<< + * else: + * bytes = cpython.PyBytes_FromStringAndSize(data, len) + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = PyUnicode_DecodeUTF8(__pyx_v_data, __pyx_v_len, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(7, 40, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "asyncpg/protocol/codecs/text.pyx":38 + * ssize_t len): + * + * if settings.is_encoding_utf8(): # <<<<<<<<<<<<<< + * # decode UTF-8 in strict mode + * return cpython.PyUnicode_DecodeUTF8(data, len, NULL) + */ + } + + /* "asyncpg/protocol/codecs/text.pyx":42 + * return cpython.PyUnicode_DecodeUTF8(data, len, NULL) + * else: + * bytes = cpython.PyBytes_FromStringAndSize(data, len) # <<<<<<<<<<<<<< + * return settings.get_text_codec().decode(bytes) + * + */ + /*else*/ { + __pyx_t_1 = PyBytes_FromStringAndSize(__pyx_v_data, __pyx_v_len); if (unlikely(!__pyx_t_1)) __PYX_ERR(7, 42, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_v_bytes = ((PyObject*)__pyx_t_1); + __pyx_t_1 = 0; + + /* "asyncpg/protocol/codecs/text.pyx":43 + * else: + * bytes = cpython.PyBytes_FromStringAndSize(data, len) + * return settings.get_text_codec().decode(bytes) # <<<<<<<<<<<<<< + * + * + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_3 = __pyx_f_7asyncpg_8protocol_8protocol_18ConnectionSettings_get_text_codec(__pyx_v_settings, 0); if (unlikely(!__pyx_t_3)) __PYX_ERR(7, 43, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_decode); if (unlikely(!__pyx_t_4)) __PYX_ERR(7, 43, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_3 = NULL; + if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_4))) { + __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_4); + if (likely(__pyx_t_3)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4); + __Pyx_INCREF(__pyx_t_3); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_4, function); + } + } + if (!__pyx_t_3) { + __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_v_bytes); if (unlikely(!__pyx_t_1)) __PYX_ERR(7, 43, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + } else { + #if CYTHON_FAST_PYCALL + if (PyFunction_Check(__pyx_t_4)) { + PyObject *__pyx_temp[2] = {__pyx_t_3, __pyx_v_bytes}; + __pyx_t_1 = __Pyx_PyFunction_FastCall(__pyx_t_4, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_1)) __PYX_ERR(7, 43, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_GOTREF(__pyx_t_1); + } else + #endif + #if CYTHON_FAST_PYCCALL + if (__Pyx_PyFastCFunction_Check(__pyx_t_4)) { + PyObject *__pyx_temp[2] = {__pyx_t_3, __pyx_v_bytes}; + __pyx_t_1 = __Pyx_PyCFunction_FastCall(__pyx_t_4, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_1)) __PYX_ERR(7, 43, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_GOTREF(__pyx_t_1); + } else + #endif + { + __pyx_t_5 = PyTuple_New(1+1); if (unlikely(!__pyx_t_5)) __PYX_ERR(7, 43, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_GIVEREF(__pyx_t_3); PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_t_3); __pyx_t_3 = NULL; + __Pyx_INCREF(__pyx_v_bytes); + __Pyx_GIVEREF(__pyx_v_bytes); + PyTuple_SET_ITEM(__pyx_t_5, 0+1, __pyx_v_bytes); + __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_4, __pyx_t_5, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(7, 43, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + } + } + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + } + + /* "asyncpg/protocol/codecs/text.pyx":35 + * + * + * cdef inline decode_pg_string(ConnectionSettings settings, const char* data, # <<<<<<<<<<<<<< + * ssize_t len): + * + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_AddTraceback("asyncpg.protocol.protocol.decode_pg_string", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XDECREF(__pyx_v_bytes); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "asyncpg/protocol/codecs/text.pyx":46 + * + * + * cdef text_decode(ConnectionSettings settings, FastReadBuffer buf): # <<<<<<<<<<<<<< + * cdef ssize_t buf_len = buf.len + * return decode_pg_string(settings, buf.read_all(), buf_len) + */ + +static PyObject *__pyx_f_7asyncpg_8protocol_8protocol_text_decode(struct __pyx_obj_7asyncpg_8protocol_8protocol_ConnectionSettings *__pyx_v_settings, struct __pyx_obj_7asyncpg_8protocol_8protocol_FastReadBuffer *__pyx_v_buf) { + Py_ssize_t __pyx_v_buf_len; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + Py_ssize_t __pyx_t_1; + PyObject *__pyx_t_2 = NULL; + __Pyx_RefNannySetupContext("text_decode", 0); + + /* "asyncpg/protocol/codecs/text.pyx":47 + * + * cdef text_decode(ConnectionSettings settings, FastReadBuffer buf): + * cdef ssize_t buf_len = buf.len # <<<<<<<<<<<<<< + * return decode_pg_string(settings, buf.read_all(), buf_len) + * + */ + __pyx_t_1 = __pyx_v_buf->len; + __pyx_v_buf_len = __pyx_t_1; + + /* "asyncpg/protocol/codecs/text.pyx":48 + * cdef text_decode(ConnectionSettings settings, FastReadBuffer buf): + * cdef ssize_t buf_len = buf.len + * return decode_pg_string(settings, buf.read_all(), buf_len) # <<<<<<<<<<<<<< + * + * + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_2 = __pyx_f_7asyncpg_8protocol_8protocol_decode_pg_string(__pyx_v_settings, __pyx_f_7asyncpg_8protocol_8protocol_14FastReadBuffer_read_all(__pyx_v_buf), __pyx_v_buf_len); if (unlikely(!__pyx_t_2)) __PYX_ERR(7, 48, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_r = __pyx_t_2; + __pyx_t_2 = 0; + goto __pyx_L0; + + /* "asyncpg/protocol/codecs/text.pyx":46 + * + * + * cdef text_decode(ConnectionSettings settings, FastReadBuffer buf): # <<<<<<<<<<<<<< + * cdef ssize_t buf_len = buf.len + * return decode_pg_string(settings, buf.read_all(), buf_len) + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_2); + __Pyx_AddTraceback("asyncpg.protocol.protocol.text_decode", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "asyncpg/protocol/codecs/text.pyx":51 + * + * + * cdef init_text_codecs(): # <<<<<<<<<<<<<< + * textoids = [ + * NAMEOID, + */ + +static PyObject *__pyx_f_7asyncpg_8protocol_8protocol_init_text_codecs(void) { + PyObject *__pyx_v_textoids = NULL; + PyObject *__pyx_v_oid = NULL; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + Py_ssize_t __pyx_t_2; + PyObject *__pyx_t_3 = NULL; + uint32_t __pyx_t_4; + __Pyx_RefNannySetupContext("init_text_codecs", 0); + + /* "asyncpg/protocol/codecs/text.pyx":52 + * + * cdef init_text_codecs(): + * textoids = [ # <<<<<<<<<<<<<< + * NAMEOID, + * BPCHAROID, + */ + __pyx_t_1 = PyList_New(5); if (unlikely(!__pyx_t_1)) __PYX_ERR(7, 52, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_INCREF(__pyx_int_19); + __Pyx_GIVEREF(__pyx_int_19); + PyList_SET_ITEM(__pyx_t_1, 0, __pyx_int_19); + __Pyx_INCREF(__pyx_int_1042); + __Pyx_GIVEREF(__pyx_int_1042); + PyList_SET_ITEM(__pyx_t_1, 1, __pyx_int_1042); + __Pyx_INCREF(__pyx_int_1043); + __Pyx_GIVEREF(__pyx_int_1043); + PyList_SET_ITEM(__pyx_t_1, 2, __pyx_int_1043); + __Pyx_INCREF(__pyx_int_25); + __Pyx_GIVEREF(__pyx_int_25); + PyList_SET_ITEM(__pyx_t_1, 3, __pyx_int_25); + __Pyx_INCREF(__pyx_int_142); + __Pyx_GIVEREF(__pyx_int_142); + PyList_SET_ITEM(__pyx_t_1, 4, __pyx_int_142); + __pyx_v_textoids = ((PyObject*)__pyx_t_1); + __pyx_t_1 = 0; + + /* "asyncpg/protocol/codecs/text.pyx":60 + * ] + * + * for oid in textoids: # <<<<<<<<<<<<<< + * register_core_codec(oid, + * &text_encode, + */ + __pyx_t_1 = __pyx_v_textoids; __Pyx_INCREF(__pyx_t_1); __pyx_t_2 = 0; + for (;;) { + if (__pyx_t_2 >= PyList_GET_SIZE(__pyx_t_1)) break; + #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + __pyx_t_3 = PyList_GET_ITEM(__pyx_t_1, __pyx_t_2); __Pyx_INCREF(__pyx_t_3); __pyx_t_2++; if (unlikely(0 < 0)) __PYX_ERR(7, 60, __pyx_L1_error) + #else + __pyx_t_3 = PySequence_ITEM(__pyx_t_1, __pyx_t_2); __pyx_t_2++; if (unlikely(!__pyx_t_3)) __PYX_ERR(7, 60, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + #endif + __Pyx_XDECREF_SET(__pyx_v_oid, __pyx_t_3); + __pyx_t_3 = 0; + + /* "asyncpg/protocol/codecs/text.pyx":61 + * + * for oid in textoids: + * register_core_codec(oid, # <<<<<<<<<<<<<< + * &text_encode, + * &text_decode, + */ + __pyx_t_4 = __Pyx_PyInt_As_uint32_t(__pyx_v_oid); if (unlikely((__pyx_t_4 == ((uint32_t)-1)) && PyErr_Occurred())) __PYX_ERR(7, 61, __pyx_L1_error) + + /* "asyncpg/protocol/codecs/text.pyx":64 + * &text_encode, + * &text_decode, + * PG_FORMAT_BINARY) # <<<<<<<<<<<<<< + * + * + */ + __pyx_t_3 = __pyx_f_7asyncpg_8protocol_8protocol_register_core_codec(__pyx_t_4, ((__pyx_t_7asyncpg_8protocol_8protocol_encode_func)(&__pyx_f_7asyncpg_8protocol_8protocol_text_encode)), ((__pyx_t_7asyncpg_8protocol_8protocol_decode_func)(&__pyx_f_7asyncpg_8protocol_8protocol_text_decode)), __pyx_e_7asyncpg_8protocol_8protocol_PG_FORMAT_BINARY); if (unlikely(!__pyx_t_3)) __PYX_ERR(7, 61, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + + /* "asyncpg/protocol/codecs/text.pyx":60 + * ] + * + * for oid in textoids: # <<<<<<<<<<<<<< + * register_core_codec(oid, + * &text_encode, + */ + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "asyncpg/protocol/codecs/text.pyx":51 + * + * + * cdef init_text_codecs(): # <<<<<<<<<<<<<< + * textoids = [ + * NAMEOID, + */ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_AddTraceback("asyncpg.protocol.protocol.init_text_codecs", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XDECREF(__pyx_v_textoids); + __Pyx_XDECREF(__pyx_v_oid); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "asyncpg/protocol/codecs/bits.pyx":11 + * + * + * cdef bits_encode(ConnectionSettings settings, WriteBuffer wbuf, obj): # <<<<<<<<<<<<<< + * cdef: + * Py_buffer pybuf + */ + +static PyObject *__pyx_f_7asyncpg_8protocol_8protocol_bits_encode(CYTHON_UNUSED struct __pyx_obj_7asyncpg_8protocol_8protocol_ConnectionSettings *__pyx_v_settings, struct __pyx_obj_7asyncpg_8protocol_8protocol_WriteBuffer *__pyx_v_wbuf, PyObject *__pyx_v_obj) { + Py_buffer __pyx_v_pybuf; + int __pyx_v_pybuf_used; + char *__pyx_v_buf; + Py_ssize_t __pyx_v_len; + Py_ssize_t __pyx_v_bitlen; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + PyObject *__pyx_t_2 = NULL; + int __pyx_t_3; + int __pyx_t_4; + PyObject *__pyx_t_5 = NULL; + PyObject *__pyx_t_6 = NULL; + Py_ssize_t __pyx_t_7; + Py_ssize_t __pyx_t_8; + int __pyx_t_9; + char const *__pyx_t_10; + PyObject *__pyx_t_11 = NULL; + PyObject *__pyx_t_12 = NULL; + PyObject *__pyx_t_13 = NULL; + PyObject *__pyx_t_14 = NULL; + PyObject *__pyx_t_15 = NULL; + PyObject *__pyx_t_16 = NULL; + __Pyx_RefNannySetupContext("bits_encode", 0); + + /* "asyncpg/protocol/codecs/bits.pyx":14 + * cdef: + * Py_buffer pybuf + * bint pybuf_used = False # <<<<<<<<<<<<<< + * char *buf + * ssize_t len + */ + __pyx_v_pybuf_used = 0; + + /* "asyncpg/protocol/codecs/bits.pyx":19 + * ssize_t bitlen + * + * if cpython.PyBytes_CheckExact(obj): # <<<<<<<<<<<<<< + * buf = cpython.PyBytes_AS_STRING(obj) + * len = cpython.Py_SIZE(obj) + */ + __pyx_t_1 = (PyBytes_CheckExact(__pyx_v_obj) != 0); + if (__pyx_t_1) { + + /* "asyncpg/protocol/codecs/bits.pyx":20 + * + * if cpython.PyBytes_CheckExact(obj): + * buf = cpython.PyBytes_AS_STRING(obj) # <<<<<<<<<<<<<< + * len = cpython.Py_SIZE(obj) + * bitlen = len * 8 + */ + __pyx_v_buf = PyBytes_AS_STRING(__pyx_v_obj); + + /* "asyncpg/protocol/codecs/bits.pyx":21 + * if cpython.PyBytes_CheckExact(obj): + * buf = cpython.PyBytes_AS_STRING(obj) + * len = cpython.Py_SIZE(obj) # <<<<<<<<<<<<<< + * bitlen = len * 8 + * elif isinstance(obj, BitString): + */ + __pyx_v_len = Py_SIZE(__pyx_v_obj); + + /* "asyncpg/protocol/codecs/bits.pyx":22 + * buf = cpython.PyBytes_AS_STRING(obj) + * len = cpython.Py_SIZE(obj) + * bitlen = len * 8 # <<<<<<<<<<<<<< + * elif isinstance(obj, BitString): + * cpython.PyBytes_AsStringAndSize(obj.bytes, &buf, &len) + */ + __pyx_v_bitlen = (__pyx_v_len * 8); + + /* "asyncpg/protocol/codecs/bits.pyx":19 + * ssize_t bitlen + * + * if cpython.PyBytes_CheckExact(obj): # <<<<<<<<<<<<<< + * buf = cpython.PyBytes_AS_STRING(obj) + * len = cpython.Py_SIZE(obj) + */ + goto __pyx_L3; + } + + /* "asyncpg/protocol/codecs/bits.pyx":23 + * len = cpython.Py_SIZE(obj) + * bitlen = len * 8 + * elif isinstance(obj, BitString): # <<<<<<<<<<<<<< + * cpython.PyBytes_AsStringAndSize(obj.bytes, &buf, &len) + * bitlen = obj.__len__() + */ + __pyx_t_2 = __Pyx_GetModuleGlobalName(__pyx_n_s_BitString); if (unlikely(!__pyx_t_2)) __PYX_ERR(8, 23, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_1 = PyObject_IsInstance(__pyx_v_obj, __pyx_t_2); if (unlikely(__pyx_t_1 == -1)) __PYX_ERR(8, 23, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_3 = (__pyx_t_1 != 0); + if (__pyx_t_3) { + + /* "asyncpg/protocol/codecs/bits.pyx":24 + * bitlen = len * 8 + * elif isinstance(obj, BitString): + * cpython.PyBytes_AsStringAndSize(obj.bytes, &buf, &len) # <<<<<<<<<<<<<< + * bitlen = obj.__len__() + * else: + */ + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_obj, __pyx_n_s_bytes); if (unlikely(!__pyx_t_2)) __PYX_ERR(8, 24, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_4 = PyBytes_AsStringAndSize(__pyx_t_2, (&__pyx_v_buf), ((Py_ssize_t *)(&__pyx_v_len))); if (unlikely(__pyx_t_4 == -1)) __PYX_ERR(8, 24, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "asyncpg/protocol/codecs/bits.pyx":25 + * elif isinstance(obj, BitString): + * cpython.PyBytes_AsStringAndSize(obj.bytes, &buf, &len) + * bitlen = obj.__len__() # <<<<<<<<<<<<<< + * else: + * cpython.PyObject_GetBuffer(obj, &pybuf, cpython.PyBUF_SIMPLE) + */ + __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_v_obj, __pyx_n_s_len); if (unlikely(!__pyx_t_5)) __PYX_ERR(8, 25, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_6 = NULL; + if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_5))) { + __pyx_t_6 = PyMethod_GET_SELF(__pyx_t_5); + if (likely(__pyx_t_6)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_5); + __Pyx_INCREF(__pyx_t_6); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_5, function); + } + } + if (__pyx_t_6) { + __pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_t_5, __pyx_t_6); if (unlikely(!__pyx_t_2)) __PYX_ERR(8, 25, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + } else { + __pyx_t_2 = __Pyx_PyObject_CallNoArg(__pyx_t_5); if (unlikely(!__pyx_t_2)) __PYX_ERR(8, 25, __pyx_L1_error) + } + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __pyx_t_7 = PyInt_AsSsize_t(__pyx_t_2); if (unlikely((__pyx_t_7 == (Py_ssize_t)-1) && PyErr_Occurred())) __PYX_ERR(8, 25, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_v_bitlen = __pyx_t_7; + + /* "asyncpg/protocol/codecs/bits.pyx":23 + * len = cpython.Py_SIZE(obj) + * bitlen = len * 8 + * elif isinstance(obj, BitString): # <<<<<<<<<<<<<< + * cpython.PyBytes_AsStringAndSize(obj.bytes, &buf, &len) + * bitlen = obj.__len__() + */ + goto __pyx_L3; + } + + /* "asyncpg/protocol/codecs/bits.pyx":27 + * bitlen = obj.__len__() + * else: + * cpython.PyObject_GetBuffer(obj, &pybuf, cpython.PyBUF_SIMPLE) # <<<<<<<<<<<<<< + * pybuf_used = True + * buf = pybuf.buf + */ + /*else*/ { + __pyx_t_4 = PyObject_GetBuffer(__pyx_v_obj, (&__pyx_v_pybuf), PyBUF_SIMPLE); if (unlikely(__pyx_t_4 == -1)) __PYX_ERR(8, 27, __pyx_L1_error) + + /* "asyncpg/protocol/codecs/bits.pyx":28 + * else: + * cpython.PyObject_GetBuffer(obj, &pybuf, cpython.PyBUF_SIMPLE) + * pybuf_used = True # <<<<<<<<<<<<<< + * buf = pybuf.buf + * len = pybuf.len + */ + __pyx_v_pybuf_used = 1; + + /* "asyncpg/protocol/codecs/bits.pyx":29 + * cpython.PyObject_GetBuffer(obj, &pybuf, cpython.PyBUF_SIMPLE) + * pybuf_used = True + * buf = pybuf.buf # <<<<<<<<<<<<<< + * len = pybuf.len + * bitlen = len * 8 + */ + __pyx_v_buf = ((char *)__pyx_v_pybuf.buf); + + /* "asyncpg/protocol/codecs/bits.pyx":30 + * pybuf_used = True + * buf = pybuf.buf + * len = pybuf.len # <<<<<<<<<<<<<< + * bitlen = len * 8 + * + */ + __pyx_t_8 = __pyx_v_pybuf.len; + __pyx_v_len = __pyx_t_8; + + /* "asyncpg/protocol/codecs/bits.pyx":31 + * buf = pybuf.buf + * len = pybuf.len + * bitlen = len * 8 # <<<<<<<<<<<<<< + * + * try: + */ + __pyx_v_bitlen = (__pyx_v_len * 8); + } + __pyx_L3:; + + /* "asyncpg/protocol/codecs/bits.pyx":33 + * bitlen = len * 8 + * + * try: # <<<<<<<<<<<<<< + * if bitlen > _MAXINT32: + * raise ValueError('bit value too long') + */ + /*try:*/ { + + /* "asyncpg/protocol/codecs/bits.pyx":34 + * + * try: + * if bitlen > _MAXINT32: # <<<<<<<<<<<<<< + * raise ValueError('bit value too long') + * wbuf.write_int32(4 + len) + */ + __pyx_t_3 = ((__pyx_v_bitlen > 0x7FFFFFFF) != 0); + if (__pyx_t_3) { + + /* "asyncpg/protocol/codecs/bits.pyx":35 + * try: + * if bitlen > _MAXINT32: + * raise ValueError('bit value too long') # <<<<<<<<<<<<<< + * wbuf.write_int32(4 + len) + * wbuf.write_int32(bitlen) + */ + __pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__31, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(8, 35, __pyx_L5_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_Raise(__pyx_t_2, 0, 0, 0); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __PYX_ERR(8, 35, __pyx_L5_error) + + /* "asyncpg/protocol/codecs/bits.pyx":34 + * + * try: + * if bitlen > _MAXINT32: # <<<<<<<<<<<<<< + * raise ValueError('bit value too long') + * wbuf.write_int32(4 + len) + */ + } + + /* "asyncpg/protocol/codecs/bits.pyx":36 + * if bitlen > _MAXINT32: + * raise ValueError('bit value too long') + * wbuf.write_int32(4 + len) # <<<<<<<<<<<<<< + * wbuf.write_int32(bitlen) + * wbuf.write_cstr(buf, len) + */ + __pyx_t_2 = __pyx_f_7asyncpg_8protocol_8protocol_11WriteBuffer_write_int32(__pyx_v_wbuf, (4 + ((int32_t)__pyx_v_len))); if (unlikely(!__pyx_t_2)) __PYX_ERR(8, 36, __pyx_L5_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "asyncpg/protocol/codecs/bits.pyx":37 + * raise ValueError('bit value too long') + * wbuf.write_int32(4 + len) + * wbuf.write_int32(bitlen) # <<<<<<<<<<<<<< + * wbuf.write_cstr(buf, len) + * finally: + */ + __pyx_t_2 = __pyx_f_7asyncpg_8protocol_8protocol_11WriteBuffer_write_int32(__pyx_v_wbuf, ((int32_t)__pyx_v_bitlen)); if (unlikely(!__pyx_t_2)) __PYX_ERR(8, 37, __pyx_L5_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "asyncpg/protocol/codecs/bits.pyx":38 + * wbuf.write_int32(4 + len) + * wbuf.write_int32(bitlen) + * wbuf.write_cstr(buf, len) # <<<<<<<<<<<<<< + * finally: + * if pybuf_used: + */ + __pyx_t_2 = __pyx_f_7asyncpg_8protocol_8protocol_11WriteBuffer_write_cstr(__pyx_v_wbuf, __pyx_v_buf, __pyx_v_len); if (unlikely(!__pyx_t_2)) __PYX_ERR(8, 38, __pyx_L5_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } + + /* "asyncpg/protocol/codecs/bits.pyx":40 + * wbuf.write_cstr(buf, len) + * finally: + * if pybuf_used: # <<<<<<<<<<<<<< + * cpython.PyBuffer_Release(&pybuf) + * + */ + /*finally:*/ { + /*normal exit:*/{ + __pyx_t_3 = (__pyx_v_pybuf_used != 0); + if (__pyx_t_3) { + + /* "asyncpg/protocol/codecs/bits.pyx":41 + * finally: + * if pybuf_used: + * cpython.PyBuffer_Release(&pybuf) # <<<<<<<<<<<<<< + * + * + */ + PyBuffer_Release((&__pyx_v_pybuf)); + + /* "asyncpg/protocol/codecs/bits.pyx":40 + * wbuf.write_cstr(buf, len) + * finally: + * if pybuf_used: # <<<<<<<<<<<<<< + * cpython.PyBuffer_Release(&pybuf) + * + */ + } + goto __pyx_L6; + } + /*exception exit:*/{ + __Pyx_PyThreadState_declare + __pyx_L5_error:; + __pyx_t_11 = 0; __pyx_t_12 = 0; __pyx_t_13 = 0; __pyx_t_14 = 0; __pyx_t_15 = 0; __pyx_t_16 = 0; + __Pyx_PyThreadState_assign + __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; + if (PY_MAJOR_VERSION >= 3) __Pyx_ExceptionSwap(&__pyx_t_14, &__pyx_t_15, &__pyx_t_16); + if ((PY_MAJOR_VERSION < 3) || unlikely(__Pyx_GetException(&__pyx_t_11, &__pyx_t_12, &__pyx_t_13) < 0)) __Pyx_ErrFetch(&__pyx_t_11, &__pyx_t_12, &__pyx_t_13); + __Pyx_XGOTREF(__pyx_t_11); + __Pyx_XGOTREF(__pyx_t_12); + __Pyx_XGOTREF(__pyx_t_13); + __Pyx_XGOTREF(__pyx_t_14); + __Pyx_XGOTREF(__pyx_t_15); + __Pyx_XGOTREF(__pyx_t_16); + __pyx_t_4 = __pyx_lineno; __pyx_t_9 = __pyx_clineno; __pyx_t_10 = __pyx_filename; + { + __pyx_t_3 = (__pyx_v_pybuf_used != 0); + if (__pyx_t_3) { + + /* "asyncpg/protocol/codecs/bits.pyx":41 + * finally: + * if pybuf_used: + * cpython.PyBuffer_Release(&pybuf) # <<<<<<<<<<<<<< + * + * + */ + PyBuffer_Release((&__pyx_v_pybuf)); + + /* "asyncpg/protocol/codecs/bits.pyx":40 + * wbuf.write_cstr(buf, len) + * finally: + * if pybuf_used: # <<<<<<<<<<<<<< + * cpython.PyBuffer_Release(&pybuf) + * + */ + } + } + __Pyx_PyThreadState_assign + if (PY_MAJOR_VERSION >= 3) { + __Pyx_XGIVEREF(__pyx_t_14); + __Pyx_XGIVEREF(__pyx_t_15); + __Pyx_XGIVEREF(__pyx_t_16); + __Pyx_ExceptionReset(__pyx_t_14, __pyx_t_15, __pyx_t_16); + } + __Pyx_XGIVEREF(__pyx_t_11); + __Pyx_XGIVEREF(__pyx_t_12); + __Pyx_XGIVEREF(__pyx_t_13); + __Pyx_ErrRestore(__pyx_t_11, __pyx_t_12, __pyx_t_13); + __pyx_t_11 = 0; __pyx_t_12 = 0; __pyx_t_13 = 0; __pyx_t_14 = 0; __pyx_t_15 = 0; __pyx_t_16 = 0; + __pyx_lineno = __pyx_t_4; __pyx_clineno = __pyx_t_9; __pyx_filename = __pyx_t_10; + goto __pyx_L1_error; + } + __pyx_L6:; + } + + /* "asyncpg/protocol/codecs/bits.pyx":11 + * + * + * cdef bits_encode(ConnectionSettings settings, WriteBuffer wbuf, obj): # <<<<<<<<<<<<<< + * cdef: + * Py_buffer pybuf + */ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_XDECREF(__pyx_t_6); + __Pyx_AddTraceback("asyncpg.protocol.protocol.bits_encode", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "asyncpg/protocol/codecs/bits.pyx":44 + * + * + * cdef bits_decode(ConnectionSettings settings, FastReadBuffer buf): # <<<<<<<<<<<<<< + * cdef: + * int32_t bitlen = hton.unpack_int32(buf.read(4)) + */ + +static PyObject *__pyx_f_7asyncpg_8protocol_8protocol_bits_decode(CYTHON_UNUSED struct __pyx_obj_7asyncpg_8protocol_8protocol_ConnectionSettings *__pyx_v_settings, struct __pyx_obj_7asyncpg_8protocol_8protocol_FastReadBuffer *__pyx_v_buf) { + int32_t __pyx_v_bitlen; + Py_ssize_t __pyx_v_buf_len; + PyObject *__pyx_v_bytes_ = NULL; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + char const *__pyx_t_1; + Py_ssize_t __pyx_t_2; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + PyObject *__pyx_t_5 = NULL; + PyObject *__pyx_t_6 = NULL; + int __pyx_t_7; + PyObject *__pyx_t_8 = NULL; + __Pyx_RefNannySetupContext("bits_decode", 0); + + /* "asyncpg/protocol/codecs/bits.pyx":46 + * cdef bits_decode(ConnectionSettings settings, FastReadBuffer buf): + * cdef: + * int32_t bitlen = hton.unpack_int32(buf.read(4)) # <<<<<<<<<<<<<< + * ssize_t buf_len = buf.len + * + */ + __pyx_t_1 = __pyx_f_7asyncpg_8protocol_8protocol_14FastReadBuffer_read(__pyx_v_buf, 4); if (unlikely(__pyx_t_1 == NULL)) __PYX_ERR(8, 46, __pyx_L1_error) + __pyx_v_bitlen = __pyx_f_7asyncpg_8protocol_4hton_unpack_int32(__pyx_t_1); + + /* "asyncpg/protocol/codecs/bits.pyx":47 + * cdef: + * int32_t bitlen = hton.unpack_int32(buf.read(4)) + * ssize_t buf_len = buf.len # <<<<<<<<<<<<<< + * + * bytes_ = cpython.PyBytes_FromStringAndSize(buf.read_all(), buf_len) + */ + __pyx_t_2 = __pyx_v_buf->len; + __pyx_v_buf_len = __pyx_t_2; + + /* "asyncpg/protocol/codecs/bits.pyx":49 + * ssize_t buf_len = buf.len + * + * bytes_ = cpython.PyBytes_FromStringAndSize(buf.read_all(), buf_len) # <<<<<<<<<<<<<< + * return BitString.frombytes(bytes_, bitlen) + * + */ + __pyx_t_3 = PyBytes_FromStringAndSize(__pyx_f_7asyncpg_8protocol_8protocol_14FastReadBuffer_read_all(__pyx_v_buf), __pyx_v_buf_len); if (unlikely(!__pyx_t_3)) __PYX_ERR(8, 49, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_v_bytes_ = ((PyObject*)__pyx_t_3); + __pyx_t_3 = 0; + + /* "asyncpg/protocol/codecs/bits.pyx":50 + * + * bytes_ = cpython.PyBytes_FromStringAndSize(buf.read_all(), buf_len) + * return BitString.frombytes(bytes_, bitlen) # <<<<<<<<<<<<<< + * + * + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_4 = __Pyx_GetModuleGlobalName(__pyx_n_s_BitString); if (unlikely(!__pyx_t_4)) __PYX_ERR(8, 50, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_n_s_frombytes); if (unlikely(!__pyx_t_5)) __PYX_ERR(8, 50, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_4 = __Pyx_PyInt_From_int32_t(__pyx_v_bitlen); if (unlikely(!__pyx_t_4)) __PYX_ERR(8, 50, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_6 = NULL; + __pyx_t_7 = 0; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_5))) { + __pyx_t_6 = PyMethod_GET_SELF(__pyx_t_5); + if (likely(__pyx_t_6)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_5); + __Pyx_INCREF(__pyx_t_6); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_5, function); + __pyx_t_7 = 1; + } + } + #if CYTHON_FAST_PYCALL + if (PyFunction_Check(__pyx_t_5)) { + PyObject *__pyx_temp[3] = {__pyx_t_6, __pyx_v_bytes_, __pyx_t_4}; + __pyx_t_3 = __Pyx_PyFunction_FastCall(__pyx_t_5, __pyx_temp+1-__pyx_t_7, 2+__pyx_t_7); if (unlikely(!__pyx_t_3)) __PYX_ERR(8, 50, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + } else + #endif + #if CYTHON_FAST_PYCCALL + if (__Pyx_PyFastCFunction_Check(__pyx_t_5)) { + PyObject *__pyx_temp[3] = {__pyx_t_6, __pyx_v_bytes_, __pyx_t_4}; + __pyx_t_3 = __Pyx_PyCFunction_FastCall(__pyx_t_5, __pyx_temp+1-__pyx_t_7, 2+__pyx_t_7); if (unlikely(!__pyx_t_3)) __PYX_ERR(8, 50, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + } else + #endif + { + __pyx_t_8 = PyTuple_New(2+__pyx_t_7); if (unlikely(!__pyx_t_8)) __PYX_ERR(8, 50, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + if (__pyx_t_6) { + __Pyx_GIVEREF(__pyx_t_6); PyTuple_SET_ITEM(__pyx_t_8, 0, __pyx_t_6); __pyx_t_6 = NULL; + } + __Pyx_INCREF(__pyx_v_bytes_); + __Pyx_GIVEREF(__pyx_v_bytes_); + PyTuple_SET_ITEM(__pyx_t_8, 0+__pyx_t_7, __pyx_v_bytes_); + __Pyx_GIVEREF(__pyx_t_4); + PyTuple_SET_ITEM(__pyx_t_8, 1+__pyx_t_7, __pyx_t_4); + __pyx_t_4 = 0; + __pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_5, __pyx_t_8, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(8, 50, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + } + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __pyx_r = __pyx_t_3; + __pyx_t_3 = 0; + goto __pyx_L0; + + /* "asyncpg/protocol/codecs/bits.pyx":44 + * + * + * cdef bits_decode(ConnectionSettings settings, FastReadBuffer buf): # <<<<<<<<<<<<<< + * cdef: + * int32_t bitlen = hton.unpack_int32(buf.read(4)) + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_XDECREF(__pyx_t_6); + __Pyx_XDECREF(__pyx_t_8); + __Pyx_AddTraceback("asyncpg.protocol.protocol.bits_decode", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XDECREF(__pyx_v_bytes_); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "asyncpg/protocol/codecs/bits.pyx":53 + * + * + * cdef init_bits_codecs(): # <<<<<<<<<<<<<< + * register_core_codec(BITOID, + * &bits_encode, + */ + +static PyObject *__pyx_f_7asyncpg_8protocol_8protocol_init_bits_codecs(void) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + __Pyx_RefNannySetupContext("init_bits_codecs", 0); + + /* "asyncpg/protocol/codecs/bits.pyx":54 + * + * cdef init_bits_codecs(): + * register_core_codec(BITOID, # <<<<<<<<<<<<<< + * &bits_encode, + * &bits_decode, + */ + __pyx_t_1 = __pyx_f_7asyncpg_8protocol_8protocol_register_core_codec(0x618, ((__pyx_t_7asyncpg_8protocol_8protocol_encode_func)(&__pyx_f_7asyncpg_8protocol_8protocol_bits_encode)), ((__pyx_t_7asyncpg_8protocol_8protocol_decode_func)(&__pyx_f_7asyncpg_8protocol_8protocol_bits_decode)), __pyx_e_7asyncpg_8protocol_8protocol_PG_FORMAT_BINARY); if (unlikely(!__pyx_t_1)) __PYX_ERR(8, 54, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "asyncpg/protocol/codecs/bits.pyx":59 + * PG_FORMAT_BINARY) + * + * register_core_codec(VARBITOID, # <<<<<<<<<<<<<< + * &bits_encode, + * &bits_decode, + */ + __pyx_t_1 = __pyx_f_7asyncpg_8protocol_8protocol_register_core_codec(0x61A, ((__pyx_t_7asyncpg_8protocol_8protocol_encode_func)(&__pyx_f_7asyncpg_8protocol_8protocol_bits_encode)), ((__pyx_t_7asyncpg_8protocol_8protocol_decode_func)(&__pyx_f_7asyncpg_8protocol_8protocol_bits_decode)), __pyx_e_7asyncpg_8protocol_8protocol_PG_FORMAT_BINARY); if (unlikely(!__pyx_t_1)) __PYX_ERR(8, 59, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "asyncpg/protocol/codecs/bits.pyx":53 + * + * + * cdef init_bits_codecs(): # <<<<<<<<<<<<<< + * register_core_codec(BITOID, + * &bits_encode, + */ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("asyncpg.protocol.protocol.init_bits_codecs", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "asyncpg/protocol/codecs/datetime.pyx":59 + * + * + * cdef inline _encode_time(WriteBuffer buf, int64_t seconds, # <<<<<<<<<<<<<< + * int32_t microseconds): + * # XXX: add support for double timestamps + */ + +static CYTHON_INLINE PyObject *__pyx_f_7asyncpg_8protocol_8protocol__encode_time(struct __pyx_obj_7asyncpg_8protocol_8protocol_WriteBuffer *__pyx_v_buf, int64_t __pyx_v_seconds, int32_t __pyx_v_microseconds) { + int64_t __pyx_v_ts; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + PyObject *__pyx_t_2 = NULL; + __Pyx_RefNannySetupContext("_encode_time", 0); + + /* "asyncpg/protocol/codecs/datetime.pyx":63 + * # XXX: add support for double timestamps + * # int64 timestamps, + * cdef int64_t ts = seconds * 1000000 + microseconds # <<<<<<<<<<<<<< + * + * if ts == infinity_datetime_ts: + */ + __pyx_v_ts = ((__pyx_v_seconds * 0xF4240) + __pyx_v_microseconds); + + /* "asyncpg/protocol/codecs/datetime.pyx":65 + * cdef int64_t ts = seconds * 1000000 + microseconds + * + * if ts == infinity_datetime_ts: # <<<<<<<<<<<<<< + * buf.write_int64(pg_time64_infinity) + * elif ts == negative_infinity_datetime_ts: + */ + __pyx_t_1 = ((__pyx_v_ts == __pyx_v_7asyncpg_8protocol_8protocol_infinity_datetime_ts) != 0); + if (__pyx_t_1) { + + /* "asyncpg/protocol/codecs/datetime.pyx":66 + * + * if ts == infinity_datetime_ts: + * buf.write_int64(pg_time64_infinity) # <<<<<<<<<<<<<< + * elif ts == negative_infinity_datetime_ts: + * buf.write_int64(pg_time64_negative_infinity) + */ + __pyx_t_2 = __pyx_f_7asyncpg_8protocol_8protocol_11WriteBuffer_write_int64(__pyx_v_buf, __pyx_v_7asyncpg_8protocol_8protocol_pg_time64_infinity); if (unlikely(!__pyx_t_2)) __PYX_ERR(9, 66, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "asyncpg/protocol/codecs/datetime.pyx":65 + * cdef int64_t ts = seconds * 1000000 + microseconds + * + * if ts == infinity_datetime_ts: # <<<<<<<<<<<<<< + * buf.write_int64(pg_time64_infinity) + * elif ts == negative_infinity_datetime_ts: + */ + goto __pyx_L3; + } + + /* "asyncpg/protocol/codecs/datetime.pyx":67 + * if ts == infinity_datetime_ts: + * buf.write_int64(pg_time64_infinity) + * elif ts == negative_infinity_datetime_ts: # <<<<<<<<<<<<<< + * buf.write_int64(pg_time64_negative_infinity) + * else: + */ + __pyx_t_1 = ((__pyx_v_ts == __pyx_v_7asyncpg_8protocol_8protocol_negative_infinity_datetime_ts) != 0); + if (__pyx_t_1) { + + /* "asyncpg/protocol/codecs/datetime.pyx":68 + * buf.write_int64(pg_time64_infinity) + * elif ts == negative_infinity_datetime_ts: + * buf.write_int64(pg_time64_negative_infinity) # <<<<<<<<<<<<<< + * else: + * buf.write_int64(ts) + */ + __pyx_t_2 = __pyx_f_7asyncpg_8protocol_8protocol_11WriteBuffer_write_int64(__pyx_v_buf, __pyx_v_7asyncpg_8protocol_8protocol_pg_time64_negative_infinity); if (unlikely(!__pyx_t_2)) __PYX_ERR(9, 68, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "asyncpg/protocol/codecs/datetime.pyx":67 + * if ts == infinity_datetime_ts: + * buf.write_int64(pg_time64_infinity) + * elif ts == negative_infinity_datetime_ts: # <<<<<<<<<<<<<< + * buf.write_int64(pg_time64_negative_infinity) + * else: + */ + goto __pyx_L3; + } + + /* "asyncpg/protocol/codecs/datetime.pyx":70 + * buf.write_int64(pg_time64_negative_infinity) + * else: + * buf.write_int64(ts) # <<<<<<<<<<<<<< + * + * + */ + /*else*/ { + __pyx_t_2 = __pyx_f_7asyncpg_8protocol_8protocol_11WriteBuffer_write_int64(__pyx_v_buf, __pyx_v_ts); if (unlikely(!__pyx_t_2)) __PYX_ERR(9, 70, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } + __pyx_L3:; + + /* "asyncpg/protocol/codecs/datetime.pyx":59 + * + * + * cdef inline _encode_time(WriteBuffer buf, int64_t seconds, # <<<<<<<<<<<<<< + * int32_t microseconds): + * # XXX: add support for double timestamps + */ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_2); + __Pyx_AddTraceback("asyncpg.protocol.protocol._encode_time", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "asyncpg/protocol/codecs/datetime.pyx":73 + * + * + * cdef inline int32_t _decode_time(FastReadBuffer buf, int64_t *seconds, # <<<<<<<<<<<<<< + * uint32_t *microseconds): + * # XXX: add support for double timestamps + */ + +static CYTHON_INLINE int32_t __pyx_f_7asyncpg_8protocol_8protocol__decode_time(struct __pyx_obj_7asyncpg_8protocol_8protocol_FastReadBuffer *__pyx_v_buf, int64_t *__pyx_v_seconds, uint32_t *__pyx_v_microseconds) { + int64_t __pyx_v_ts; + int32_t __pyx_r; + __Pyx_RefNannyDeclarations + char const *__pyx_t_1; + int __pyx_t_2; + __Pyx_RefNannySetupContext("_decode_time", 0); + + /* "asyncpg/protocol/codecs/datetime.pyx":77 + * # XXX: add support for double timestamps + * # int64 timestamps, + * cdef int64_t ts = hton.unpack_int64(buf.read(8)) # <<<<<<<<<<<<<< + * + * if ts == pg_time64_infinity: + */ + __pyx_t_1 = __pyx_f_7asyncpg_8protocol_8protocol_14FastReadBuffer_read(__pyx_v_buf, 8); if (unlikely(__pyx_t_1 == NULL)) __PYX_ERR(9, 77, __pyx_L1_error) + __pyx_v_ts = __pyx_f_7asyncpg_8protocol_4hton_unpack_int64(__pyx_t_1); + + /* "asyncpg/protocol/codecs/datetime.pyx":79 + * cdef int64_t ts = hton.unpack_int64(buf.read(8)) + * + * if ts == pg_time64_infinity: # <<<<<<<<<<<<<< + * return 1 + * elif ts == pg_time64_negative_infinity: + */ + __pyx_t_2 = ((__pyx_v_ts == __pyx_v_7asyncpg_8protocol_8protocol_pg_time64_infinity) != 0); + if (__pyx_t_2) { + + /* "asyncpg/protocol/codecs/datetime.pyx":80 + * + * if ts == pg_time64_infinity: + * return 1 # <<<<<<<<<<<<<< + * elif ts == pg_time64_negative_infinity: + * return -1 + */ + __pyx_r = 1; + goto __pyx_L0; + + /* "asyncpg/protocol/codecs/datetime.pyx":79 + * cdef int64_t ts = hton.unpack_int64(buf.read(8)) + * + * if ts == pg_time64_infinity: # <<<<<<<<<<<<<< + * return 1 + * elif ts == pg_time64_negative_infinity: + */ + } + + /* "asyncpg/protocol/codecs/datetime.pyx":81 + * if ts == pg_time64_infinity: + * return 1 + * elif ts == pg_time64_negative_infinity: # <<<<<<<<<<<<<< + * return -1 + * + */ + __pyx_t_2 = ((__pyx_v_ts == __pyx_v_7asyncpg_8protocol_8protocol_pg_time64_negative_infinity) != 0); + if (__pyx_t_2) { + + /* "asyncpg/protocol/codecs/datetime.pyx":82 + * return 1 + * elif ts == pg_time64_negative_infinity: + * return -1 # <<<<<<<<<<<<<< + * + * seconds[0] = (ts / 1000000) + */ + __pyx_r = -1; + goto __pyx_L0; + + /* "asyncpg/protocol/codecs/datetime.pyx":81 + * if ts == pg_time64_infinity: + * return 1 + * elif ts == pg_time64_negative_infinity: # <<<<<<<<<<<<<< + * return -1 + * + */ + } + + /* "asyncpg/protocol/codecs/datetime.pyx":84 + * return -1 + * + * seconds[0] = (ts / 1000000) # <<<<<<<<<<<<<< + * microseconds[0] = (ts % 1000000) + * + */ + (__pyx_v_seconds[0]) = ((int64_t)(((double)__pyx_v_ts) / 1000000.0)); + + /* "asyncpg/protocol/codecs/datetime.pyx":85 + * + * seconds[0] = (ts / 1000000) + * microseconds[0] = (ts % 1000000) # <<<<<<<<<<<<<< + * + * return 0 + */ + (__pyx_v_microseconds[0]) = ((uint32_t)__Pyx_mod_int64_t(__pyx_v_ts, 0xF4240)); + + /* "asyncpg/protocol/codecs/datetime.pyx":87 + * microseconds[0] = (ts % 1000000) + * + * return 0 # <<<<<<<<<<<<<< + * + * + */ + __pyx_r = 0; + goto __pyx_L0; + + /* "asyncpg/protocol/codecs/datetime.pyx":73 + * + * + * cdef inline int32_t _decode_time(FastReadBuffer buf, int64_t *seconds, # <<<<<<<<<<<<<< + * uint32_t *microseconds): + * # XXX: add support for double timestamps + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_WriteUnraisable("asyncpg.protocol.protocol._decode_time", __pyx_clineno, __pyx_lineno, __pyx_filename, 0, 0); + __pyx_r = 0; + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "asyncpg/protocol/codecs/datetime.pyx":90 + * + * + * cdef date_encode(ConnectionSettings settings, WriteBuffer buf, obj): # <<<<<<<<<<<<<< + * cdef: + * int32_t ordinal = cpython.PyLong_AsLong(obj.toordinal()) + */ + +static PyObject *__pyx_f_7asyncpg_8protocol_8protocol_date_encode(CYTHON_UNUSED struct __pyx_obj_7asyncpg_8protocol_8protocol_ConnectionSettings *__pyx_v_settings, struct __pyx_obj_7asyncpg_8protocol_8protocol_WriteBuffer *__pyx_v_buf, PyObject *__pyx_v_obj) { + int32_t __pyx_v_ordinal; + int32_t __pyx_v_pg_ordinal; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + long __pyx_t_4; + int __pyx_t_5; + __Pyx_RefNannySetupContext("date_encode", 0); + + /* "asyncpg/protocol/codecs/datetime.pyx":92 + * cdef date_encode(ConnectionSettings settings, WriteBuffer buf, obj): + * cdef: + * int32_t ordinal = cpython.PyLong_AsLong(obj.toordinal()) # <<<<<<<<<<<<<< + * int32_t pg_ordinal + * + */ + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_obj, __pyx_n_s_toordinal); if (unlikely(!__pyx_t_2)) __PYX_ERR(9, 92, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = NULL; + if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_3)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_3); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + } + } + if (__pyx_t_3) { + __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_3); if (unlikely(!__pyx_t_1)) __PYX_ERR(9, 92, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + } else { + __pyx_t_1 = __Pyx_PyObject_CallNoArg(__pyx_t_2); if (unlikely(!__pyx_t_1)) __PYX_ERR(9, 92, __pyx_L1_error) + } + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_4 = PyLong_AsLong(__pyx_t_1); if (unlikely(__pyx_t_4 == -1L && PyErr_Occurred())) __PYX_ERR(9, 92, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_v_ordinal = ((int32_t)__pyx_t_4); + + /* "asyncpg/protocol/codecs/datetime.pyx":95 + * int32_t pg_ordinal + * + * if ordinal == infinity_date_ord: # <<<<<<<<<<<<<< + * pg_ordinal = pg_date_infinity + * elif ordinal == negative_infinity_date_ord: + */ + __pyx_t_5 = ((__pyx_v_ordinal == __pyx_v_7asyncpg_8protocol_8protocol_infinity_date_ord) != 0); + if (__pyx_t_5) { + + /* "asyncpg/protocol/codecs/datetime.pyx":96 + * + * if ordinal == infinity_date_ord: + * pg_ordinal = pg_date_infinity # <<<<<<<<<<<<<< + * elif ordinal == negative_infinity_date_ord: + * pg_ordinal = pg_date_negative_infinity + */ + __pyx_v_pg_ordinal = __pyx_v_7asyncpg_8protocol_8protocol_pg_date_infinity; + + /* "asyncpg/protocol/codecs/datetime.pyx":95 + * int32_t pg_ordinal + * + * if ordinal == infinity_date_ord: # <<<<<<<<<<<<<< + * pg_ordinal = pg_date_infinity + * elif ordinal == negative_infinity_date_ord: + */ + goto __pyx_L3; + } + + /* "asyncpg/protocol/codecs/datetime.pyx":97 + * if ordinal == infinity_date_ord: + * pg_ordinal = pg_date_infinity + * elif ordinal == negative_infinity_date_ord: # <<<<<<<<<<<<<< + * pg_ordinal = pg_date_negative_infinity + * else: + */ + __pyx_t_5 = ((__pyx_v_ordinal == __pyx_v_7asyncpg_8protocol_8protocol_negative_infinity_date_ord) != 0); + if (__pyx_t_5) { + + /* "asyncpg/protocol/codecs/datetime.pyx":98 + * pg_ordinal = pg_date_infinity + * elif ordinal == negative_infinity_date_ord: + * pg_ordinal = pg_date_negative_infinity # <<<<<<<<<<<<<< + * else: + * pg_ordinal = ordinal - pg_date_offset_ord + */ + __pyx_v_pg_ordinal = __pyx_v_7asyncpg_8protocol_8protocol_pg_date_negative_infinity; + + /* "asyncpg/protocol/codecs/datetime.pyx":97 + * if ordinal == infinity_date_ord: + * pg_ordinal = pg_date_infinity + * elif ordinal == negative_infinity_date_ord: # <<<<<<<<<<<<<< + * pg_ordinal = pg_date_negative_infinity + * else: + */ + goto __pyx_L3; + } + + /* "asyncpg/protocol/codecs/datetime.pyx":100 + * pg_ordinal = pg_date_negative_infinity + * else: + * pg_ordinal = ordinal - pg_date_offset_ord # <<<<<<<<<<<<<< + * + * buf.write_int32(4) + */ + /*else*/ { + __pyx_v_pg_ordinal = (__pyx_v_ordinal - __pyx_v_7asyncpg_8protocol_8protocol_pg_date_offset_ord); + } + __pyx_L3:; + + /* "asyncpg/protocol/codecs/datetime.pyx":102 + * pg_ordinal = ordinal - pg_date_offset_ord + * + * buf.write_int32(4) # <<<<<<<<<<<<<< + * buf.write_int32(pg_ordinal) + * + */ + __pyx_t_1 = __pyx_f_7asyncpg_8protocol_8protocol_11WriteBuffer_write_int32(__pyx_v_buf, 4); if (unlikely(!__pyx_t_1)) __PYX_ERR(9, 102, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "asyncpg/protocol/codecs/datetime.pyx":103 + * + * buf.write_int32(4) + * buf.write_int32(pg_ordinal) # <<<<<<<<<<<<<< + * + * + */ + __pyx_t_1 = __pyx_f_7asyncpg_8protocol_8protocol_11WriteBuffer_write_int32(__pyx_v_buf, __pyx_v_pg_ordinal); if (unlikely(!__pyx_t_1)) __PYX_ERR(9, 103, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "asyncpg/protocol/codecs/datetime.pyx":90 + * + * + * cdef date_encode(ConnectionSettings settings, WriteBuffer buf, obj): # <<<<<<<<<<<<<< + * cdef: + * int32_t ordinal = cpython.PyLong_AsLong(obj.toordinal()) + */ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_AddTraceback("asyncpg.protocol.protocol.date_encode", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "asyncpg/protocol/codecs/datetime.pyx":106 + * + * + * cdef date_decode(ConnectionSettings settings, FastReadBuffer buf): # <<<<<<<<<<<<<< + * cdef int32_t pg_ordinal = hton.unpack_int32(buf.read(4)) + * + */ + +static PyObject *__pyx_f_7asyncpg_8protocol_8protocol_date_decode(CYTHON_UNUSED struct __pyx_obj_7asyncpg_8protocol_8protocol_ConnectionSettings *__pyx_v_settings, struct __pyx_obj_7asyncpg_8protocol_8protocol_FastReadBuffer *__pyx_v_buf) { + int32_t __pyx_v_pg_ordinal; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + char const *__pyx_t_1; + int __pyx_t_2; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + PyObject *__pyx_t_5 = NULL; + PyObject *__pyx_t_6 = NULL; + PyObject *__pyx_t_7 = NULL; + __Pyx_RefNannySetupContext("date_decode", 0); + + /* "asyncpg/protocol/codecs/datetime.pyx":107 + * + * cdef date_decode(ConnectionSettings settings, FastReadBuffer buf): + * cdef int32_t pg_ordinal = hton.unpack_int32(buf.read(4)) # <<<<<<<<<<<<<< + * + * if pg_ordinal == pg_date_infinity: + */ + __pyx_t_1 = __pyx_f_7asyncpg_8protocol_8protocol_14FastReadBuffer_read(__pyx_v_buf, 4); if (unlikely(__pyx_t_1 == NULL)) __PYX_ERR(9, 107, __pyx_L1_error) + __pyx_v_pg_ordinal = __pyx_f_7asyncpg_8protocol_4hton_unpack_int32(__pyx_t_1); + + /* "asyncpg/protocol/codecs/datetime.pyx":109 + * cdef int32_t pg_ordinal = hton.unpack_int32(buf.read(4)) + * + * if pg_ordinal == pg_date_infinity: # <<<<<<<<<<<<<< + * return infinity_date + * elif pg_ordinal == pg_date_negative_infinity: + */ + __pyx_t_2 = ((__pyx_v_pg_ordinal == __pyx_v_7asyncpg_8protocol_8protocol_pg_date_infinity) != 0); + if (__pyx_t_2) { + + /* "asyncpg/protocol/codecs/datetime.pyx":110 + * + * if pg_ordinal == pg_date_infinity: + * return infinity_date # <<<<<<<<<<<<<< + * elif pg_ordinal == pg_date_negative_infinity: + * return negative_infinity_date + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_3 = __Pyx_GetModuleGlobalName(__pyx_n_s_infinity_date); if (unlikely(!__pyx_t_3)) __PYX_ERR(9, 110, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_r = __pyx_t_3; + __pyx_t_3 = 0; + goto __pyx_L0; + + /* "asyncpg/protocol/codecs/datetime.pyx":109 + * cdef int32_t pg_ordinal = hton.unpack_int32(buf.read(4)) + * + * if pg_ordinal == pg_date_infinity: # <<<<<<<<<<<<<< + * return infinity_date + * elif pg_ordinal == pg_date_negative_infinity: + */ + } + + /* "asyncpg/protocol/codecs/datetime.pyx":111 + * if pg_ordinal == pg_date_infinity: + * return infinity_date + * elif pg_ordinal == pg_date_negative_infinity: # <<<<<<<<<<<<<< + * return negative_infinity_date + * else: + */ + __pyx_t_2 = ((__pyx_v_pg_ordinal == __pyx_v_7asyncpg_8protocol_8protocol_pg_date_negative_infinity) != 0); + if (__pyx_t_2) { + + /* "asyncpg/protocol/codecs/datetime.pyx":112 + * return infinity_date + * elif pg_ordinal == pg_date_negative_infinity: + * return negative_infinity_date # <<<<<<<<<<<<<< + * else: + * return date_from_ordinal(pg_ordinal + pg_date_offset_ord) + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_3 = __Pyx_GetModuleGlobalName(__pyx_n_s_negative_infinity_date); if (unlikely(!__pyx_t_3)) __PYX_ERR(9, 112, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_r = __pyx_t_3; + __pyx_t_3 = 0; + goto __pyx_L0; + + /* "asyncpg/protocol/codecs/datetime.pyx":111 + * if pg_ordinal == pg_date_infinity: + * return infinity_date + * elif pg_ordinal == pg_date_negative_infinity: # <<<<<<<<<<<<<< + * return negative_infinity_date + * else: + */ + } + + /* "asyncpg/protocol/codecs/datetime.pyx":114 + * return negative_infinity_date + * else: + * return date_from_ordinal(pg_ordinal + pg_date_offset_ord) # <<<<<<<<<<<<<< + * + * + */ + /*else*/ { + __Pyx_XDECREF(__pyx_r); + __pyx_t_4 = __Pyx_GetModuleGlobalName(__pyx_n_s_date_from_ordinal); if (unlikely(!__pyx_t_4)) __PYX_ERR(9, 114, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_5 = __Pyx_PyInt_From_int32_t((__pyx_v_pg_ordinal + __pyx_v_7asyncpg_8protocol_8protocol_pg_date_offset_ord)); if (unlikely(!__pyx_t_5)) __PYX_ERR(9, 114, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_6 = NULL; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_4))) { + __pyx_t_6 = PyMethod_GET_SELF(__pyx_t_4); + if (likely(__pyx_t_6)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4); + __Pyx_INCREF(__pyx_t_6); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_4, function); + } + } + if (!__pyx_t_6) { + __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_t_5); if (unlikely(!__pyx_t_3)) __PYX_ERR(9, 114, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_GOTREF(__pyx_t_3); + } else { + #if CYTHON_FAST_PYCALL + if (PyFunction_Check(__pyx_t_4)) { + PyObject *__pyx_temp[2] = {__pyx_t_6, __pyx_t_5}; + __pyx_t_3 = __Pyx_PyFunction_FastCall(__pyx_t_4, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_3)) __PYX_ERR(9, 114, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + } else + #endif + #if CYTHON_FAST_PYCCALL + if (__Pyx_PyFastCFunction_Check(__pyx_t_4)) { + PyObject *__pyx_temp[2] = {__pyx_t_6, __pyx_t_5}; + __pyx_t_3 = __Pyx_PyCFunction_FastCall(__pyx_t_4, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_3)) __PYX_ERR(9, 114, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + } else + #endif + { + __pyx_t_7 = PyTuple_New(1+1); if (unlikely(!__pyx_t_7)) __PYX_ERR(9, 114, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __Pyx_GIVEREF(__pyx_t_6); PyTuple_SET_ITEM(__pyx_t_7, 0, __pyx_t_6); __pyx_t_6 = NULL; + __Pyx_GIVEREF(__pyx_t_5); + PyTuple_SET_ITEM(__pyx_t_7, 0+1, __pyx_t_5); + __pyx_t_5 = 0; + __pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_4, __pyx_t_7, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(9, 114, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + } + } + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_r = __pyx_t_3; + __pyx_t_3 = 0; + goto __pyx_L0; + } + + /* "asyncpg/protocol/codecs/datetime.pyx":106 + * + * + * cdef date_decode(ConnectionSettings settings, FastReadBuffer buf): # <<<<<<<<<<<<<< + * cdef int32_t pg_ordinal = hton.unpack_int32(buf.read(4)) + * + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_XDECREF(__pyx_t_6); + __Pyx_XDECREF(__pyx_t_7); + __Pyx_AddTraceback("asyncpg.protocol.protocol.date_decode", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "asyncpg/protocol/codecs/datetime.pyx":117 + * + * + * cdef timestamp_encode(ConnectionSettings settings, WriteBuffer buf, obj): # <<<<<<<<<<<<<< + * delta = obj - pg_epoch_datetime + * cdef: + */ + +static PyObject *__pyx_f_7asyncpg_8protocol_8protocol_timestamp_encode(CYTHON_UNUSED struct __pyx_obj_7asyncpg_8protocol_8protocol_ConnectionSettings *__pyx_v_settings, struct __pyx_obj_7asyncpg_8protocol_8protocol_WriteBuffer *__pyx_v_buf, PyObject *__pyx_v_obj) { + PyObject *__pyx_v_delta = NULL; + int64_t __pyx_v_seconds; + int32_t __pyx_v_microseconds; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PY_LONG_LONG __pyx_t_3; + long __pyx_t_4; + __Pyx_RefNannySetupContext("timestamp_encode", 0); + + /* "asyncpg/protocol/codecs/datetime.pyx":118 + * + * cdef timestamp_encode(ConnectionSettings settings, WriteBuffer buf, obj): + * delta = obj - pg_epoch_datetime # <<<<<<<<<<<<<< + * cdef: + * int64_t seconds = cpython.PyLong_AsLongLong(delta.days) * 86400 + \ + */ + __pyx_t_1 = __Pyx_GetModuleGlobalName(__pyx_n_s_pg_epoch_datetime); if (unlikely(!__pyx_t_1)) __PYX_ERR(9, 118, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = PyNumber_Subtract(__pyx_v_obj, __pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(9, 118, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_v_delta = __pyx_t_2; + __pyx_t_2 = 0; + + /* "asyncpg/protocol/codecs/datetime.pyx":120 + * delta = obj - pg_epoch_datetime + * cdef: + * int64_t seconds = cpython.PyLong_AsLongLong(delta.days) * 86400 + \ # <<<<<<<<<<<<<< + * cpython.PyLong_AsLong(delta.seconds) + * int32_t microseconds = cpython.PyLong_AsLong( + */ + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_delta, __pyx_n_s_days); if (unlikely(!__pyx_t_2)) __PYX_ERR(9, 120, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = PyLong_AsLongLong(__pyx_t_2); if (unlikely(__pyx_t_3 == -1LL && PyErr_Occurred())) __PYX_ERR(9, 120, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "asyncpg/protocol/codecs/datetime.pyx":121 + * cdef: + * int64_t seconds = cpython.PyLong_AsLongLong(delta.days) * 86400 + \ + * cpython.PyLong_AsLong(delta.seconds) # <<<<<<<<<<<<<< + * int32_t microseconds = cpython.PyLong_AsLong( + * delta.microseconds) + */ + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_delta, __pyx_n_s_seconds); if (unlikely(!__pyx_t_2)) __PYX_ERR(9, 121, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_4 = PyLong_AsLong(__pyx_t_2); if (unlikely(__pyx_t_4 == -1L && PyErr_Occurred())) __PYX_ERR(9, 121, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "asyncpg/protocol/codecs/datetime.pyx":120 + * delta = obj - pg_epoch_datetime + * cdef: + * int64_t seconds = cpython.PyLong_AsLongLong(delta.days) * 86400 + \ # <<<<<<<<<<<<<< + * cpython.PyLong_AsLong(delta.seconds) + * int32_t microseconds = cpython.PyLong_AsLong( + */ + __pyx_v_seconds = ((__pyx_t_3 * 0x15180) + __pyx_t_4); + + /* "asyncpg/protocol/codecs/datetime.pyx":123 + * cpython.PyLong_AsLong(delta.seconds) + * int32_t microseconds = cpython.PyLong_AsLong( + * delta.microseconds) # <<<<<<<<<<<<<< + * + * buf.write_int32(8) + */ + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_delta, __pyx_n_s_microseconds); if (unlikely(!__pyx_t_2)) __PYX_ERR(9, 123, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + + /* "asyncpg/protocol/codecs/datetime.pyx":122 + * int64_t seconds = cpython.PyLong_AsLongLong(delta.days) * 86400 + \ + * cpython.PyLong_AsLong(delta.seconds) + * int32_t microseconds = cpython.PyLong_AsLong( # <<<<<<<<<<<<<< + * delta.microseconds) + * + */ + __pyx_t_4 = PyLong_AsLong(__pyx_t_2); if (unlikely(__pyx_t_4 == -1L && PyErr_Occurred())) __PYX_ERR(9, 122, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_v_microseconds = ((int32_t)__pyx_t_4); + + /* "asyncpg/protocol/codecs/datetime.pyx":125 + * delta.microseconds) + * + * buf.write_int32(8) # <<<<<<<<<<<<<< + * _encode_time(buf, seconds, microseconds) + * + */ + __pyx_t_2 = __pyx_f_7asyncpg_8protocol_8protocol_11WriteBuffer_write_int32(__pyx_v_buf, 8); if (unlikely(!__pyx_t_2)) __PYX_ERR(9, 125, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "asyncpg/protocol/codecs/datetime.pyx":126 + * + * buf.write_int32(8) + * _encode_time(buf, seconds, microseconds) # <<<<<<<<<<<<<< + * + * + */ + __pyx_t_2 = __pyx_f_7asyncpg_8protocol_8protocol__encode_time(__pyx_v_buf, __pyx_v_seconds, __pyx_v_microseconds); if (unlikely(!__pyx_t_2)) __PYX_ERR(9, 126, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "asyncpg/protocol/codecs/datetime.pyx":117 + * + * + * cdef timestamp_encode(ConnectionSettings settings, WriteBuffer buf, obj): # <<<<<<<<<<<<<< + * delta = obj - pg_epoch_datetime + * cdef: + */ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_AddTraceback("asyncpg.protocol.protocol.timestamp_encode", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XDECREF(__pyx_v_delta); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "asyncpg/protocol/codecs/datetime.pyx":129 + * + * + * cdef timestamp_decode(ConnectionSettings settings, FastReadBuffer buf): # <<<<<<<<<<<<<< + * cdef: + * int64_t seconds = 0 + */ + +static PyObject *__pyx_f_7asyncpg_8protocol_8protocol_timestamp_decode(CYTHON_UNUSED struct __pyx_obj_7asyncpg_8protocol_8protocol_ConnectionSettings *__pyx_v_settings, struct __pyx_obj_7asyncpg_8protocol_8protocol_FastReadBuffer *__pyx_v_buf) { + int64_t __pyx_v_seconds; + uint32_t __pyx_v_microseconds; + int32_t __pyx_v_inf; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + PyObject *__pyx_t_5 = NULL; + PyObject *__pyx_t_6 = NULL; + PyObject *__pyx_t_7 = NULL; + PyObject *__pyx_t_8 = NULL; + int __pyx_t_9; + PyObject *__pyx_t_10 = NULL; + __Pyx_RefNannySetupContext("timestamp_decode", 0); + + /* "asyncpg/protocol/codecs/datetime.pyx":131 + * cdef timestamp_decode(ConnectionSettings settings, FastReadBuffer buf): + * cdef: + * int64_t seconds = 0 # <<<<<<<<<<<<<< + * uint32_t microseconds = 0 + * int32_t inf = _decode_time(buf, &seconds, µseconds) + */ + __pyx_v_seconds = 0; + + /* "asyncpg/protocol/codecs/datetime.pyx":132 + * cdef: + * int64_t seconds = 0 + * uint32_t microseconds = 0 # <<<<<<<<<<<<<< + * int32_t inf = _decode_time(buf, &seconds, µseconds) + * + */ + __pyx_v_microseconds = 0; + + /* "asyncpg/protocol/codecs/datetime.pyx":133 + * int64_t seconds = 0 + * uint32_t microseconds = 0 + * int32_t inf = _decode_time(buf, &seconds, µseconds) # <<<<<<<<<<<<<< + * + * if inf > 0: + */ + __pyx_v_inf = __pyx_f_7asyncpg_8protocol_8protocol__decode_time(__pyx_v_buf, (&__pyx_v_seconds), (&__pyx_v_microseconds)); + + /* "asyncpg/protocol/codecs/datetime.pyx":135 + * int32_t inf = _decode_time(buf, &seconds, µseconds) + * + * if inf > 0: # <<<<<<<<<<<<<< + * # positive infinity + * return infinity_datetime + */ + __pyx_t_1 = ((__pyx_v_inf > 0) != 0); + if (__pyx_t_1) { + + /* "asyncpg/protocol/codecs/datetime.pyx":137 + * if inf > 0: + * # positive infinity + * return infinity_datetime # <<<<<<<<<<<<<< + * elif inf < 0: + * # negative infinity + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_2 = __Pyx_GetModuleGlobalName(__pyx_n_s_infinity_datetime); if (unlikely(!__pyx_t_2)) __PYX_ERR(9, 137, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_r = __pyx_t_2; + __pyx_t_2 = 0; + goto __pyx_L0; + + /* "asyncpg/protocol/codecs/datetime.pyx":135 + * int32_t inf = _decode_time(buf, &seconds, µseconds) + * + * if inf > 0: # <<<<<<<<<<<<<< + * # positive infinity + * return infinity_datetime + */ + } + + /* "asyncpg/protocol/codecs/datetime.pyx":138 + * # positive infinity + * return infinity_datetime + * elif inf < 0: # <<<<<<<<<<<<<< + * # negative infinity + * return negative_infinity_datetime + */ + __pyx_t_1 = ((__pyx_v_inf < 0) != 0); + if (__pyx_t_1) { + + /* "asyncpg/protocol/codecs/datetime.pyx":140 + * elif inf < 0: + * # negative infinity + * return negative_infinity_datetime # <<<<<<<<<<<<<< + * else: + * return pg_epoch_datetime.__add__( + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_2 = __Pyx_GetModuleGlobalName(__pyx_n_s_negative_infinity_datetime); if (unlikely(!__pyx_t_2)) __PYX_ERR(9, 140, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_r = __pyx_t_2; + __pyx_t_2 = 0; + goto __pyx_L0; + + /* "asyncpg/protocol/codecs/datetime.pyx":138 + * # positive infinity + * return infinity_datetime + * elif inf < 0: # <<<<<<<<<<<<<< + * # negative infinity + * return negative_infinity_datetime + */ + } + + /* "asyncpg/protocol/codecs/datetime.pyx":142 + * return negative_infinity_datetime + * else: + * return pg_epoch_datetime.__add__( # <<<<<<<<<<<<<< + * timedelta(0, seconds, microseconds)) + * + */ + /*else*/ { + __Pyx_XDECREF(__pyx_r); + __pyx_t_3 = __Pyx_GetModuleGlobalName(__pyx_n_s_pg_epoch_datetime); if (unlikely(!__pyx_t_3)) __PYX_ERR(9, 142, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_add); if (unlikely(!__pyx_t_4)) __PYX_ERR(9, 142, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + + /* "asyncpg/protocol/codecs/datetime.pyx":143 + * else: + * return pg_epoch_datetime.__add__( + * timedelta(0, seconds, microseconds)) # <<<<<<<<<<<<<< + * + * + */ + __pyx_t_5 = __Pyx_GetModuleGlobalName(__pyx_n_s_timedelta); if (unlikely(!__pyx_t_5)) __PYX_ERR(9, 143, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_6 = __Pyx_PyInt_From_int64_t(__pyx_v_seconds); if (unlikely(!__pyx_t_6)) __PYX_ERR(9, 143, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_7 = __Pyx_PyInt_From_uint32_t(__pyx_v_microseconds); if (unlikely(!__pyx_t_7)) __PYX_ERR(9, 143, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __pyx_t_8 = NULL; + __pyx_t_9 = 0; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_5))) { + __pyx_t_8 = PyMethod_GET_SELF(__pyx_t_5); + if (likely(__pyx_t_8)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_5); + __Pyx_INCREF(__pyx_t_8); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_5, function); + __pyx_t_9 = 1; + } + } + #if CYTHON_FAST_PYCALL + if (PyFunction_Check(__pyx_t_5)) { + PyObject *__pyx_temp[4] = {__pyx_t_8, __pyx_int_0, __pyx_t_6, __pyx_t_7}; + __pyx_t_3 = __Pyx_PyFunction_FastCall(__pyx_t_5, __pyx_temp+1-__pyx_t_9, 3+__pyx_t_9); if (unlikely(!__pyx_t_3)) __PYX_ERR(9, 143, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + } else + #endif + #if CYTHON_FAST_PYCCALL + if (__Pyx_PyFastCFunction_Check(__pyx_t_5)) { + PyObject *__pyx_temp[4] = {__pyx_t_8, __pyx_int_0, __pyx_t_6, __pyx_t_7}; + __pyx_t_3 = __Pyx_PyCFunction_FastCall(__pyx_t_5, __pyx_temp+1-__pyx_t_9, 3+__pyx_t_9); if (unlikely(!__pyx_t_3)) __PYX_ERR(9, 143, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + } else + #endif + { + __pyx_t_10 = PyTuple_New(3+__pyx_t_9); if (unlikely(!__pyx_t_10)) __PYX_ERR(9, 143, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_10); + if (__pyx_t_8) { + __Pyx_GIVEREF(__pyx_t_8); PyTuple_SET_ITEM(__pyx_t_10, 0, __pyx_t_8); __pyx_t_8 = NULL; + } + __Pyx_INCREF(__pyx_int_0); + __Pyx_GIVEREF(__pyx_int_0); + PyTuple_SET_ITEM(__pyx_t_10, 0+__pyx_t_9, __pyx_int_0); + __Pyx_GIVEREF(__pyx_t_6); + PyTuple_SET_ITEM(__pyx_t_10, 1+__pyx_t_9, __pyx_t_6); + __Pyx_GIVEREF(__pyx_t_7); + PyTuple_SET_ITEM(__pyx_t_10, 2+__pyx_t_9, __pyx_t_7); + __pyx_t_6 = 0; + __pyx_t_7 = 0; + __pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_5, __pyx_t_10, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(9, 143, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; + } + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __pyx_t_5 = NULL; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_4))) { + __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_4); + if (likely(__pyx_t_5)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4); + __Pyx_INCREF(__pyx_t_5); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_4, function); + } + } + if (!__pyx_t_5) { + __pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_t_3); if (unlikely(!__pyx_t_2)) __PYX_ERR(9, 142, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_GOTREF(__pyx_t_2); + } else { + #if CYTHON_FAST_PYCALL + if (PyFunction_Check(__pyx_t_4)) { + PyObject *__pyx_temp[2] = {__pyx_t_5, __pyx_t_3}; + __pyx_t_2 = __Pyx_PyFunction_FastCall(__pyx_t_4, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_2)) __PYX_ERR(9, 142, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + } else + #endif + #if CYTHON_FAST_PYCCALL + if (__Pyx_PyFastCFunction_Check(__pyx_t_4)) { + PyObject *__pyx_temp[2] = {__pyx_t_5, __pyx_t_3}; + __pyx_t_2 = __Pyx_PyCFunction_FastCall(__pyx_t_4, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_2)) __PYX_ERR(9, 142, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + } else + #endif + { + __pyx_t_10 = PyTuple_New(1+1); if (unlikely(!__pyx_t_10)) __PYX_ERR(9, 142, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_10); + __Pyx_GIVEREF(__pyx_t_5); PyTuple_SET_ITEM(__pyx_t_10, 0, __pyx_t_5); __pyx_t_5 = NULL; + __Pyx_GIVEREF(__pyx_t_3); + PyTuple_SET_ITEM(__pyx_t_10, 0+1, __pyx_t_3); + __pyx_t_3 = 0; + __pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_4, __pyx_t_10, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(9, 142, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; + } + } + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_r = __pyx_t_2; + __pyx_t_2 = 0; + goto __pyx_L0; + } + + /* "asyncpg/protocol/codecs/datetime.pyx":129 + * + * + * cdef timestamp_decode(ConnectionSettings settings, FastReadBuffer buf): # <<<<<<<<<<<<<< + * cdef: + * int64_t seconds = 0 + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_XDECREF(__pyx_t_6); + __Pyx_XDECREF(__pyx_t_7); + __Pyx_XDECREF(__pyx_t_8); + __Pyx_XDECREF(__pyx_t_10); + __Pyx_AddTraceback("asyncpg.protocol.protocol.timestamp_decode", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "asyncpg/protocol/codecs/datetime.pyx":146 + * + * + * cdef timestamptz_encode(ConnectionSettings settings, WriteBuffer buf, obj): # <<<<<<<<<<<<<< + * buf.write_int32(8) + * + */ + +static PyObject *__pyx_f_7asyncpg_8protocol_8protocol_timestamptz_encode(CYTHON_UNUSED struct __pyx_obj_7asyncpg_8protocol_8protocol_ConnectionSettings *__pyx_v_settings, struct __pyx_obj_7asyncpg_8protocol_8protocol_WriteBuffer *__pyx_v_buf, PyObject *__pyx_v_obj) { + PyObject *__pyx_v_delta = NULL; + int64_t __pyx_v_seconds; + int32_t __pyx_v_microseconds; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + int __pyx_t_3; + PyObject *__pyx_t_4 = NULL; + PyObject *__pyx_t_5 = NULL; + PyObject *__pyx_t_6 = NULL; + PY_LONG_LONG __pyx_t_7; + long __pyx_t_8; + __Pyx_RefNannySetupContext("timestamptz_encode", 0); + + /* "asyncpg/protocol/codecs/datetime.pyx":147 + * + * cdef timestamptz_encode(ConnectionSettings settings, WriteBuffer buf, obj): + * buf.write_int32(8) # <<<<<<<<<<<<<< + * + * if obj == infinity_datetime: + */ + __pyx_t_1 = __pyx_f_7asyncpg_8protocol_8protocol_11WriteBuffer_write_int32(__pyx_v_buf, 8); if (unlikely(!__pyx_t_1)) __PYX_ERR(9, 147, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "asyncpg/protocol/codecs/datetime.pyx":149 + * buf.write_int32(8) + * + * if obj == infinity_datetime: # <<<<<<<<<<<<<< + * buf.write_int64(pg_time64_infinity) + * return + */ + __pyx_t_1 = __Pyx_GetModuleGlobalName(__pyx_n_s_infinity_datetime); if (unlikely(!__pyx_t_1)) __PYX_ERR(9, 149, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = PyObject_RichCompare(__pyx_v_obj, __pyx_t_1, Py_EQ); __Pyx_XGOTREF(__pyx_t_2); if (unlikely(!__pyx_t_2)) __PYX_ERR(9, 149, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_3 = __Pyx_PyObject_IsTrue(__pyx_t_2); if (unlikely(__pyx_t_3 < 0)) __PYX_ERR(9, 149, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + if (__pyx_t_3) { + + /* "asyncpg/protocol/codecs/datetime.pyx":150 + * + * if obj == infinity_datetime: + * buf.write_int64(pg_time64_infinity) # <<<<<<<<<<<<<< + * return + * elif obj == negative_infinity_datetime: + */ + __pyx_t_2 = __pyx_f_7asyncpg_8protocol_8protocol_11WriteBuffer_write_int64(__pyx_v_buf, __pyx_v_7asyncpg_8protocol_8protocol_pg_time64_infinity); if (unlikely(!__pyx_t_2)) __PYX_ERR(9, 150, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "asyncpg/protocol/codecs/datetime.pyx":151 + * if obj == infinity_datetime: + * buf.write_int64(pg_time64_infinity) + * return # <<<<<<<<<<<<<< + * elif obj == negative_infinity_datetime: + * buf.write_int64(pg_time64_negative_infinity) + */ + __Pyx_XDECREF(__pyx_r); + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + + /* "asyncpg/protocol/codecs/datetime.pyx":149 + * buf.write_int32(8) + * + * if obj == infinity_datetime: # <<<<<<<<<<<<<< + * buf.write_int64(pg_time64_infinity) + * return + */ + } + + /* "asyncpg/protocol/codecs/datetime.pyx":152 + * buf.write_int64(pg_time64_infinity) + * return + * elif obj == negative_infinity_datetime: # <<<<<<<<<<<<<< + * buf.write_int64(pg_time64_negative_infinity) + * return + */ + __pyx_t_2 = __Pyx_GetModuleGlobalName(__pyx_n_s_negative_infinity_datetime); if (unlikely(!__pyx_t_2)) __PYX_ERR(9, 152, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_1 = PyObject_RichCompare(__pyx_v_obj, __pyx_t_2, Py_EQ); __Pyx_XGOTREF(__pyx_t_1); if (unlikely(!__pyx_t_1)) __PYX_ERR(9, 152, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_3 = __Pyx_PyObject_IsTrue(__pyx_t_1); if (unlikely(__pyx_t_3 < 0)) __PYX_ERR(9, 152, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + if (__pyx_t_3) { + + /* "asyncpg/protocol/codecs/datetime.pyx":153 + * return + * elif obj == negative_infinity_datetime: + * buf.write_int64(pg_time64_negative_infinity) # <<<<<<<<<<<<<< + * return + * + */ + __pyx_t_1 = __pyx_f_7asyncpg_8protocol_8protocol_11WriteBuffer_write_int64(__pyx_v_buf, __pyx_v_7asyncpg_8protocol_8protocol_pg_time64_negative_infinity); if (unlikely(!__pyx_t_1)) __PYX_ERR(9, 153, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "asyncpg/protocol/codecs/datetime.pyx":154 + * elif obj == negative_infinity_datetime: + * buf.write_int64(pg_time64_negative_infinity) + * return # <<<<<<<<<<<<<< + * + * delta = obj.astimezone(utc) - pg_epoch_datetime_utc + */ + __Pyx_XDECREF(__pyx_r); + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + + /* "asyncpg/protocol/codecs/datetime.pyx":152 + * buf.write_int64(pg_time64_infinity) + * return + * elif obj == negative_infinity_datetime: # <<<<<<<<<<<<<< + * buf.write_int64(pg_time64_negative_infinity) + * return + */ + } + + /* "asyncpg/protocol/codecs/datetime.pyx":156 + * return + * + * delta = obj.astimezone(utc) - pg_epoch_datetime_utc # <<<<<<<<<<<<<< + * cdef: + * int64_t seconds = cpython.PyLong_AsLongLong(delta.days) * 86400 + \ + */ + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_obj, __pyx_n_s_astimezone); if (unlikely(!__pyx_t_2)) __PYX_ERR(9, 156, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_4 = __Pyx_GetModuleGlobalName(__pyx_n_s_utc); if (unlikely(!__pyx_t_4)) __PYX_ERR(9, 156, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_5 = NULL; + if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_5)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_5); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + } + } + if (!__pyx_t_5) { + __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_4); if (unlikely(!__pyx_t_1)) __PYX_ERR(9, 156, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_GOTREF(__pyx_t_1); + } else { + #if CYTHON_FAST_PYCALL + if (PyFunction_Check(__pyx_t_2)) { + PyObject *__pyx_temp[2] = {__pyx_t_5, __pyx_t_4}; + __pyx_t_1 = __Pyx_PyFunction_FastCall(__pyx_t_2, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_1)) __PYX_ERR(9, 156, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + } else + #endif + #if CYTHON_FAST_PYCCALL + if (__Pyx_PyFastCFunction_Check(__pyx_t_2)) { + PyObject *__pyx_temp[2] = {__pyx_t_5, __pyx_t_4}; + __pyx_t_1 = __Pyx_PyCFunction_FastCall(__pyx_t_2, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_1)) __PYX_ERR(9, 156, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + } else + #endif + { + __pyx_t_6 = PyTuple_New(1+1); if (unlikely(!__pyx_t_6)) __PYX_ERR(9, 156, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_GIVEREF(__pyx_t_5); PyTuple_SET_ITEM(__pyx_t_6, 0, __pyx_t_5); __pyx_t_5 = NULL; + __Pyx_GIVEREF(__pyx_t_4); + PyTuple_SET_ITEM(__pyx_t_6, 0+1, __pyx_t_4); + __pyx_t_4 = 0; + __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_t_6, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(9, 156, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + } + } + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_2 = __Pyx_GetModuleGlobalName(__pyx_n_s_pg_epoch_datetime_utc); if (unlikely(!__pyx_t_2)) __PYX_ERR(9, 156, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_6 = PyNumber_Subtract(__pyx_t_1, __pyx_t_2); if (unlikely(!__pyx_t_6)) __PYX_ERR(9, 156, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_v_delta = __pyx_t_6; + __pyx_t_6 = 0; + + /* "asyncpg/protocol/codecs/datetime.pyx":158 + * delta = obj.astimezone(utc) - pg_epoch_datetime_utc + * cdef: + * int64_t seconds = cpython.PyLong_AsLongLong(delta.days) * 86400 + \ # <<<<<<<<<<<<<< + * cpython.PyLong_AsLong(delta.seconds) + * int32_t microseconds = cpython.PyLong_AsLong( + */ + __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_v_delta, __pyx_n_s_days); if (unlikely(!__pyx_t_6)) __PYX_ERR(9, 158, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_7 = PyLong_AsLongLong(__pyx_t_6); if (unlikely(__pyx_t_7 == -1LL && PyErr_Occurred())) __PYX_ERR(9, 158, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + + /* "asyncpg/protocol/codecs/datetime.pyx":159 + * cdef: + * int64_t seconds = cpython.PyLong_AsLongLong(delta.days) * 86400 + \ + * cpython.PyLong_AsLong(delta.seconds) # <<<<<<<<<<<<<< + * int32_t microseconds = cpython.PyLong_AsLong( + * delta.microseconds) + */ + __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_v_delta, __pyx_n_s_seconds); if (unlikely(!__pyx_t_6)) __PYX_ERR(9, 159, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_8 = PyLong_AsLong(__pyx_t_6); if (unlikely(__pyx_t_8 == -1L && PyErr_Occurred())) __PYX_ERR(9, 159, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + + /* "asyncpg/protocol/codecs/datetime.pyx":158 + * delta = obj.astimezone(utc) - pg_epoch_datetime_utc + * cdef: + * int64_t seconds = cpython.PyLong_AsLongLong(delta.days) * 86400 + \ # <<<<<<<<<<<<<< + * cpython.PyLong_AsLong(delta.seconds) + * int32_t microseconds = cpython.PyLong_AsLong( + */ + __pyx_v_seconds = ((__pyx_t_7 * 0x15180) + __pyx_t_8); + + /* "asyncpg/protocol/codecs/datetime.pyx":161 + * cpython.PyLong_AsLong(delta.seconds) + * int32_t microseconds = cpython.PyLong_AsLong( + * delta.microseconds) # <<<<<<<<<<<<<< + * + * _encode_time(buf, seconds, microseconds) + */ + __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_v_delta, __pyx_n_s_microseconds); if (unlikely(!__pyx_t_6)) __PYX_ERR(9, 161, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + + /* "asyncpg/protocol/codecs/datetime.pyx":160 + * int64_t seconds = cpython.PyLong_AsLongLong(delta.days) * 86400 + \ + * cpython.PyLong_AsLong(delta.seconds) + * int32_t microseconds = cpython.PyLong_AsLong( # <<<<<<<<<<<<<< + * delta.microseconds) + * + */ + __pyx_t_8 = PyLong_AsLong(__pyx_t_6); if (unlikely(__pyx_t_8 == -1L && PyErr_Occurred())) __PYX_ERR(9, 160, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __pyx_v_microseconds = ((int32_t)__pyx_t_8); + + /* "asyncpg/protocol/codecs/datetime.pyx":163 + * delta.microseconds) + * + * _encode_time(buf, seconds, microseconds) # <<<<<<<<<<<<<< + * + * + */ + __pyx_t_6 = __pyx_f_7asyncpg_8protocol_8protocol__encode_time(__pyx_v_buf, __pyx_v_seconds, __pyx_v_microseconds); if (unlikely(!__pyx_t_6)) __PYX_ERR(9, 163, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + + /* "asyncpg/protocol/codecs/datetime.pyx":146 + * + * + * cdef timestamptz_encode(ConnectionSettings settings, WriteBuffer buf, obj): # <<<<<<<<<<<<<< + * buf.write_int32(8) + * + */ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_XDECREF(__pyx_t_6); + __Pyx_AddTraceback("asyncpg.protocol.protocol.timestamptz_encode", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XDECREF(__pyx_v_delta); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "asyncpg/protocol/codecs/datetime.pyx":166 + * + * + * cdef timestamptz_decode(ConnectionSettings settings, FastReadBuffer buf): # <<<<<<<<<<<<<< + * cdef: + * int64_t seconds = 0 + */ + +static PyObject *__pyx_f_7asyncpg_8protocol_8protocol_timestamptz_decode(CYTHON_UNUSED struct __pyx_obj_7asyncpg_8protocol_8protocol_ConnectionSettings *__pyx_v_settings, struct __pyx_obj_7asyncpg_8protocol_8protocol_FastReadBuffer *__pyx_v_buf) { + int64_t __pyx_v_seconds; + uint32_t __pyx_v_microseconds; + int32_t __pyx_v_inf; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + PyObject *__pyx_t_5 = NULL; + PyObject *__pyx_t_6 = NULL; + PyObject *__pyx_t_7 = NULL; + PyObject *__pyx_t_8 = NULL; + int __pyx_t_9; + PyObject *__pyx_t_10 = NULL; + __Pyx_RefNannySetupContext("timestamptz_decode", 0); + + /* "asyncpg/protocol/codecs/datetime.pyx":168 + * cdef timestamptz_decode(ConnectionSettings settings, FastReadBuffer buf): + * cdef: + * int64_t seconds = 0 # <<<<<<<<<<<<<< + * uint32_t microseconds = 0 + * int32_t inf = _decode_time(buf, &seconds, µseconds) + */ + __pyx_v_seconds = 0; + + /* "asyncpg/protocol/codecs/datetime.pyx":169 + * cdef: + * int64_t seconds = 0 + * uint32_t microseconds = 0 # <<<<<<<<<<<<<< + * int32_t inf = _decode_time(buf, &seconds, µseconds) + * + */ + __pyx_v_microseconds = 0; + + /* "asyncpg/protocol/codecs/datetime.pyx":170 + * int64_t seconds = 0 + * uint32_t microseconds = 0 + * int32_t inf = _decode_time(buf, &seconds, µseconds) # <<<<<<<<<<<<<< + * + * if inf > 0: + */ + __pyx_v_inf = __pyx_f_7asyncpg_8protocol_8protocol__decode_time(__pyx_v_buf, (&__pyx_v_seconds), (&__pyx_v_microseconds)); + + /* "asyncpg/protocol/codecs/datetime.pyx":172 + * int32_t inf = _decode_time(buf, &seconds, µseconds) + * + * if inf > 0: # <<<<<<<<<<<<<< + * # positive infinity + * return infinity_datetime + */ + __pyx_t_1 = ((__pyx_v_inf > 0) != 0); + if (__pyx_t_1) { + + /* "asyncpg/protocol/codecs/datetime.pyx":174 + * if inf > 0: + * # positive infinity + * return infinity_datetime # <<<<<<<<<<<<<< + * elif inf < 0: + * # negative infinity + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_2 = __Pyx_GetModuleGlobalName(__pyx_n_s_infinity_datetime); if (unlikely(!__pyx_t_2)) __PYX_ERR(9, 174, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_r = __pyx_t_2; + __pyx_t_2 = 0; + goto __pyx_L0; + + /* "asyncpg/protocol/codecs/datetime.pyx":172 + * int32_t inf = _decode_time(buf, &seconds, µseconds) + * + * if inf > 0: # <<<<<<<<<<<<<< + * # positive infinity + * return infinity_datetime + */ + } + + /* "asyncpg/protocol/codecs/datetime.pyx":175 + * # positive infinity + * return infinity_datetime + * elif inf < 0: # <<<<<<<<<<<<<< + * # negative infinity + * return negative_infinity_datetime + */ + __pyx_t_1 = ((__pyx_v_inf < 0) != 0); + if (__pyx_t_1) { + + /* "asyncpg/protocol/codecs/datetime.pyx":177 + * elif inf < 0: + * # negative infinity + * return negative_infinity_datetime # <<<<<<<<<<<<<< + * else: + * return pg_epoch_datetime_utc.__add__( + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_2 = __Pyx_GetModuleGlobalName(__pyx_n_s_negative_infinity_datetime); if (unlikely(!__pyx_t_2)) __PYX_ERR(9, 177, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_r = __pyx_t_2; + __pyx_t_2 = 0; + goto __pyx_L0; + + /* "asyncpg/protocol/codecs/datetime.pyx":175 + * # positive infinity + * return infinity_datetime + * elif inf < 0: # <<<<<<<<<<<<<< + * # negative infinity + * return negative_infinity_datetime + */ + } + + /* "asyncpg/protocol/codecs/datetime.pyx":179 + * return negative_infinity_datetime + * else: + * return pg_epoch_datetime_utc.__add__( # <<<<<<<<<<<<<< + * timedelta(0, seconds, microseconds)) + * + */ + /*else*/ { + __Pyx_XDECREF(__pyx_r); + __pyx_t_3 = __Pyx_GetModuleGlobalName(__pyx_n_s_pg_epoch_datetime_utc); if (unlikely(!__pyx_t_3)) __PYX_ERR(9, 179, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_add); if (unlikely(!__pyx_t_4)) __PYX_ERR(9, 179, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + + /* "asyncpg/protocol/codecs/datetime.pyx":180 + * else: + * return pg_epoch_datetime_utc.__add__( + * timedelta(0, seconds, microseconds)) # <<<<<<<<<<<<<< + * + * + */ + __pyx_t_5 = __Pyx_GetModuleGlobalName(__pyx_n_s_timedelta); if (unlikely(!__pyx_t_5)) __PYX_ERR(9, 180, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_6 = __Pyx_PyInt_From_int64_t(__pyx_v_seconds); if (unlikely(!__pyx_t_6)) __PYX_ERR(9, 180, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_7 = __Pyx_PyInt_From_uint32_t(__pyx_v_microseconds); if (unlikely(!__pyx_t_7)) __PYX_ERR(9, 180, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __pyx_t_8 = NULL; + __pyx_t_9 = 0; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_5))) { + __pyx_t_8 = PyMethod_GET_SELF(__pyx_t_5); + if (likely(__pyx_t_8)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_5); + __Pyx_INCREF(__pyx_t_8); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_5, function); + __pyx_t_9 = 1; + } + } + #if CYTHON_FAST_PYCALL + if (PyFunction_Check(__pyx_t_5)) { + PyObject *__pyx_temp[4] = {__pyx_t_8, __pyx_int_0, __pyx_t_6, __pyx_t_7}; + __pyx_t_3 = __Pyx_PyFunction_FastCall(__pyx_t_5, __pyx_temp+1-__pyx_t_9, 3+__pyx_t_9); if (unlikely(!__pyx_t_3)) __PYX_ERR(9, 180, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + } else + #endif + #if CYTHON_FAST_PYCCALL + if (__Pyx_PyFastCFunction_Check(__pyx_t_5)) { + PyObject *__pyx_temp[4] = {__pyx_t_8, __pyx_int_0, __pyx_t_6, __pyx_t_7}; + __pyx_t_3 = __Pyx_PyCFunction_FastCall(__pyx_t_5, __pyx_temp+1-__pyx_t_9, 3+__pyx_t_9); if (unlikely(!__pyx_t_3)) __PYX_ERR(9, 180, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + } else + #endif + { + __pyx_t_10 = PyTuple_New(3+__pyx_t_9); if (unlikely(!__pyx_t_10)) __PYX_ERR(9, 180, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_10); + if (__pyx_t_8) { + __Pyx_GIVEREF(__pyx_t_8); PyTuple_SET_ITEM(__pyx_t_10, 0, __pyx_t_8); __pyx_t_8 = NULL; + } + __Pyx_INCREF(__pyx_int_0); + __Pyx_GIVEREF(__pyx_int_0); + PyTuple_SET_ITEM(__pyx_t_10, 0+__pyx_t_9, __pyx_int_0); + __Pyx_GIVEREF(__pyx_t_6); + PyTuple_SET_ITEM(__pyx_t_10, 1+__pyx_t_9, __pyx_t_6); + __Pyx_GIVEREF(__pyx_t_7); + PyTuple_SET_ITEM(__pyx_t_10, 2+__pyx_t_9, __pyx_t_7); + __pyx_t_6 = 0; + __pyx_t_7 = 0; + __pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_5, __pyx_t_10, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(9, 180, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; + } + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __pyx_t_5 = NULL; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_4))) { + __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_4); + if (likely(__pyx_t_5)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4); + __Pyx_INCREF(__pyx_t_5); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_4, function); + } + } + if (!__pyx_t_5) { + __pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_t_3); if (unlikely(!__pyx_t_2)) __PYX_ERR(9, 179, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_GOTREF(__pyx_t_2); + } else { + #if CYTHON_FAST_PYCALL + if (PyFunction_Check(__pyx_t_4)) { + PyObject *__pyx_temp[2] = {__pyx_t_5, __pyx_t_3}; + __pyx_t_2 = __Pyx_PyFunction_FastCall(__pyx_t_4, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_2)) __PYX_ERR(9, 179, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + } else + #endif + #if CYTHON_FAST_PYCCALL + if (__Pyx_PyFastCFunction_Check(__pyx_t_4)) { + PyObject *__pyx_temp[2] = {__pyx_t_5, __pyx_t_3}; + __pyx_t_2 = __Pyx_PyCFunction_FastCall(__pyx_t_4, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_2)) __PYX_ERR(9, 179, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + } else + #endif + { + __pyx_t_10 = PyTuple_New(1+1); if (unlikely(!__pyx_t_10)) __PYX_ERR(9, 179, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_10); + __Pyx_GIVEREF(__pyx_t_5); PyTuple_SET_ITEM(__pyx_t_10, 0, __pyx_t_5); __pyx_t_5 = NULL; + __Pyx_GIVEREF(__pyx_t_3); + PyTuple_SET_ITEM(__pyx_t_10, 0+1, __pyx_t_3); + __pyx_t_3 = 0; + __pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_4, __pyx_t_10, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(9, 179, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; + } + } + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_r = __pyx_t_2; + __pyx_t_2 = 0; + goto __pyx_L0; + } + + /* "asyncpg/protocol/codecs/datetime.pyx":166 + * + * + * cdef timestamptz_decode(ConnectionSettings settings, FastReadBuffer buf): # <<<<<<<<<<<<<< + * cdef: + * int64_t seconds = 0 + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_XDECREF(__pyx_t_6); + __Pyx_XDECREF(__pyx_t_7); + __Pyx_XDECREF(__pyx_t_8); + __Pyx_XDECREF(__pyx_t_10); + __Pyx_AddTraceback("asyncpg.protocol.protocol.timestamptz_decode", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "asyncpg/protocol/codecs/datetime.pyx":183 + * + * + * cdef time_encode(ConnectionSettings settings, WriteBuffer buf, obj): # <<<<<<<<<<<<<< + * cdef: + * int64_t seconds = cpython.PyLong_AsLong(obj.hour) * 3600 + \ + */ + +static PyObject *__pyx_f_7asyncpg_8protocol_8protocol_time_encode(CYTHON_UNUSED struct __pyx_obj_7asyncpg_8protocol_8protocol_ConnectionSettings *__pyx_v_settings, struct __pyx_obj_7asyncpg_8protocol_8protocol_WriteBuffer *__pyx_v_buf, PyObject *__pyx_v_obj) { + int64_t __pyx_v_seconds; + int32_t __pyx_v_microseconds; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + long __pyx_t_2; + long __pyx_t_3; + long __pyx_t_4; + __Pyx_RefNannySetupContext("time_encode", 0); + + /* "asyncpg/protocol/codecs/datetime.pyx":185 + * cdef time_encode(ConnectionSettings settings, WriteBuffer buf, obj): + * cdef: + * int64_t seconds = cpython.PyLong_AsLong(obj.hour) * 3600 + \ # <<<<<<<<<<<<<< + * cpython.PyLong_AsLong(obj.minute) * 60 + \ + * cpython.PyLong_AsLong(obj.second) + */ + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_obj, __pyx_n_s_hour); if (unlikely(!__pyx_t_1)) __PYX_ERR(9, 185, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = PyLong_AsLong(__pyx_t_1); if (unlikely(__pyx_t_2 == -1L && PyErr_Occurred())) __PYX_ERR(9, 185, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "asyncpg/protocol/codecs/datetime.pyx":186 + * cdef: + * int64_t seconds = cpython.PyLong_AsLong(obj.hour) * 3600 + \ + * cpython.PyLong_AsLong(obj.minute) * 60 + \ # <<<<<<<<<<<<<< + * cpython.PyLong_AsLong(obj.second) + * int32_t microseconds = cpython.PyLong_AsLong(obj.microsecond) + */ + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_obj, __pyx_n_s_minute); if (unlikely(!__pyx_t_1)) __PYX_ERR(9, 186, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_3 = PyLong_AsLong(__pyx_t_1); if (unlikely(__pyx_t_3 == -1L && PyErr_Occurred())) __PYX_ERR(9, 186, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "asyncpg/protocol/codecs/datetime.pyx":187 + * int64_t seconds = cpython.PyLong_AsLong(obj.hour) * 3600 + \ + * cpython.PyLong_AsLong(obj.minute) * 60 + \ + * cpython.PyLong_AsLong(obj.second) # <<<<<<<<<<<<<< + * int32_t microseconds = cpython.PyLong_AsLong(obj.microsecond) + * + */ + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_obj, __pyx_n_s_second); if (unlikely(!__pyx_t_1)) __PYX_ERR(9, 187, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_4 = PyLong_AsLong(__pyx_t_1); if (unlikely(__pyx_t_4 == -1L && PyErr_Occurred())) __PYX_ERR(9, 187, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "asyncpg/protocol/codecs/datetime.pyx":186 + * cdef: + * int64_t seconds = cpython.PyLong_AsLong(obj.hour) * 3600 + \ + * cpython.PyLong_AsLong(obj.minute) * 60 + \ # <<<<<<<<<<<<<< + * cpython.PyLong_AsLong(obj.second) + * int32_t microseconds = cpython.PyLong_AsLong(obj.microsecond) + */ + __pyx_v_seconds = (((__pyx_t_2 * 0xE10) + (__pyx_t_3 * 60)) + __pyx_t_4); + + /* "asyncpg/protocol/codecs/datetime.pyx":188 + * cpython.PyLong_AsLong(obj.minute) * 60 + \ + * cpython.PyLong_AsLong(obj.second) + * int32_t microseconds = cpython.PyLong_AsLong(obj.microsecond) # <<<<<<<<<<<<<< + * + * buf.write_int32(8) + */ + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_obj, __pyx_n_s_microsecond); if (unlikely(!__pyx_t_1)) __PYX_ERR(9, 188, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_4 = PyLong_AsLong(__pyx_t_1); if (unlikely(__pyx_t_4 == -1L && PyErr_Occurred())) __PYX_ERR(9, 188, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_v_microseconds = ((int32_t)__pyx_t_4); + + /* "asyncpg/protocol/codecs/datetime.pyx":190 + * int32_t microseconds = cpython.PyLong_AsLong(obj.microsecond) + * + * buf.write_int32(8) # <<<<<<<<<<<<<< + * _encode_time(buf, seconds, microseconds) + * + */ + __pyx_t_1 = __pyx_f_7asyncpg_8protocol_8protocol_11WriteBuffer_write_int32(__pyx_v_buf, 8); if (unlikely(!__pyx_t_1)) __PYX_ERR(9, 190, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "asyncpg/protocol/codecs/datetime.pyx":191 + * + * buf.write_int32(8) + * _encode_time(buf, seconds, microseconds) # <<<<<<<<<<<<<< + * + * + */ + __pyx_t_1 = __pyx_f_7asyncpg_8protocol_8protocol__encode_time(__pyx_v_buf, __pyx_v_seconds, __pyx_v_microseconds); if (unlikely(!__pyx_t_1)) __PYX_ERR(9, 191, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "asyncpg/protocol/codecs/datetime.pyx":183 + * + * + * cdef time_encode(ConnectionSettings settings, WriteBuffer buf, obj): # <<<<<<<<<<<<<< + * cdef: + * int64_t seconds = cpython.PyLong_AsLong(obj.hour) * 3600 + \ + */ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("asyncpg.protocol.protocol.time_encode", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "asyncpg/protocol/codecs/datetime.pyx":194 + * + * + * cdef time_decode(ConnectionSettings settings, FastReadBuffer buf): # <<<<<<<<<<<<<< + * cdef: + * int64_t seconds = 0 + */ + +static PyObject *__pyx_f_7asyncpg_8protocol_8protocol_time_decode(CYTHON_UNUSED struct __pyx_obj_7asyncpg_8protocol_8protocol_ConnectionSettings *__pyx_v_settings, struct __pyx_obj_7asyncpg_8protocol_8protocol_FastReadBuffer *__pyx_v_buf) { + int64_t __pyx_v_seconds; + uint32_t __pyx_v_microseconds; + int64_t __pyx_v_minutes; + int64_t __pyx_v_sec; + int64_t __pyx_v_hours; + int64_t __pyx_v_min; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + PyObject *__pyx_t_5 = NULL; + PyObject *__pyx_t_6 = NULL; + PyObject *__pyx_t_7 = NULL; + int __pyx_t_8; + PyObject *__pyx_t_9 = NULL; + __Pyx_RefNannySetupContext("time_decode", 0); + + /* "asyncpg/protocol/codecs/datetime.pyx":196 + * cdef time_decode(ConnectionSettings settings, FastReadBuffer buf): + * cdef: + * int64_t seconds = 0 # <<<<<<<<<<<<<< + * uint32_t microseconds = 0 + * + */ + __pyx_v_seconds = 0; + + /* "asyncpg/protocol/codecs/datetime.pyx":197 + * cdef: + * int64_t seconds = 0 + * uint32_t microseconds = 0 # <<<<<<<<<<<<<< + * + * _decode_time(buf, &seconds, µseconds) + */ + __pyx_v_microseconds = 0; + + /* "asyncpg/protocol/codecs/datetime.pyx":199 + * uint32_t microseconds = 0 + * + * _decode_time(buf, &seconds, µseconds) # <<<<<<<<<<<<<< + * + * cdef: + */ + __pyx_f_7asyncpg_8protocol_8protocol__decode_time(__pyx_v_buf, (&__pyx_v_seconds), (&__pyx_v_microseconds)); + + /* "asyncpg/protocol/codecs/datetime.pyx":202 + * + * cdef: + * int64_t minutes = (seconds / 60) # <<<<<<<<<<<<<< + * int64_t sec = seconds % 60 + * int64_t hours = (minutes / 60) + */ + __pyx_v_minutes = ((int64_t)(((double)__pyx_v_seconds) / 60.0)); + + /* "asyncpg/protocol/codecs/datetime.pyx":203 + * cdef: + * int64_t minutes = (seconds / 60) + * int64_t sec = seconds % 60 # <<<<<<<<<<<<<< + * int64_t hours = (minutes / 60) + * int64_t min = minutes % 60 + */ + __pyx_v_sec = __Pyx_mod_int64_t(__pyx_v_seconds, 60); + + /* "asyncpg/protocol/codecs/datetime.pyx":204 + * int64_t minutes = (seconds / 60) + * int64_t sec = seconds % 60 + * int64_t hours = (minutes / 60) # <<<<<<<<<<<<<< + * int64_t min = minutes % 60 + * + */ + __pyx_v_hours = ((int64_t)(((double)__pyx_v_minutes) / 60.0)); + + /* "asyncpg/protocol/codecs/datetime.pyx":205 + * int64_t sec = seconds % 60 + * int64_t hours = (minutes / 60) + * int64_t min = minutes % 60 # <<<<<<<<<<<<<< + * + * return datetime.time(hours, min, sec, microseconds) + */ + __pyx_v_min = __Pyx_mod_int64_t(__pyx_v_minutes, 60); + + /* "asyncpg/protocol/codecs/datetime.pyx":207 + * int64_t min = minutes % 60 + * + * return datetime.time(hours, min, sec, microseconds) # <<<<<<<<<<<<<< + * + * + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_2 = __Pyx_GetModuleGlobalName(__pyx_n_s_datetime); if (unlikely(!__pyx_t_2)) __PYX_ERR(9, 207, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_time); if (unlikely(!__pyx_t_3)) __PYX_ERR(9, 207, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_2 = __Pyx_PyInt_From_int64_t(__pyx_v_hours); if (unlikely(!__pyx_t_2)) __PYX_ERR(9, 207, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_4 = __Pyx_PyInt_From_int64_t(__pyx_v_min); if (unlikely(!__pyx_t_4)) __PYX_ERR(9, 207, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_5 = __Pyx_PyInt_From_int64_t(__pyx_v_sec); if (unlikely(!__pyx_t_5)) __PYX_ERR(9, 207, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_6 = __Pyx_PyInt_From_uint32_t(__pyx_v_microseconds); if (unlikely(!__pyx_t_6)) __PYX_ERR(9, 207, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_7 = NULL; + __pyx_t_8 = 0; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_3))) { + __pyx_t_7 = PyMethod_GET_SELF(__pyx_t_3); + if (likely(__pyx_t_7)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); + __Pyx_INCREF(__pyx_t_7); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_3, function); + __pyx_t_8 = 1; + } + } + #if CYTHON_FAST_PYCALL + if (PyFunction_Check(__pyx_t_3)) { + PyObject *__pyx_temp[5] = {__pyx_t_7, __pyx_t_2, __pyx_t_4, __pyx_t_5, __pyx_t_6}; + __pyx_t_1 = __Pyx_PyFunction_FastCall(__pyx_t_3, __pyx_temp+1-__pyx_t_8, 4+__pyx_t_8); if (unlikely(!__pyx_t_1)) __PYX_ERR(9, 207, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + } else + #endif + #if CYTHON_FAST_PYCCALL + if (__Pyx_PyFastCFunction_Check(__pyx_t_3)) { + PyObject *__pyx_temp[5] = {__pyx_t_7, __pyx_t_2, __pyx_t_4, __pyx_t_5, __pyx_t_6}; + __pyx_t_1 = __Pyx_PyCFunction_FastCall(__pyx_t_3, __pyx_temp+1-__pyx_t_8, 4+__pyx_t_8); if (unlikely(!__pyx_t_1)) __PYX_ERR(9, 207, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + } else + #endif + { + __pyx_t_9 = PyTuple_New(4+__pyx_t_8); if (unlikely(!__pyx_t_9)) __PYX_ERR(9, 207, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_9); + if (__pyx_t_7) { + __Pyx_GIVEREF(__pyx_t_7); PyTuple_SET_ITEM(__pyx_t_9, 0, __pyx_t_7); __pyx_t_7 = NULL; + } + __Pyx_GIVEREF(__pyx_t_2); + PyTuple_SET_ITEM(__pyx_t_9, 0+__pyx_t_8, __pyx_t_2); + __Pyx_GIVEREF(__pyx_t_4); + PyTuple_SET_ITEM(__pyx_t_9, 1+__pyx_t_8, __pyx_t_4); + __Pyx_GIVEREF(__pyx_t_5); + PyTuple_SET_ITEM(__pyx_t_9, 2+__pyx_t_8, __pyx_t_5); + __Pyx_GIVEREF(__pyx_t_6); + PyTuple_SET_ITEM(__pyx_t_9, 3+__pyx_t_8, __pyx_t_6); + __pyx_t_2 = 0; + __pyx_t_4 = 0; + __pyx_t_5 = 0; + __pyx_t_6 = 0; + __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_t_9, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(9, 207, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + } + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "asyncpg/protocol/codecs/datetime.pyx":194 + * + * + * cdef time_decode(ConnectionSettings settings, FastReadBuffer buf): # <<<<<<<<<<<<<< + * cdef: + * int64_t seconds = 0 + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_XDECREF(__pyx_t_6); + __Pyx_XDECREF(__pyx_t_7); + __Pyx_XDECREF(__pyx_t_9); + __Pyx_AddTraceback("asyncpg.protocol.protocol.time_decode", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "asyncpg/protocol/codecs/datetime.pyx":210 + * + * + * cdef timetz_encode(ConnectionSettings settings, WriteBuffer buf, obj): # <<<<<<<<<<<<<< + * offset = obj.tzinfo.utcoffset(None) + * + */ + +static PyObject *__pyx_f_7asyncpg_8protocol_8protocol_timetz_encode(CYTHON_UNUSED struct __pyx_obj_7asyncpg_8protocol_8protocol_ConnectionSettings *__pyx_v_settings, struct __pyx_obj_7asyncpg_8protocol_8protocol_WriteBuffer *__pyx_v_buf, PyObject *__pyx_v_obj) { + PyObject *__pyx_v_offset = NULL; + int32_t __pyx_v_offset_sec; + int64_t __pyx_v_seconds; + int32_t __pyx_v_microseconds; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + long __pyx_t_3; + long __pyx_t_4; + long __pyx_t_5; + __Pyx_RefNannySetupContext("timetz_encode", 0); + + /* "asyncpg/protocol/codecs/datetime.pyx":211 + * + * cdef timetz_encode(ConnectionSettings settings, WriteBuffer buf, obj): + * offset = obj.tzinfo.utcoffset(None) # <<<<<<<<<<<<<< + * + * cdef: + */ + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_obj, __pyx_n_s_tzinfo); if (unlikely(!__pyx_t_1)) __PYX_ERR(9, 211, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_utcoffset); if (unlikely(!__pyx_t_2)) __PYX_ERR(9, 211, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_tuple__32, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(9, 211, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_v_offset = __pyx_t_1; + __pyx_t_1 = 0; + + /* "asyncpg/protocol/codecs/datetime.pyx":215 + * cdef: + * int32_t offset_sec = \ + * cpython.PyLong_AsLong(offset.days) * 24 * 60 * 60 + \ # <<<<<<<<<<<<<< + * cpython.PyLong_AsLong(offset.seconds) + * + */ + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_offset, __pyx_n_s_days); if (unlikely(!__pyx_t_1)) __PYX_ERR(9, 215, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_3 = PyLong_AsLong(__pyx_t_1); if (unlikely(__pyx_t_3 == -1L && PyErr_Occurred())) __PYX_ERR(9, 215, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "asyncpg/protocol/codecs/datetime.pyx":216 + * int32_t offset_sec = \ + * cpython.PyLong_AsLong(offset.days) * 24 * 60 * 60 + \ + * cpython.PyLong_AsLong(offset.seconds) # <<<<<<<<<<<<<< + * + * int64_t seconds = cpython.PyLong_AsLong(obj.hour) * 3600 + \ + */ + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_offset, __pyx_n_s_seconds); if (unlikely(!__pyx_t_1)) __PYX_ERR(9, 216, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_4 = PyLong_AsLong(__pyx_t_1); if (unlikely(__pyx_t_4 == -1L && PyErr_Occurred())) __PYX_ERR(9, 216, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "asyncpg/protocol/codecs/datetime.pyx":215 + * cdef: + * int32_t offset_sec = \ + * cpython.PyLong_AsLong(offset.days) * 24 * 60 * 60 + \ # <<<<<<<<<<<<<< + * cpython.PyLong_AsLong(offset.seconds) + * + */ + __pyx_v_offset_sec = ((((((int32_t)__pyx_t_3) * 24) * 60) * 60) + ((int32_t)__pyx_t_4)); + + /* "asyncpg/protocol/codecs/datetime.pyx":218 + * cpython.PyLong_AsLong(offset.seconds) + * + * int64_t seconds = cpython.PyLong_AsLong(obj.hour) * 3600 + \ # <<<<<<<<<<<<<< + * cpython.PyLong_AsLong(obj.minute) * 60 + \ + * cpython.PyLong_AsLong(obj.second) + */ + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_obj, __pyx_n_s_hour); if (unlikely(!__pyx_t_1)) __PYX_ERR(9, 218, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_4 = PyLong_AsLong(__pyx_t_1); if (unlikely(__pyx_t_4 == -1L && PyErr_Occurred())) __PYX_ERR(9, 218, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "asyncpg/protocol/codecs/datetime.pyx":219 + * + * int64_t seconds = cpython.PyLong_AsLong(obj.hour) * 3600 + \ + * cpython.PyLong_AsLong(obj.minute) * 60 + \ # <<<<<<<<<<<<<< + * cpython.PyLong_AsLong(obj.second) + * + */ + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_obj, __pyx_n_s_minute); if (unlikely(!__pyx_t_1)) __PYX_ERR(9, 219, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_3 = PyLong_AsLong(__pyx_t_1); if (unlikely(__pyx_t_3 == -1L && PyErr_Occurred())) __PYX_ERR(9, 219, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "asyncpg/protocol/codecs/datetime.pyx":220 + * int64_t seconds = cpython.PyLong_AsLong(obj.hour) * 3600 + \ + * cpython.PyLong_AsLong(obj.minute) * 60 + \ + * cpython.PyLong_AsLong(obj.second) # <<<<<<<<<<<<<< + * + * int32_t microseconds = cpython.PyLong_AsLong(obj.microsecond) + */ + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_obj, __pyx_n_s_second); if (unlikely(!__pyx_t_1)) __PYX_ERR(9, 220, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_5 = PyLong_AsLong(__pyx_t_1); if (unlikely(__pyx_t_5 == -1L && PyErr_Occurred())) __PYX_ERR(9, 220, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "asyncpg/protocol/codecs/datetime.pyx":219 + * + * int64_t seconds = cpython.PyLong_AsLong(obj.hour) * 3600 + \ + * cpython.PyLong_AsLong(obj.minute) * 60 + \ # <<<<<<<<<<<<<< + * cpython.PyLong_AsLong(obj.second) + * + */ + __pyx_v_seconds = (((__pyx_t_4 * 0xE10) + (__pyx_t_3 * 60)) + __pyx_t_5); + + /* "asyncpg/protocol/codecs/datetime.pyx":222 + * cpython.PyLong_AsLong(obj.second) + * + * int32_t microseconds = cpython.PyLong_AsLong(obj.microsecond) # <<<<<<<<<<<<<< + * + * buf.write_int32(12) + */ + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_obj, __pyx_n_s_microsecond); if (unlikely(!__pyx_t_1)) __PYX_ERR(9, 222, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_5 = PyLong_AsLong(__pyx_t_1); if (unlikely(__pyx_t_5 == -1L && PyErr_Occurred())) __PYX_ERR(9, 222, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_v_microseconds = ((int32_t)__pyx_t_5); + + /* "asyncpg/protocol/codecs/datetime.pyx":224 + * int32_t microseconds = cpython.PyLong_AsLong(obj.microsecond) + * + * buf.write_int32(12) # <<<<<<<<<<<<<< + * _encode_time(buf, seconds, microseconds) + * buf.write_int32(offset_sec) + */ + __pyx_t_1 = __pyx_f_7asyncpg_8protocol_8protocol_11WriteBuffer_write_int32(__pyx_v_buf, 12); if (unlikely(!__pyx_t_1)) __PYX_ERR(9, 224, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "asyncpg/protocol/codecs/datetime.pyx":225 + * + * buf.write_int32(12) + * _encode_time(buf, seconds, microseconds) # <<<<<<<<<<<<<< + * buf.write_int32(offset_sec) + * + */ + __pyx_t_1 = __pyx_f_7asyncpg_8protocol_8protocol__encode_time(__pyx_v_buf, __pyx_v_seconds, __pyx_v_microseconds); if (unlikely(!__pyx_t_1)) __PYX_ERR(9, 225, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "asyncpg/protocol/codecs/datetime.pyx":226 + * buf.write_int32(12) + * _encode_time(buf, seconds, microseconds) + * buf.write_int32(offset_sec) # <<<<<<<<<<<<<< + * + * + */ + __pyx_t_1 = __pyx_f_7asyncpg_8protocol_8protocol_11WriteBuffer_write_int32(__pyx_v_buf, __pyx_v_offset_sec); if (unlikely(!__pyx_t_1)) __PYX_ERR(9, 226, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "asyncpg/protocol/codecs/datetime.pyx":210 + * + * + * cdef timetz_encode(ConnectionSettings settings, WriteBuffer buf, obj): # <<<<<<<<<<<<<< + * offset = obj.tzinfo.utcoffset(None) + * + */ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_AddTraceback("asyncpg.protocol.protocol.timetz_encode", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XDECREF(__pyx_v_offset); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "asyncpg/protocol/codecs/datetime.pyx":229 + * + * + * cdef timetz_decode(ConnectionSettings settings, FastReadBuffer buf): # <<<<<<<<<<<<<< + * time = time_decode(settings, buf) + * cdef int32_t offset = (hton.unpack_int32(buf.read(4)) / 60) + */ + +static PyObject *__pyx_f_7asyncpg_8protocol_8protocol_timetz_decode(struct __pyx_obj_7asyncpg_8protocol_8protocol_ConnectionSettings *__pyx_v_settings, struct __pyx_obj_7asyncpg_8protocol_8protocol_FastReadBuffer *__pyx_v_buf) { + PyObject *__pyx_v_time = NULL; + int32_t __pyx_v_offset; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + char const *__pyx_t_2; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + PyObject *__pyx_t_5 = NULL; + PyObject *__pyx_t_6 = NULL; + PyObject *__pyx_t_7 = NULL; + PyObject *__pyx_t_8 = NULL; + __Pyx_RefNannySetupContext("timetz_decode", 0); + + /* "asyncpg/protocol/codecs/datetime.pyx":230 + * + * cdef timetz_decode(ConnectionSettings settings, FastReadBuffer buf): + * time = time_decode(settings, buf) # <<<<<<<<<<<<<< + * cdef int32_t offset = (hton.unpack_int32(buf.read(4)) / 60) + * return time.replace(tzinfo=datetime.timezone(timedelta(minutes=offset))) + */ + __pyx_t_1 = __pyx_f_7asyncpg_8protocol_8protocol_time_decode(__pyx_v_settings, __pyx_v_buf); if (unlikely(!__pyx_t_1)) __PYX_ERR(9, 230, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_v_time = __pyx_t_1; + __pyx_t_1 = 0; + + /* "asyncpg/protocol/codecs/datetime.pyx":231 + * cdef timetz_decode(ConnectionSettings settings, FastReadBuffer buf): + * time = time_decode(settings, buf) + * cdef int32_t offset = (hton.unpack_int32(buf.read(4)) / 60) # <<<<<<<<<<<<<< + * return time.replace(tzinfo=datetime.timezone(timedelta(minutes=offset))) + * + */ + __pyx_t_2 = __pyx_f_7asyncpg_8protocol_8protocol_14FastReadBuffer_read(__pyx_v_buf, 4); if (unlikely(__pyx_t_2 == NULL)) __PYX_ERR(9, 231, __pyx_L1_error) + __pyx_v_offset = ((int32_t)(((double)__pyx_f_7asyncpg_8protocol_4hton_unpack_int32(__pyx_t_2)) / 60.0)); + + /* "asyncpg/protocol/codecs/datetime.pyx":232 + * time = time_decode(settings, buf) + * cdef int32_t offset = (hton.unpack_int32(buf.read(4)) / 60) + * return time.replace(tzinfo=datetime.timezone(timedelta(minutes=offset))) # <<<<<<<<<<<<<< + * + * + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_time, __pyx_n_s_replace); if (unlikely(!__pyx_t_1)) __PYX_ERR(9, 232, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_3 = PyDict_New(); if (unlikely(!__pyx_t_3)) __PYX_ERR(9, 232, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_5 = __Pyx_GetModuleGlobalName(__pyx_n_s_datetime); if (unlikely(!__pyx_t_5)) __PYX_ERR(9, 232, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_t_5, __pyx_n_s_timezone); if (unlikely(!__pyx_t_6)) __PYX_ERR(9, 232, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __pyx_t_5 = __Pyx_GetModuleGlobalName(__pyx_n_s_timedelta); if (unlikely(!__pyx_t_5)) __PYX_ERR(9, 232, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_7 = PyDict_New(); if (unlikely(!__pyx_t_7)) __PYX_ERR(9, 232, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __pyx_t_8 = __Pyx_PyInt_From_int32_t(__pyx_v_offset); if (unlikely(!__pyx_t_8)) __PYX_ERR(9, 232, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + if (PyDict_SetItem(__pyx_t_7, __pyx_n_s_minutes, __pyx_t_8) < 0) __PYX_ERR(9, 232, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + __pyx_t_8 = __Pyx_PyObject_Call(__pyx_t_5, __pyx_empty_tuple, __pyx_t_7); if (unlikely(!__pyx_t_8)) __PYX_ERR(9, 232, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __pyx_t_7 = NULL; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_6))) { + __pyx_t_7 = PyMethod_GET_SELF(__pyx_t_6); + if (likely(__pyx_t_7)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_6); + __Pyx_INCREF(__pyx_t_7); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_6, function); + } + } + if (!__pyx_t_7) { + __pyx_t_4 = __Pyx_PyObject_CallOneArg(__pyx_t_6, __pyx_t_8); if (unlikely(!__pyx_t_4)) __PYX_ERR(9, 232, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + __Pyx_GOTREF(__pyx_t_4); + } else { + #if CYTHON_FAST_PYCALL + if (PyFunction_Check(__pyx_t_6)) { + PyObject *__pyx_temp[2] = {__pyx_t_7, __pyx_t_8}; + __pyx_t_4 = __Pyx_PyFunction_FastCall(__pyx_t_6, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_4)) __PYX_ERR(9, 232, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + } else + #endif + #if CYTHON_FAST_PYCCALL + if (__Pyx_PyFastCFunction_Check(__pyx_t_6)) { + PyObject *__pyx_temp[2] = {__pyx_t_7, __pyx_t_8}; + __pyx_t_4 = __Pyx_PyCFunction_FastCall(__pyx_t_6, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_4)) __PYX_ERR(9, 232, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + } else + #endif + { + __pyx_t_5 = PyTuple_New(1+1); if (unlikely(!__pyx_t_5)) __PYX_ERR(9, 232, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_GIVEREF(__pyx_t_7); PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_t_7); __pyx_t_7 = NULL; + __Pyx_GIVEREF(__pyx_t_8); + PyTuple_SET_ITEM(__pyx_t_5, 0+1, __pyx_t_8); + __pyx_t_8 = 0; + __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_6, __pyx_t_5, NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(9, 232, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + } + } + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + if (PyDict_SetItem(__pyx_t_3, __pyx_n_s_tzinfo, __pyx_t_4) < 0) __PYX_ERR(9, 232, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_empty_tuple, __pyx_t_3); if (unlikely(!__pyx_t_4)) __PYX_ERR(9, 232, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_r = __pyx_t_4; + __pyx_t_4 = 0; + goto __pyx_L0; + + /* "asyncpg/protocol/codecs/datetime.pyx":229 + * + * + * cdef timetz_decode(ConnectionSettings settings, FastReadBuffer buf): # <<<<<<<<<<<<<< + * time = time_decode(settings, buf) + * cdef int32_t offset = (hton.unpack_int32(buf.read(4)) / 60) + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_XDECREF(__pyx_t_6); + __Pyx_XDECREF(__pyx_t_7); + __Pyx_XDECREF(__pyx_t_8); + __Pyx_AddTraceback("asyncpg.protocol.protocol.timetz_decode", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XDECREF(__pyx_v_time); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "asyncpg/protocol/codecs/datetime.pyx":235 + * + * + * cdef interval_encode(ConnectionSettings settings, WriteBuffer buf, obj): # <<<<<<<<<<<<<< + * cdef: + * int32_t days = cpython.PyLong_AsLong(obj.days) + */ + +static PyObject *__pyx_f_7asyncpg_8protocol_8protocol_interval_encode(CYTHON_UNUSED struct __pyx_obj_7asyncpg_8protocol_8protocol_ConnectionSettings *__pyx_v_settings, struct __pyx_obj_7asyncpg_8protocol_8protocol_WriteBuffer *__pyx_v_buf, PyObject *__pyx_v_obj) { + int32_t __pyx_v_days; + int64_t __pyx_v_seconds; + int32_t __pyx_v_microseconds; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + long __pyx_t_2; + PY_LONG_LONG __pyx_t_3; + __Pyx_RefNannySetupContext("interval_encode", 0); + + /* "asyncpg/protocol/codecs/datetime.pyx":237 + * cdef interval_encode(ConnectionSettings settings, WriteBuffer buf, obj): + * cdef: + * int32_t days = cpython.PyLong_AsLong(obj.days) # <<<<<<<<<<<<<< + * int64_t seconds = cpython.PyLong_AsLongLong(obj.seconds) + * int32_t microseconds = cpython.PyLong_AsLong(obj.microseconds) + */ + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_obj, __pyx_n_s_days); if (unlikely(!__pyx_t_1)) __PYX_ERR(9, 237, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = PyLong_AsLong(__pyx_t_1); if (unlikely(__pyx_t_2 == -1L && PyErr_Occurred())) __PYX_ERR(9, 237, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_v_days = ((int32_t)__pyx_t_2); + + /* "asyncpg/protocol/codecs/datetime.pyx":238 + * cdef: + * int32_t days = cpython.PyLong_AsLong(obj.days) + * int64_t seconds = cpython.PyLong_AsLongLong(obj.seconds) # <<<<<<<<<<<<<< + * int32_t microseconds = cpython.PyLong_AsLong(obj.microseconds) + * + */ + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_obj, __pyx_n_s_seconds); if (unlikely(!__pyx_t_1)) __PYX_ERR(9, 238, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_3 = PyLong_AsLongLong(__pyx_t_1); if (unlikely(__pyx_t_3 == -1LL && PyErr_Occurred())) __PYX_ERR(9, 238, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_v_seconds = __pyx_t_3; + + /* "asyncpg/protocol/codecs/datetime.pyx":239 + * int32_t days = cpython.PyLong_AsLong(obj.days) + * int64_t seconds = cpython.PyLong_AsLongLong(obj.seconds) + * int32_t microseconds = cpython.PyLong_AsLong(obj.microseconds) # <<<<<<<<<<<<<< + * + * buf.write_int32(16) + */ + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_obj, __pyx_n_s_microseconds); if (unlikely(!__pyx_t_1)) __PYX_ERR(9, 239, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = PyLong_AsLong(__pyx_t_1); if (unlikely(__pyx_t_2 == -1L && PyErr_Occurred())) __PYX_ERR(9, 239, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_v_microseconds = ((int32_t)__pyx_t_2); + + /* "asyncpg/protocol/codecs/datetime.pyx":241 + * int32_t microseconds = cpython.PyLong_AsLong(obj.microseconds) + * + * buf.write_int32(16) # <<<<<<<<<<<<<< + * _encode_time(buf, seconds, microseconds) + * buf.write_int32(days) + */ + __pyx_t_1 = __pyx_f_7asyncpg_8protocol_8protocol_11WriteBuffer_write_int32(__pyx_v_buf, 16); if (unlikely(!__pyx_t_1)) __PYX_ERR(9, 241, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "asyncpg/protocol/codecs/datetime.pyx":242 + * + * buf.write_int32(16) + * _encode_time(buf, seconds, microseconds) # <<<<<<<<<<<<<< + * buf.write_int32(days) + * buf.write_int32(0) # Months + */ + __pyx_t_1 = __pyx_f_7asyncpg_8protocol_8protocol__encode_time(__pyx_v_buf, __pyx_v_seconds, __pyx_v_microseconds); if (unlikely(!__pyx_t_1)) __PYX_ERR(9, 242, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "asyncpg/protocol/codecs/datetime.pyx":243 + * buf.write_int32(16) + * _encode_time(buf, seconds, microseconds) + * buf.write_int32(days) # <<<<<<<<<<<<<< + * buf.write_int32(0) # Months + * + */ + __pyx_t_1 = __pyx_f_7asyncpg_8protocol_8protocol_11WriteBuffer_write_int32(__pyx_v_buf, __pyx_v_days); if (unlikely(!__pyx_t_1)) __PYX_ERR(9, 243, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "asyncpg/protocol/codecs/datetime.pyx":244 + * _encode_time(buf, seconds, microseconds) + * buf.write_int32(days) + * buf.write_int32(0) # Months # <<<<<<<<<<<<<< + * + * + */ + __pyx_t_1 = __pyx_f_7asyncpg_8protocol_8protocol_11WriteBuffer_write_int32(__pyx_v_buf, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(9, 244, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "asyncpg/protocol/codecs/datetime.pyx":235 + * + * + * cdef interval_encode(ConnectionSettings settings, WriteBuffer buf, obj): # <<<<<<<<<<<<<< + * cdef: + * int32_t days = cpython.PyLong_AsLong(obj.days) + */ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("asyncpg.protocol.protocol.interval_encode", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "asyncpg/protocol/codecs/datetime.pyx":247 + * + * + * cdef interval_decode(ConnectionSettings settings, FastReadBuffer buf): # <<<<<<<<<<<<<< + * cdef: + * int32_t days + */ + +static PyObject *__pyx_f_7asyncpg_8protocol_8protocol_interval_decode(CYTHON_UNUSED struct __pyx_obj_7asyncpg_8protocol_8protocol_ConnectionSettings *__pyx_v_settings, struct __pyx_obj_7asyncpg_8protocol_8protocol_FastReadBuffer *__pyx_v_buf) { + int32_t __pyx_v_days; + int32_t __pyx_v_months; + int64_t __pyx_v_seconds; + uint32_t __pyx_v_microseconds; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + char const *__pyx_t_1; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + __Pyx_RefNannySetupContext("interval_decode", 0); + + /* "asyncpg/protocol/codecs/datetime.pyx":251 + * int32_t days + * int32_t months + * int64_t seconds = 0 # <<<<<<<<<<<<<< + * uint32_t microseconds = 0 + * + */ + __pyx_v_seconds = 0; + + /* "asyncpg/protocol/codecs/datetime.pyx":252 + * int32_t months + * int64_t seconds = 0 + * uint32_t microseconds = 0 # <<<<<<<<<<<<<< + * + * _decode_time(buf, &seconds, µseconds) + */ + __pyx_v_microseconds = 0; + + /* "asyncpg/protocol/codecs/datetime.pyx":254 + * uint32_t microseconds = 0 + * + * _decode_time(buf, &seconds, µseconds) # <<<<<<<<<<<<<< + * days = hton.unpack_int32(buf.read(4)) + * months = hton.unpack_int32(buf.read(4)) + */ + __pyx_f_7asyncpg_8protocol_8protocol__decode_time(__pyx_v_buf, (&__pyx_v_seconds), (&__pyx_v_microseconds)); + + /* "asyncpg/protocol/codecs/datetime.pyx":255 + * + * _decode_time(buf, &seconds, µseconds) + * days = hton.unpack_int32(buf.read(4)) # <<<<<<<<<<<<<< + * months = hton.unpack_int32(buf.read(4)) + * + */ + __pyx_t_1 = __pyx_f_7asyncpg_8protocol_8protocol_14FastReadBuffer_read(__pyx_v_buf, 4); if (unlikely(__pyx_t_1 == NULL)) __PYX_ERR(9, 255, __pyx_L1_error) + __pyx_v_days = __pyx_f_7asyncpg_8protocol_4hton_unpack_int32(__pyx_t_1); + + /* "asyncpg/protocol/codecs/datetime.pyx":256 + * _decode_time(buf, &seconds, µseconds) + * days = hton.unpack_int32(buf.read(4)) + * months = hton.unpack_int32(buf.read(4)) # <<<<<<<<<<<<<< + * + * return datetime.timedelta(days=days + months * 30, seconds=seconds, + */ + __pyx_t_1 = __pyx_f_7asyncpg_8protocol_8protocol_14FastReadBuffer_read(__pyx_v_buf, 4); if (unlikely(__pyx_t_1 == NULL)) __PYX_ERR(9, 256, __pyx_L1_error) + __pyx_v_months = __pyx_f_7asyncpg_8protocol_4hton_unpack_int32(__pyx_t_1); + + /* "asyncpg/protocol/codecs/datetime.pyx":258 + * months = hton.unpack_int32(buf.read(4)) + * + * return datetime.timedelta(days=days + months * 30, seconds=seconds, # <<<<<<<<<<<<<< + * microseconds=microseconds) + * + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_2 = __Pyx_GetModuleGlobalName(__pyx_n_s_datetime); if (unlikely(!__pyx_t_2)) __PYX_ERR(9, 258, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_timedelta); if (unlikely(!__pyx_t_3)) __PYX_ERR(9, 258, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_2 = PyDict_New(); if (unlikely(!__pyx_t_2)) __PYX_ERR(9, 258, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_4 = __Pyx_PyInt_From_long((__pyx_v_days + (__pyx_v_months * 30))); if (unlikely(!__pyx_t_4)) __PYX_ERR(9, 258, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_days, __pyx_t_4) < 0) __PYX_ERR(9, 258, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_4 = __Pyx_PyInt_From_int64_t(__pyx_v_seconds); if (unlikely(!__pyx_t_4)) __PYX_ERR(9, 258, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_seconds, __pyx_t_4) < 0) __PYX_ERR(9, 258, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + + /* "asyncpg/protocol/codecs/datetime.pyx":259 + * + * return datetime.timedelta(days=days + months * 30, seconds=seconds, + * microseconds=microseconds) # <<<<<<<<<<<<<< + * + * + */ + __pyx_t_4 = __Pyx_PyInt_From_uint32_t(__pyx_v_microseconds); if (unlikely(!__pyx_t_4)) __PYX_ERR(9, 259, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_microseconds, __pyx_t_4) < 0) __PYX_ERR(9, 258, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + + /* "asyncpg/protocol/codecs/datetime.pyx":258 + * months = hton.unpack_int32(buf.read(4)) + * + * return datetime.timedelta(days=days + months * 30, seconds=seconds, # <<<<<<<<<<<<<< + * microseconds=microseconds) + * + */ + __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_empty_tuple, __pyx_t_2); if (unlikely(!__pyx_t_4)) __PYX_ERR(9, 258, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_r = __pyx_t_4; + __pyx_t_4 = 0; + goto __pyx_L0; + + /* "asyncpg/protocol/codecs/datetime.pyx":247 + * + * + * cdef interval_decode(ConnectionSettings settings, FastReadBuffer buf): # <<<<<<<<<<<<<< + * cdef: + * int32_t days + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_AddTraceback("asyncpg.protocol.protocol.interval_decode", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "asyncpg/protocol/codecs/datetime.pyx":262 + * + * + * cdef init_datetime_codecs(): # <<<<<<<<<<<<<< + * register_core_codec(DATEOID, + * &date_encode, + */ + +static PyObject *__pyx_f_7asyncpg_8protocol_8protocol_init_datetime_codecs(void) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + __Pyx_RefNannySetupContext("init_datetime_codecs", 0); + + /* "asyncpg/protocol/codecs/datetime.pyx":263 + * + * cdef init_datetime_codecs(): + * register_core_codec(DATEOID, # <<<<<<<<<<<<<< + * &date_encode, + * &date_decode, + */ + __pyx_t_1 = __pyx_f_7asyncpg_8protocol_8protocol_register_core_codec(0x43A, ((__pyx_t_7asyncpg_8protocol_8protocol_encode_func)(&__pyx_f_7asyncpg_8protocol_8protocol_date_encode)), ((__pyx_t_7asyncpg_8protocol_8protocol_decode_func)(&__pyx_f_7asyncpg_8protocol_8protocol_date_decode)), __pyx_e_7asyncpg_8protocol_8protocol_PG_FORMAT_BINARY); if (unlikely(!__pyx_t_1)) __PYX_ERR(9, 263, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "asyncpg/protocol/codecs/datetime.pyx":268 + * PG_FORMAT_BINARY) + * + * register_core_codec(TIMEOID, # <<<<<<<<<<<<<< + * &time_encode, + * &time_decode, + */ + __pyx_t_1 = __pyx_f_7asyncpg_8protocol_8protocol_register_core_codec(0x43B, ((__pyx_t_7asyncpg_8protocol_8protocol_encode_func)(&__pyx_f_7asyncpg_8protocol_8protocol_time_encode)), ((__pyx_t_7asyncpg_8protocol_8protocol_decode_func)(&__pyx_f_7asyncpg_8protocol_8protocol_time_decode)), __pyx_e_7asyncpg_8protocol_8protocol_PG_FORMAT_BINARY); if (unlikely(!__pyx_t_1)) __PYX_ERR(9, 268, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "asyncpg/protocol/codecs/datetime.pyx":273 + * PG_FORMAT_BINARY) + * + * register_core_codec(TIMETZOID, # <<<<<<<<<<<<<< + * &timetz_encode, + * &timetz_decode, + */ + __pyx_t_1 = __pyx_f_7asyncpg_8protocol_8protocol_register_core_codec(0x4F2, ((__pyx_t_7asyncpg_8protocol_8protocol_encode_func)(&__pyx_f_7asyncpg_8protocol_8protocol_timetz_encode)), ((__pyx_t_7asyncpg_8protocol_8protocol_decode_func)(&__pyx_f_7asyncpg_8protocol_8protocol_timetz_decode)), __pyx_e_7asyncpg_8protocol_8protocol_PG_FORMAT_BINARY); if (unlikely(!__pyx_t_1)) __PYX_ERR(9, 273, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "asyncpg/protocol/codecs/datetime.pyx":278 + * PG_FORMAT_BINARY) + * + * register_core_codec(TIMESTAMPOID, # <<<<<<<<<<<<<< + * ×tamp_encode, + * ×tamp_decode, + */ + __pyx_t_1 = __pyx_f_7asyncpg_8protocol_8protocol_register_core_codec(0x45A, ((__pyx_t_7asyncpg_8protocol_8protocol_encode_func)(&__pyx_f_7asyncpg_8protocol_8protocol_timestamp_encode)), ((__pyx_t_7asyncpg_8protocol_8protocol_decode_func)(&__pyx_f_7asyncpg_8protocol_8protocol_timestamp_decode)), __pyx_e_7asyncpg_8protocol_8protocol_PG_FORMAT_BINARY); if (unlikely(!__pyx_t_1)) __PYX_ERR(9, 278, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "asyncpg/protocol/codecs/datetime.pyx":283 + * PG_FORMAT_BINARY) + * + * register_core_codec(TIMESTAMPTZOID, # <<<<<<<<<<<<<< + * ×tamptz_encode, + * ×tamptz_decode, + */ + __pyx_t_1 = __pyx_f_7asyncpg_8protocol_8protocol_register_core_codec(0x4A0, ((__pyx_t_7asyncpg_8protocol_8protocol_encode_func)(&__pyx_f_7asyncpg_8protocol_8protocol_timestamptz_encode)), ((__pyx_t_7asyncpg_8protocol_8protocol_decode_func)(&__pyx_f_7asyncpg_8protocol_8protocol_timestamptz_decode)), __pyx_e_7asyncpg_8protocol_8protocol_PG_FORMAT_BINARY); if (unlikely(!__pyx_t_1)) __PYX_ERR(9, 283, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "asyncpg/protocol/codecs/datetime.pyx":288 + * PG_FORMAT_BINARY) + * + * register_core_codec(INTERVALOID, # <<<<<<<<<<<<<< + * &interval_encode, + * &interval_decode, + */ + __pyx_t_1 = __pyx_f_7asyncpg_8protocol_8protocol_register_core_codec(0x4A2, ((__pyx_t_7asyncpg_8protocol_8protocol_encode_func)(&__pyx_f_7asyncpg_8protocol_8protocol_interval_encode)), ((__pyx_t_7asyncpg_8protocol_8protocol_decode_func)(&__pyx_f_7asyncpg_8protocol_8protocol_interval_decode)), __pyx_e_7asyncpg_8protocol_8protocol_PG_FORMAT_BINARY); if (unlikely(!__pyx_t_1)) __PYX_ERR(9, 288, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "asyncpg/protocol/codecs/datetime.pyx":296 + * # interpret the value, and simply return and pass it as text. + * # + * register_core_codec(ABSTIMEOID, # <<<<<<<<<<<<<< + * &text_encode, + * &text_decode, + */ + __pyx_t_1 = __pyx_f_7asyncpg_8protocol_8protocol_register_core_codec(0x2BE, ((__pyx_t_7asyncpg_8protocol_8protocol_encode_func)(&__pyx_f_7asyncpg_8protocol_8protocol_text_encode)), ((__pyx_t_7asyncpg_8protocol_8protocol_decode_func)(&__pyx_f_7asyncpg_8protocol_8protocol_text_decode)), __pyx_e_7asyncpg_8protocol_8protocol_PG_FORMAT_TEXT); if (unlikely(!__pyx_t_1)) __PYX_ERR(9, 296, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "asyncpg/protocol/codecs/datetime.pyx":301 + * PG_FORMAT_TEXT) + * + * register_core_codec(RELTIMEOID, # <<<<<<<<<<<<<< + * &text_encode, + * &text_decode, + */ + __pyx_t_1 = __pyx_f_7asyncpg_8protocol_8protocol_register_core_codec(0x2BF, ((__pyx_t_7asyncpg_8protocol_8protocol_encode_func)(&__pyx_f_7asyncpg_8protocol_8protocol_text_encode)), ((__pyx_t_7asyncpg_8protocol_8protocol_decode_func)(&__pyx_f_7asyncpg_8protocol_8protocol_text_decode)), __pyx_e_7asyncpg_8protocol_8protocol_PG_FORMAT_TEXT); if (unlikely(!__pyx_t_1)) __PYX_ERR(9, 301, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "asyncpg/protocol/codecs/datetime.pyx":306 + * PG_FORMAT_TEXT) + * + * register_core_codec(TINTERVALOID, # <<<<<<<<<<<<<< + * &text_encode, + * &text_decode, + */ + __pyx_t_1 = __pyx_f_7asyncpg_8protocol_8protocol_register_core_codec(0x2C0, ((__pyx_t_7asyncpg_8protocol_8protocol_encode_func)(&__pyx_f_7asyncpg_8protocol_8protocol_text_encode)), ((__pyx_t_7asyncpg_8protocol_8protocol_decode_func)(&__pyx_f_7asyncpg_8protocol_8protocol_text_decode)), __pyx_e_7asyncpg_8protocol_8protocol_PG_FORMAT_TEXT); if (unlikely(!__pyx_t_1)) __PYX_ERR(9, 306, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "asyncpg/protocol/codecs/datetime.pyx":262 + * + * + * cdef init_datetime_codecs(): # <<<<<<<<<<<<<< + * register_core_codec(DATEOID, + * &date_encode, + */ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("asyncpg.protocol.protocol.init_datetime_codecs", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "asyncpg/protocol/codecs/float.pyx":11 + * + * + * cdef float4_encode(ConnectionSettings settings, WriteBuffer buf, obj): # <<<<<<<<<<<<<< + * cdef double dval = cpython.PyFloat_AsDouble(obj) + * cdef float fval = dval + */ + +static PyObject *__pyx_f_7asyncpg_8protocol_8protocol_float4_encode(CYTHON_UNUSED struct __pyx_obj_7asyncpg_8protocol_8protocol_ConnectionSettings *__pyx_v_settings, struct __pyx_obj_7asyncpg_8protocol_8protocol_WriteBuffer *__pyx_v_buf, PyObject *__pyx_v_obj) { + double __pyx_v_dval; + float __pyx_v_fval; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + double __pyx_t_1; + int __pyx_t_2; + int __pyx_t_3; + PyObject *__pyx_t_4 = NULL; + __Pyx_RefNannySetupContext("float4_encode", 0); + + /* "asyncpg/protocol/codecs/float.pyx":12 + * + * cdef float4_encode(ConnectionSettings settings, WriteBuffer buf, obj): + * cdef double dval = cpython.PyFloat_AsDouble(obj) # <<<<<<<<<<<<<< + * cdef float fval = dval + * if math.isinf(fval) and not math.isinf(dval): + */ + __pyx_t_1 = PyFloat_AsDouble(__pyx_v_obj); if (unlikely(__pyx_t_1 == -1.0 && PyErr_Occurred())) __PYX_ERR(10, 12, __pyx_L1_error) + __pyx_v_dval = __pyx_t_1; + + /* "asyncpg/protocol/codecs/float.pyx":13 + * cdef float4_encode(ConnectionSettings settings, WriteBuffer buf, obj): + * cdef double dval = cpython.PyFloat_AsDouble(obj) + * cdef float fval = dval # <<<<<<<<<<<<<< + * if math.isinf(fval) and not math.isinf(dval): + * raise ValueError('float value too large to be encoded as FLOAT4') + */ + __pyx_v_fval = ((float)__pyx_v_dval); + + /* "asyncpg/protocol/codecs/float.pyx":14 + * cdef double dval = cpython.PyFloat_AsDouble(obj) + * cdef float fval = dval + * if math.isinf(fval) and not math.isinf(dval): # <<<<<<<<<<<<<< + * raise ValueError('float value too large to be encoded as FLOAT4') + * + */ + __pyx_t_3 = (isinf(__pyx_v_fval) != 0); + if (__pyx_t_3) { + } else { + __pyx_t_2 = __pyx_t_3; + goto __pyx_L4_bool_binop_done; + } + __pyx_t_3 = ((!(isinf(__pyx_v_dval) != 0)) != 0); + __pyx_t_2 = __pyx_t_3; + __pyx_L4_bool_binop_done:; + if (__pyx_t_2) { + + /* "asyncpg/protocol/codecs/float.pyx":15 + * cdef float fval = dval + * if math.isinf(fval) and not math.isinf(dval): + * raise ValueError('float value too large to be encoded as FLOAT4') # <<<<<<<<<<<<<< + * + * buf.write_int32(4) + */ + __pyx_t_4 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__33, NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(10, 15, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_Raise(__pyx_t_4, 0, 0, 0); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __PYX_ERR(10, 15, __pyx_L1_error) + + /* "asyncpg/protocol/codecs/float.pyx":14 + * cdef double dval = cpython.PyFloat_AsDouble(obj) + * cdef float fval = dval + * if math.isinf(fval) and not math.isinf(dval): # <<<<<<<<<<<<<< + * raise ValueError('float value too large to be encoded as FLOAT4') + * + */ + } + + /* "asyncpg/protocol/codecs/float.pyx":17 + * raise ValueError('float value too large to be encoded as FLOAT4') + * + * buf.write_int32(4) # <<<<<<<<<<<<<< + * buf.write_float(fval) + * + */ + __pyx_t_4 = __pyx_f_7asyncpg_8protocol_8protocol_11WriteBuffer_write_int32(__pyx_v_buf, 4); if (unlikely(!__pyx_t_4)) __PYX_ERR(10, 17, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + + /* "asyncpg/protocol/codecs/float.pyx":18 + * + * buf.write_int32(4) + * buf.write_float(fval) # <<<<<<<<<<<<<< + * + * + */ + __pyx_t_4 = __pyx_f_7asyncpg_8protocol_8protocol_11WriteBuffer_write_float(__pyx_v_buf, __pyx_v_fval); if (unlikely(!__pyx_t_4)) __PYX_ERR(10, 18, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + + /* "asyncpg/protocol/codecs/float.pyx":11 + * + * + * cdef float4_encode(ConnectionSettings settings, WriteBuffer buf, obj): # <<<<<<<<<<<<<< + * cdef double dval = cpython.PyFloat_AsDouble(obj) + * cdef float fval = dval + */ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_4); + __Pyx_AddTraceback("asyncpg.protocol.protocol.float4_encode", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "asyncpg/protocol/codecs/float.pyx":21 + * + * + * cdef float4_decode(ConnectionSettings settings, FastReadBuffer buf): # <<<<<<<<<<<<<< + * cdef float f = hton.unpack_float(buf.read(4)) + * return cpython.PyFloat_FromDouble(f) + */ + +static PyObject *__pyx_f_7asyncpg_8protocol_8protocol_float4_decode(CYTHON_UNUSED struct __pyx_obj_7asyncpg_8protocol_8protocol_ConnectionSettings *__pyx_v_settings, struct __pyx_obj_7asyncpg_8protocol_8protocol_FastReadBuffer *__pyx_v_buf) { + float __pyx_v_f; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + char const *__pyx_t_1; + PyObject *__pyx_t_2 = NULL; + __Pyx_RefNannySetupContext("float4_decode", 0); + + /* "asyncpg/protocol/codecs/float.pyx":22 + * + * cdef float4_decode(ConnectionSettings settings, FastReadBuffer buf): + * cdef float f = hton.unpack_float(buf.read(4)) # <<<<<<<<<<<<<< + * return cpython.PyFloat_FromDouble(f) + * + */ + __pyx_t_1 = __pyx_f_7asyncpg_8protocol_8protocol_14FastReadBuffer_read(__pyx_v_buf, 4); if (unlikely(__pyx_t_1 == NULL)) __PYX_ERR(10, 22, __pyx_L1_error) + __pyx_v_f = __pyx_f_7asyncpg_8protocol_4hton_unpack_float(__pyx_t_1); + + /* "asyncpg/protocol/codecs/float.pyx":23 + * cdef float4_decode(ConnectionSettings settings, FastReadBuffer buf): + * cdef float f = hton.unpack_float(buf.read(4)) + * return cpython.PyFloat_FromDouble(f) # <<<<<<<<<<<<<< + * + * + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_2 = PyFloat_FromDouble(__pyx_v_f); if (unlikely(!__pyx_t_2)) __PYX_ERR(10, 23, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_r = __pyx_t_2; + __pyx_t_2 = 0; + goto __pyx_L0; + + /* "asyncpg/protocol/codecs/float.pyx":21 + * + * + * cdef float4_decode(ConnectionSettings settings, FastReadBuffer buf): # <<<<<<<<<<<<<< + * cdef float f = hton.unpack_float(buf.read(4)) + * return cpython.PyFloat_FromDouble(f) + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_2); + __Pyx_AddTraceback("asyncpg.protocol.protocol.float4_decode", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "asyncpg/protocol/codecs/float.pyx":26 + * + * + * cdef float8_encode(ConnectionSettings settings, WriteBuffer buf, obj): # <<<<<<<<<<<<<< + * cdef double dval = cpython.PyFloat_AsDouble(obj) + * buf.write_int32(8) + */ + +static PyObject *__pyx_f_7asyncpg_8protocol_8protocol_float8_encode(CYTHON_UNUSED struct __pyx_obj_7asyncpg_8protocol_8protocol_ConnectionSettings *__pyx_v_settings, struct __pyx_obj_7asyncpg_8protocol_8protocol_WriteBuffer *__pyx_v_buf, PyObject *__pyx_v_obj) { + double __pyx_v_dval; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + double __pyx_t_1; + PyObject *__pyx_t_2 = NULL; + __Pyx_RefNannySetupContext("float8_encode", 0); + + /* "asyncpg/protocol/codecs/float.pyx":27 + * + * cdef float8_encode(ConnectionSettings settings, WriteBuffer buf, obj): + * cdef double dval = cpython.PyFloat_AsDouble(obj) # <<<<<<<<<<<<<< + * buf.write_int32(8) + * buf.write_double(dval) + */ + __pyx_t_1 = PyFloat_AsDouble(__pyx_v_obj); if (unlikely(__pyx_t_1 == -1.0 && PyErr_Occurred())) __PYX_ERR(10, 27, __pyx_L1_error) + __pyx_v_dval = __pyx_t_1; + + /* "asyncpg/protocol/codecs/float.pyx":28 + * cdef float8_encode(ConnectionSettings settings, WriteBuffer buf, obj): + * cdef double dval = cpython.PyFloat_AsDouble(obj) + * buf.write_int32(8) # <<<<<<<<<<<<<< + * buf.write_double(dval) + * + */ + __pyx_t_2 = __pyx_f_7asyncpg_8protocol_8protocol_11WriteBuffer_write_int32(__pyx_v_buf, 8); if (unlikely(!__pyx_t_2)) __PYX_ERR(10, 28, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "asyncpg/protocol/codecs/float.pyx":29 + * cdef double dval = cpython.PyFloat_AsDouble(obj) + * buf.write_int32(8) + * buf.write_double(dval) # <<<<<<<<<<<<<< + * + * + */ + __pyx_t_2 = __pyx_f_7asyncpg_8protocol_8protocol_11WriteBuffer_write_double(__pyx_v_buf, __pyx_v_dval); if (unlikely(!__pyx_t_2)) __PYX_ERR(10, 29, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "asyncpg/protocol/codecs/float.pyx":26 + * + * + * cdef float8_encode(ConnectionSettings settings, WriteBuffer buf, obj): # <<<<<<<<<<<<<< + * cdef double dval = cpython.PyFloat_AsDouble(obj) + * buf.write_int32(8) + */ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_2); + __Pyx_AddTraceback("asyncpg.protocol.protocol.float8_encode", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "asyncpg/protocol/codecs/float.pyx":32 + * + * + * cdef float8_decode(ConnectionSettings settings, FastReadBuffer buf): # <<<<<<<<<<<<<< + * cdef double f = hton.unpack_double(buf.read(8)) + * return cpython.PyFloat_FromDouble(f) + */ + +static PyObject *__pyx_f_7asyncpg_8protocol_8protocol_float8_decode(CYTHON_UNUSED struct __pyx_obj_7asyncpg_8protocol_8protocol_ConnectionSettings *__pyx_v_settings, struct __pyx_obj_7asyncpg_8protocol_8protocol_FastReadBuffer *__pyx_v_buf) { + double __pyx_v_f; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + char const *__pyx_t_1; + PyObject *__pyx_t_2 = NULL; + __Pyx_RefNannySetupContext("float8_decode", 0); + + /* "asyncpg/protocol/codecs/float.pyx":33 + * + * cdef float8_decode(ConnectionSettings settings, FastReadBuffer buf): + * cdef double f = hton.unpack_double(buf.read(8)) # <<<<<<<<<<<<<< + * return cpython.PyFloat_FromDouble(f) + * + */ + __pyx_t_1 = __pyx_f_7asyncpg_8protocol_8protocol_14FastReadBuffer_read(__pyx_v_buf, 8); if (unlikely(__pyx_t_1 == NULL)) __PYX_ERR(10, 33, __pyx_L1_error) + __pyx_v_f = __pyx_f_7asyncpg_8protocol_4hton_unpack_double(__pyx_t_1); + + /* "asyncpg/protocol/codecs/float.pyx":34 + * cdef float8_decode(ConnectionSettings settings, FastReadBuffer buf): + * cdef double f = hton.unpack_double(buf.read(8)) + * return cpython.PyFloat_FromDouble(f) # <<<<<<<<<<<<<< + * + * + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_2 = PyFloat_FromDouble(__pyx_v_f); if (unlikely(!__pyx_t_2)) __PYX_ERR(10, 34, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_r = __pyx_t_2; + __pyx_t_2 = 0; + goto __pyx_L0; + + /* "asyncpg/protocol/codecs/float.pyx":32 + * + * + * cdef float8_decode(ConnectionSettings settings, FastReadBuffer buf): # <<<<<<<<<<<<<< + * cdef double f = hton.unpack_double(buf.read(8)) + * return cpython.PyFloat_FromDouble(f) + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_2); + __Pyx_AddTraceback("asyncpg.protocol.protocol.float8_decode", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "asyncpg/protocol/codecs/float.pyx":37 + * + * + * cdef init_float_codecs(): # <<<<<<<<<<<<<< + * register_core_codec(FLOAT4OID, + * &float4_encode, + */ + +static PyObject *__pyx_f_7asyncpg_8protocol_8protocol_init_float_codecs(void) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + __Pyx_RefNannySetupContext("init_float_codecs", 0); + + /* "asyncpg/protocol/codecs/float.pyx":38 + * + * cdef init_float_codecs(): + * register_core_codec(FLOAT4OID, # <<<<<<<<<<<<<< + * &float4_encode, + * &float4_decode, + */ + __pyx_t_1 = __pyx_f_7asyncpg_8protocol_8protocol_register_core_codec(0x2BC, ((__pyx_t_7asyncpg_8protocol_8protocol_encode_func)(&__pyx_f_7asyncpg_8protocol_8protocol_float4_encode)), ((__pyx_t_7asyncpg_8protocol_8protocol_decode_func)(&__pyx_f_7asyncpg_8protocol_8protocol_float4_decode)), __pyx_e_7asyncpg_8protocol_8protocol_PG_FORMAT_BINARY); if (unlikely(!__pyx_t_1)) __PYX_ERR(10, 38, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "asyncpg/protocol/codecs/float.pyx":43 + * PG_FORMAT_BINARY) + * + * register_core_codec(FLOAT8OID, # <<<<<<<<<<<<<< + * &float8_encode, + * &float8_decode, + */ + __pyx_t_1 = __pyx_f_7asyncpg_8protocol_8protocol_register_core_codec(0x2BD, ((__pyx_t_7asyncpg_8protocol_8protocol_encode_func)(&__pyx_f_7asyncpg_8protocol_8protocol_float8_encode)), ((__pyx_t_7asyncpg_8protocol_8protocol_decode_func)(&__pyx_f_7asyncpg_8protocol_8protocol_float8_decode)), __pyx_e_7asyncpg_8protocol_8protocol_PG_FORMAT_BINARY); if (unlikely(!__pyx_t_1)) __PYX_ERR(10, 43, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "asyncpg/protocol/codecs/float.pyx":37 + * + * + * cdef init_float_codecs(): # <<<<<<<<<<<<<< + * register_core_codec(FLOAT4OID, + * &float4_encode, + */ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("asyncpg.protocol.protocol.init_float_codecs", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "asyncpg/protocol/codecs/geometry.pyx":11 + * + * + * cdef inline _encode_points(WriteBuffer wbuf, object points): # <<<<<<<<<<<<<< + * cdef object point + * + */ + +static CYTHON_INLINE PyObject *__pyx_f_7asyncpg_8protocol_8protocol__encode_points(struct __pyx_obj_7asyncpg_8protocol_8protocol_WriteBuffer *__pyx_v_wbuf, PyObject *__pyx_v_points) { + PyObject *__pyx_v_point = 0; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + Py_ssize_t __pyx_t_2; + PyObject *(*__pyx_t_3)(PyObject *); + PyObject *__pyx_t_4 = NULL; + double __pyx_t_5; + __Pyx_RefNannySetupContext("_encode_points", 0); + + /* "asyncpg/protocol/codecs/geometry.pyx":14 + * cdef object point + * + * for point in points: # <<<<<<<<<<<<<< + * wbuf.write_double(point[0]) + * wbuf.write_double(point[1]) + */ + if (likely(PyList_CheckExact(__pyx_v_points)) || PyTuple_CheckExact(__pyx_v_points)) { + __pyx_t_1 = __pyx_v_points; __Pyx_INCREF(__pyx_t_1); __pyx_t_2 = 0; + __pyx_t_3 = NULL; + } else { + __pyx_t_2 = -1; __pyx_t_1 = PyObject_GetIter(__pyx_v_points); if (unlikely(!__pyx_t_1)) __PYX_ERR(11, 14, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_3 = Py_TYPE(__pyx_t_1)->tp_iternext; if (unlikely(!__pyx_t_3)) __PYX_ERR(11, 14, __pyx_L1_error) + } + for (;;) { + if (likely(!__pyx_t_3)) { + if (likely(PyList_CheckExact(__pyx_t_1))) { + if (__pyx_t_2 >= PyList_GET_SIZE(__pyx_t_1)) break; + #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + __pyx_t_4 = PyList_GET_ITEM(__pyx_t_1, __pyx_t_2); __Pyx_INCREF(__pyx_t_4); __pyx_t_2++; if (unlikely(0 < 0)) __PYX_ERR(11, 14, __pyx_L1_error) + #else + __pyx_t_4 = PySequence_ITEM(__pyx_t_1, __pyx_t_2); __pyx_t_2++; if (unlikely(!__pyx_t_4)) __PYX_ERR(11, 14, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + #endif + } else { + if (__pyx_t_2 >= PyTuple_GET_SIZE(__pyx_t_1)) break; + #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + __pyx_t_4 = PyTuple_GET_ITEM(__pyx_t_1, __pyx_t_2); __Pyx_INCREF(__pyx_t_4); __pyx_t_2++; if (unlikely(0 < 0)) __PYX_ERR(11, 14, __pyx_L1_error) + #else + __pyx_t_4 = PySequence_ITEM(__pyx_t_1, __pyx_t_2); __pyx_t_2++; if (unlikely(!__pyx_t_4)) __PYX_ERR(11, 14, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + #endif + } + } else { + __pyx_t_4 = __pyx_t_3(__pyx_t_1); + if (unlikely(!__pyx_t_4)) { + PyObject* exc_type = PyErr_Occurred(); + if (exc_type) { + if (likely(exc_type == PyExc_StopIteration || PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) PyErr_Clear(); + else __PYX_ERR(11, 14, __pyx_L1_error) + } + break; + } + __Pyx_GOTREF(__pyx_t_4); + } + __Pyx_XDECREF_SET(__pyx_v_point, __pyx_t_4); + __pyx_t_4 = 0; + + /* "asyncpg/protocol/codecs/geometry.pyx":15 + * + * for point in points: + * wbuf.write_double(point[0]) # <<<<<<<<<<<<<< + * wbuf.write_double(point[1]) + * + */ + __pyx_t_4 = __Pyx_GetItemInt(__pyx_v_point, 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_4)) __PYX_ERR(11, 15, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_5 = __pyx_PyFloat_AsDouble(__pyx_t_4); if (unlikely((__pyx_t_5 == (double)-1) && PyErr_Occurred())) __PYX_ERR(11, 15, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_4 = __pyx_f_7asyncpg_8protocol_8protocol_11WriteBuffer_write_double(__pyx_v_wbuf, __pyx_t_5); if (unlikely(!__pyx_t_4)) __PYX_ERR(11, 15, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + + /* "asyncpg/protocol/codecs/geometry.pyx":16 + * for point in points: + * wbuf.write_double(point[0]) + * wbuf.write_double(point[1]) # <<<<<<<<<<<<<< + * + * + */ + __pyx_t_4 = __Pyx_GetItemInt(__pyx_v_point, 1, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_4)) __PYX_ERR(11, 16, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_5 = __pyx_PyFloat_AsDouble(__pyx_t_4); if (unlikely((__pyx_t_5 == (double)-1) && PyErr_Occurred())) __PYX_ERR(11, 16, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_4 = __pyx_f_7asyncpg_8protocol_8protocol_11WriteBuffer_write_double(__pyx_v_wbuf, __pyx_t_5); if (unlikely(!__pyx_t_4)) __PYX_ERR(11, 16, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + + /* "asyncpg/protocol/codecs/geometry.pyx":14 + * cdef object point + * + * for point in points: # <<<<<<<<<<<<<< + * wbuf.write_double(point[0]) + * wbuf.write_double(point[1]) + */ + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "asyncpg/protocol/codecs/geometry.pyx":11 + * + * + * cdef inline _encode_points(WriteBuffer wbuf, object points): # <<<<<<<<<<<<<< + * cdef object point + * + */ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_AddTraceback("asyncpg.protocol.protocol._encode_points", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XDECREF(__pyx_v_point); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "asyncpg/protocol/codecs/geometry.pyx":19 + * + * + * cdef inline _decode_points(FastReadBuffer buf): # <<<<<<<<<<<<<< + * cdef: + * int32_t npts = hton.unpack_int32(buf.read(4)) + */ + +static CYTHON_INLINE PyObject *__pyx_f_7asyncpg_8protocol_8protocol__decode_points(struct __pyx_obj_7asyncpg_8protocol_8protocol_FastReadBuffer *__pyx_v_buf) { + int32_t __pyx_v_npts; + PyObject *__pyx_v_pts = 0; + int32_t __pyx_v_i; + PyObject *__pyx_v_point = 0; + double __pyx_v_x; + double __pyx_v_y; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + char const *__pyx_t_1; + PyObject *__pyx_t_2 = NULL; + int32_t __pyx_t_3; + int32_t __pyx_t_4; + PyObject *__pyx_t_5 = NULL; + PyObject *__pyx_t_6 = NULL; + PyObject *__pyx_t_7 = NULL; + PyObject *__pyx_t_8 = NULL; + int __pyx_t_9; + PyObject *__pyx_t_10 = NULL; + __Pyx_RefNannySetupContext("_decode_points", 0); + + /* "asyncpg/protocol/codecs/geometry.pyx":21 + * cdef inline _decode_points(FastReadBuffer buf): + * cdef: + * int32_t npts = hton.unpack_int32(buf.read(4)) # <<<<<<<<<<<<<< + * pts = cpython.PyTuple_New(npts) + * int32_t i + */ + __pyx_t_1 = __pyx_f_7asyncpg_8protocol_8protocol_14FastReadBuffer_read(__pyx_v_buf, 4); if (unlikely(__pyx_t_1 == NULL)) __PYX_ERR(11, 21, __pyx_L1_error) + __pyx_v_npts = __pyx_f_7asyncpg_8protocol_4hton_unpack_int32(__pyx_t_1); + + /* "asyncpg/protocol/codecs/geometry.pyx":22 + * cdef: + * int32_t npts = hton.unpack_int32(buf.read(4)) + * pts = cpython.PyTuple_New(npts) # <<<<<<<<<<<<<< + * int32_t i + * object point + */ + __pyx_t_2 = PyTuple_New(__pyx_v_npts); if (unlikely(!__pyx_t_2)) __PYX_ERR(11, 22, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_v_pts = __pyx_t_2; + __pyx_t_2 = 0; + + /* "asyncpg/protocol/codecs/geometry.pyx":28 + * double y + * + * for i in range(npts): # <<<<<<<<<<<<<< + * x = hton.unpack_double(buf.read(8)) + * y = hton.unpack_double(buf.read(8)) + */ + __pyx_t_3 = __pyx_v_npts; + for (__pyx_t_4 = 0; __pyx_t_4 < __pyx_t_3; __pyx_t_4+=1) { + __pyx_v_i = __pyx_t_4; + + /* "asyncpg/protocol/codecs/geometry.pyx":29 + * + * for i in range(npts): + * x = hton.unpack_double(buf.read(8)) # <<<<<<<<<<<<<< + * y = hton.unpack_double(buf.read(8)) + * point = Point(x, y) + */ + __pyx_t_1 = __pyx_f_7asyncpg_8protocol_8protocol_14FastReadBuffer_read(__pyx_v_buf, 8); if (unlikely(__pyx_t_1 == NULL)) __PYX_ERR(11, 29, __pyx_L1_error) + __pyx_v_x = __pyx_f_7asyncpg_8protocol_4hton_unpack_double(__pyx_t_1); + + /* "asyncpg/protocol/codecs/geometry.pyx":30 + * for i in range(npts): + * x = hton.unpack_double(buf.read(8)) + * y = hton.unpack_double(buf.read(8)) # <<<<<<<<<<<<<< + * point = Point(x, y) + * cpython.Py_INCREF(point) + */ + __pyx_t_1 = __pyx_f_7asyncpg_8protocol_8protocol_14FastReadBuffer_read(__pyx_v_buf, 8); if (unlikely(__pyx_t_1 == NULL)) __PYX_ERR(11, 30, __pyx_L1_error) + __pyx_v_y = __pyx_f_7asyncpg_8protocol_4hton_unpack_double(__pyx_t_1); + + /* "asyncpg/protocol/codecs/geometry.pyx":31 + * x = hton.unpack_double(buf.read(8)) + * y = hton.unpack_double(buf.read(8)) + * point = Point(x, y) # <<<<<<<<<<<<<< + * cpython.Py_INCREF(point) + * cpython.PyTuple_SET_ITEM(pts, i, point) + */ + __pyx_t_5 = __Pyx_GetModuleGlobalName(__pyx_n_s_Point); if (unlikely(!__pyx_t_5)) __PYX_ERR(11, 31, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_6 = PyFloat_FromDouble(__pyx_v_x); if (unlikely(!__pyx_t_6)) __PYX_ERR(11, 31, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_7 = PyFloat_FromDouble(__pyx_v_y); if (unlikely(!__pyx_t_7)) __PYX_ERR(11, 31, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __pyx_t_8 = NULL; + __pyx_t_9 = 0; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_5))) { + __pyx_t_8 = PyMethod_GET_SELF(__pyx_t_5); + if (likely(__pyx_t_8)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_5); + __Pyx_INCREF(__pyx_t_8); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_5, function); + __pyx_t_9 = 1; + } + } + #if CYTHON_FAST_PYCALL + if (PyFunction_Check(__pyx_t_5)) { + PyObject *__pyx_temp[3] = {__pyx_t_8, __pyx_t_6, __pyx_t_7}; + __pyx_t_2 = __Pyx_PyFunction_FastCall(__pyx_t_5, __pyx_temp+1-__pyx_t_9, 2+__pyx_t_9); if (unlikely(!__pyx_t_2)) __PYX_ERR(11, 31, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + } else + #endif + #if CYTHON_FAST_PYCCALL + if (__Pyx_PyFastCFunction_Check(__pyx_t_5)) { + PyObject *__pyx_temp[3] = {__pyx_t_8, __pyx_t_6, __pyx_t_7}; + __pyx_t_2 = __Pyx_PyCFunction_FastCall(__pyx_t_5, __pyx_temp+1-__pyx_t_9, 2+__pyx_t_9); if (unlikely(!__pyx_t_2)) __PYX_ERR(11, 31, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + } else + #endif + { + __pyx_t_10 = PyTuple_New(2+__pyx_t_9); if (unlikely(!__pyx_t_10)) __PYX_ERR(11, 31, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_10); + if (__pyx_t_8) { + __Pyx_GIVEREF(__pyx_t_8); PyTuple_SET_ITEM(__pyx_t_10, 0, __pyx_t_8); __pyx_t_8 = NULL; + } + __Pyx_GIVEREF(__pyx_t_6); + PyTuple_SET_ITEM(__pyx_t_10, 0+__pyx_t_9, __pyx_t_6); + __Pyx_GIVEREF(__pyx_t_7); + PyTuple_SET_ITEM(__pyx_t_10, 1+__pyx_t_9, __pyx_t_7); + __pyx_t_6 = 0; + __pyx_t_7 = 0; + __pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_5, __pyx_t_10, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(11, 31, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; + } + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_XDECREF_SET(__pyx_v_point, __pyx_t_2); + __pyx_t_2 = 0; + + /* "asyncpg/protocol/codecs/geometry.pyx":32 + * y = hton.unpack_double(buf.read(8)) + * point = Point(x, y) + * cpython.Py_INCREF(point) # <<<<<<<<<<<<<< + * cpython.PyTuple_SET_ITEM(pts, i, point) + * + */ + Py_INCREF(__pyx_v_point); + + /* "asyncpg/protocol/codecs/geometry.pyx":33 + * point = Point(x, y) + * cpython.Py_INCREF(point) + * cpython.PyTuple_SET_ITEM(pts, i, point) # <<<<<<<<<<<<<< + * + * return pts + */ + PyTuple_SET_ITEM(__pyx_v_pts, __pyx_v_i, __pyx_v_point); + } + + /* "asyncpg/protocol/codecs/geometry.pyx":35 + * cpython.PyTuple_SET_ITEM(pts, i, point) + * + * return pts # <<<<<<<<<<<<<< + * + * + */ + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(__pyx_v_pts); + __pyx_r = __pyx_v_pts; + goto __pyx_L0; + + /* "asyncpg/protocol/codecs/geometry.pyx":19 + * + * + * cdef inline _decode_points(FastReadBuffer buf): # <<<<<<<<<<<<<< + * cdef: + * int32_t npts = hton.unpack_int32(buf.read(4)) + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_XDECREF(__pyx_t_6); + __Pyx_XDECREF(__pyx_t_7); + __Pyx_XDECREF(__pyx_t_8); + __Pyx_XDECREF(__pyx_t_10); + __Pyx_AddTraceback("asyncpg.protocol.protocol._decode_points", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XDECREF(__pyx_v_pts); + __Pyx_XDECREF(__pyx_v_point); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "asyncpg/protocol/codecs/geometry.pyx":38 + * + * + * cdef box_encode(ConnectionSettings settings, WriteBuffer wbuf, obj): # <<<<<<<<<<<<<< + * wbuf.write_int32(32) + * _encode_points(wbuf, (obj[0], obj[1])) + */ + +static PyObject *__pyx_f_7asyncpg_8protocol_8protocol_box_encode(CYTHON_UNUSED struct __pyx_obj_7asyncpg_8protocol_8protocol_ConnectionSettings *__pyx_v_settings, struct __pyx_obj_7asyncpg_8protocol_8protocol_WriteBuffer *__pyx_v_wbuf, PyObject *__pyx_v_obj) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + __Pyx_RefNannySetupContext("box_encode", 0); + + /* "asyncpg/protocol/codecs/geometry.pyx":39 + * + * cdef box_encode(ConnectionSettings settings, WriteBuffer wbuf, obj): + * wbuf.write_int32(32) # <<<<<<<<<<<<<< + * _encode_points(wbuf, (obj[0], obj[1])) + * + */ + __pyx_t_1 = __pyx_f_7asyncpg_8protocol_8protocol_11WriteBuffer_write_int32(__pyx_v_wbuf, 32); if (unlikely(!__pyx_t_1)) __PYX_ERR(11, 39, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "asyncpg/protocol/codecs/geometry.pyx":40 + * cdef box_encode(ConnectionSettings settings, WriteBuffer wbuf, obj): + * wbuf.write_int32(32) + * _encode_points(wbuf, (obj[0], obj[1])) # <<<<<<<<<<<<<< + * + * + */ + __pyx_t_1 = __Pyx_GetItemInt(__pyx_v_obj, 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_1)) __PYX_ERR(11, 40, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = __Pyx_GetItemInt(__pyx_v_obj, 1, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_2)) __PYX_ERR(11, 40, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = PyTuple_New(2); if (unlikely(!__pyx_t_3)) __PYX_ERR(11, 40, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_GIVEREF(__pyx_t_1); + PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_t_1); + __Pyx_GIVEREF(__pyx_t_2); + PyTuple_SET_ITEM(__pyx_t_3, 1, __pyx_t_2); + __pyx_t_1 = 0; + __pyx_t_2 = 0; + __pyx_t_2 = __pyx_f_7asyncpg_8protocol_8protocol__encode_points(__pyx_v_wbuf, __pyx_t_3); if (unlikely(!__pyx_t_2)) __PYX_ERR(11, 40, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "asyncpg/protocol/codecs/geometry.pyx":38 + * + * + * cdef box_encode(ConnectionSettings settings, WriteBuffer wbuf, obj): # <<<<<<<<<<<<<< + * wbuf.write_int32(32) + * _encode_points(wbuf, (obj[0], obj[1])) + */ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_AddTraceback("asyncpg.protocol.protocol.box_encode", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "asyncpg/protocol/codecs/geometry.pyx":43 + * + * + * cdef box_decode(ConnectionSettings settings, FastReadBuffer buf): # <<<<<<<<<<<<<< + * cdef: + * double high_x = hton.unpack_double(buf.read(8)) + */ + +static PyObject *__pyx_f_7asyncpg_8protocol_8protocol_box_decode(CYTHON_UNUSED struct __pyx_obj_7asyncpg_8protocol_8protocol_ConnectionSettings *__pyx_v_settings, struct __pyx_obj_7asyncpg_8protocol_8protocol_FastReadBuffer *__pyx_v_buf) { + double __pyx_v_high_x; + double __pyx_v_high_y; + double __pyx_v_low_x; + double __pyx_v_low_y; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + char const *__pyx_t_1; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + PyObject *__pyx_t_5 = NULL; + PyObject *__pyx_t_6 = NULL; + PyObject *__pyx_t_7 = NULL; + PyObject *__pyx_t_8 = NULL; + int __pyx_t_9; + PyObject *__pyx_t_10 = NULL; + PyObject *__pyx_t_11 = NULL; + __Pyx_RefNannySetupContext("box_decode", 0); + + /* "asyncpg/protocol/codecs/geometry.pyx":45 + * cdef box_decode(ConnectionSettings settings, FastReadBuffer buf): + * cdef: + * double high_x = hton.unpack_double(buf.read(8)) # <<<<<<<<<<<<<< + * double high_y = hton.unpack_double(buf.read(8)) + * double low_x = hton.unpack_double(buf.read(8)) + */ + __pyx_t_1 = __pyx_f_7asyncpg_8protocol_8protocol_14FastReadBuffer_read(__pyx_v_buf, 8); if (unlikely(__pyx_t_1 == NULL)) __PYX_ERR(11, 45, __pyx_L1_error) + __pyx_v_high_x = __pyx_f_7asyncpg_8protocol_4hton_unpack_double(__pyx_t_1); + + /* "asyncpg/protocol/codecs/geometry.pyx":46 + * cdef: + * double high_x = hton.unpack_double(buf.read(8)) + * double high_y = hton.unpack_double(buf.read(8)) # <<<<<<<<<<<<<< + * double low_x = hton.unpack_double(buf.read(8)) + * double low_y = hton.unpack_double(buf.read(8)) + */ + __pyx_t_1 = __pyx_f_7asyncpg_8protocol_8protocol_14FastReadBuffer_read(__pyx_v_buf, 8); if (unlikely(__pyx_t_1 == NULL)) __PYX_ERR(11, 46, __pyx_L1_error) + __pyx_v_high_y = __pyx_f_7asyncpg_8protocol_4hton_unpack_double(__pyx_t_1); + + /* "asyncpg/protocol/codecs/geometry.pyx":47 + * double high_x = hton.unpack_double(buf.read(8)) + * double high_y = hton.unpack_double(buf.read(8)) + * double low_x = hton.unpack_double(buf.read(8)) # <<<<<<<<<<<<<< + * double low_y = hton.unpack_double(buf.read(8)) + * + */ + __pyx_t_1 = __pyx_f_7asyncpg_8protocol_8protocol_14FastReadBuffer_read(__pyx_v_buf, 8); if (unlikely(__pyx_t_1 == NULL)) __PYX_ERR(11, 47, __pyx_L1_error) + __pyx_v_low_x = __pyx_f_7asyncpg_8protocol_4hton_unpack_double(__pyx_t_1); + + /* "asyncpg/protocol/codecs/geometry.pyx":48 + * double high_y = hton.unpack_double(buf.read(8)) + * double low_x = hton.unpack_double(buf.read(8)) + * double low_y = hton.unpack_double(buf.read(8)) # <<<<<<<<<<<<<< + * + * return Box(Point(high_x, high_y), Point(low_x, low_y)) + */ + __pyx_t_1 = __pyx_f_7asyncpg_8protocol_8protocol_14FastReadBuffer_read(__pyx_v_buf, 8); if (unlikely(__pyx_t_1 == NULL)) __PYX_ERR(11, 48, __pyx_L1_error) + __pyx_v_low_y = __pyx_f_7asyncpg_8protocol_4hton_unpack_double(__pyx_t_1); + + /* "asyncpg/protocol/codecs/geometry.pyx":50 + * double low_y = hton.unpack_double(buf.read(8)) + * + * return Box(Point(high_x, high_y), Point(low_x, low_y)) # <<<<<<<<<<<<<< + * + * + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_3 = __Pyx_GetModuleGlobalName(__pyx_n_s_Box); if (unlikely(!__pyx_t_3)) __PYX_ERR(11, 50, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_5 = __Pyx_GetModuleGlobalName(__pyx_n_s_Point); if (unlikely(!__pyx_t_5)) __PYX_ERR(11, 50, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_6 = PyFloat_FromDouble(__pyx_v_high_x); if (unlikely(!__pyx_t_6)) __PYX_ERR(11, 50, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_7 = PyFloat_FromDouble(__pyx_v_high_y); if (unlikely(!__pyx_t_7)) __PYX_ERR(11, 50, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __pyx_t_8 = NULL; + __pyx_t_9 = 0; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_5))) { + __pyx_t_8 = PyMethod_GET_SELF(__pyx_t_5); + if (likely(__pyx_t_8)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_5); + __Pyx_INCREF(__pyx_t_8); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_5, function); + __pyx_t_9 = 1; + } + } + #if CYTHON_FAST_PYCALL + if (PyFunction_Check(__pyx_t_5)) { + PyObject *__pyx_temp[3] = {__pyx_t_8, __pyx_t_6, __pyx_t_7}; + __pyx_t_4 = __Pyx_PyFunction_FastCall(__pyx_t_5, __pyx_temp+1-__pyx_t_9, 2+__pyx_t_9); if (unlikely(!__pyx_t_4)) __PYX_ERR(11, 50, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + } else + #endif + #if CYTHON_FAST_PYCCALL + if (__Pyx_PyFastCFunction_Check(__pyx_t_5)) { + PyObject *__pyx_temp[3] = {__pyx_t_8, __pyx_t_6, __pyx_t_7}; + __pyx_t_4 = __Pyx_PyCFunction_FastCall(__pyx_t_5, __pyx_temp+1-__pyx_t_9, 2+__pyx_t_9); if (unlikely(!__pyx_t_4)) __PYX_ERR(11, 50, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + } else + #endif + { + __pyx_t_10 = PyTuple_New(2+__pyx_t_9); if (unlikely(!__pyx_t_10)) __PYX_ERR(11, 50, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_10); + if (__pyx_t_8) { + __Pyx_GIVEREF(__pyx_t_8); PyTuple_SET_ITEM(__pyx_t_10, 0, __pyx_t_8); __pyx_t_8 = NULL; + } + __Pyx_GIVEREF(__pyx_t_6); + PyTuple_SET_ITEM(__pyx_t_10, 0+__pyx_t_9, __pyx_t_6); + __Pyx_GIVEREF(__pyx_t_7); + PyTuple_SET_ITEM(__pyx_t_10, 1+__pyx_t_9, __pyx_t_7); + __pyx_t_6 = 0; + __pyx_t_7 = 0; + __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_5, __pyx_t_10, NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(11, 50, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; + } + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __pyx_t_10 = __Pyx_GetModuleGlobalName(__pyx_n_s_Point); if (unlikely(!__pyx_t_10)) __PYX_ERR(11, 50, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_10); + __pyx_t_7 = PyFloat_FromDouble(__pyx_v_low_x); if (unlikely(!__pyx_t_7)) __PYX_ERR(11, 50, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __pyx_t_6 = PyFloat_FromDouble(__pyx_v_low_y); if (unlikely(!__pyx_t_6)) __PYX_ERR(11, 50, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_8 = NULL; + __pyx_t_9 = 0; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_10))) { + __pyx_t_8 = PyMethod_GET_SELF(__pyx_t_10); + if (likely(__pyx_t_8)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_10); + __Pyx_INCREF(__pyx_t_8); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_10, function); + __pyx_t_9 = 1; + } + } + #if CYTHON_FAST_PYCALL + if (PyFunction_Check(__pyx_t_10)) { + PyObject *__pyx_temp[3] = {__pyx_t_8, __pyx_t_7, __pyx_t_6}; + __pyx_t_5 = __Pyx_PyFunction_FastCall(__pyx_t_10, __pyx_temp+1-__pyx_t_9, 2+__pyx_t_9); if (unlikely(!__pyx_t_5)) __PYX_ERR(11, 50, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; + __Pyx_GOTREF(__pyx_t_5); + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + } else + #endif + #if CYTHON_FAST_PYCCALL + if (__Pyx_PyFastCFunction_Check(__pyx_t_10)) { + PyObject *__pyx_temp[3] = {__pyx_t_8, __pyx_t_7, __pyx_t_6}; + __pyx_t_5 = __Pyx_PyCFunction_FastCall(__pyx_t_10, __pyx_temp+1-__pyx_t_9, 2+__pyx_t_9); if (unlikely(!__pyx_t_5)) __PYX_ERR(11, 50, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; + __Pyx_GOTREF(__pyx_t_5); + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + } else + #endif + { + __pyx_t_11 = PyTuple_New(2+__pyx_t_9); if (unlikely(!__pyx_t_11)) __PYX_ERR(11, 50, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_11); + if (__pyx_t_8) { + __Pyx_GIVEREF(__pyx_t_8); PyTuple_SET_ITEM(__pyx_t_11, 0, __pyx_t_8); __pyx_t_8 = NULL; + } + __Pyx_GIVEREF(__pyx_t_7); + PyTuple_SET_ITEM(__pyx_t_11, 0+__pyx_t_9, __pyx_t_7); + __Pyx_GIVEREF(__pyx_t_6); + PyTuple_SET_ITEM(__pyx_t_11, 1+__pyx_t_9, __pyx_t_6); + __pyx_t_7 = 0; + __pyx_t_6 = 0; + __pyx_t_5 = __Pyx_PyObject_Call(__pyx_t_10, __pyx_t_11, NULL); if (unlikely(!__pyx_t_5)) __PYX_ERR(11, 50, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0; + } + __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; + __pyx_t_10 = NULL; + __pyx_t_9 = 0; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_3))) { + __pyx_t_10 = PyMethod_GET_SELF(__pyx_t_3); + if (likely(__pyx_t_10)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); + __Pyx_INCREF(__pyx_t_10); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_3, function); + __pyx_t_9 = 1; + } + } + #if CYTHON_FAST_PYCALL + if (PyFunction_Check(__pyx_t_3)) { + PyObject *__pyx_temp[3] = {__pyx_t_10, __pyx_t_4, __pyx_t_5}; + __pyx_t_2 = __Pyx_PyFunction_FastCall(__pyx_t_3, __pyx_temp+1-__pyx_t_9, 2+__pyx_t_9); if (unlikely(!__pyx_t_2)) __PYX_ERR(11, 50, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_10); __pyx_t_10 = 0; + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + } else + #endif + #if CYTHON_FAST_PYCCALL + if (__Pyx_PyFastCFunction_Check(__pyx_t_3)) { + PyObject *__pyx_temp[3] = {__pyx_t_10, __pyx_t_4, __pyx_t_5}; + __pyx_t_2 = __Pyx_PyCFunction_FastCall(__pyx_t_3, __pyx_temp+1-__pyx_t_9, 2+__pyx_t_9); if (unlikely(!__pyx_t_2)) __PYX_ERR(11, 50, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_10); __pyx_t_10 = 0; + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + } else + #endif + { + __pyx_t_11 = PyTuple_New(2+__pyx_t_9); if (unlikely(!__pyx_t_11)) __PYX_ERR(11, 50, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_11); + if (__pyx_t_10) { + __Pyx_GIVEREF(__pyx_t_10); PyTuple_SET_ITEM(__pyx_t_11, 0, __pyx_t_10); __pyx_t_10 = NULL; + } + __Pyx_GIVEREF(__pyx_t_4); + PyTuple_SET_ITEM(__pyx_t_11, 0+__pyx_t_9, __pyx_t_4); + __Pyx_GIVEREF(__pyx_t_5); + PyTuple_SET_ITEM(__pyx_t_11, 1+__pyx_t_9, __pyx_t_5); + __pyx_t_4 = 0; + __pyx_t_5 = 0; + __pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_t_11, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(11, 50, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0; + } + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_r = __pyx_t_2; + __pyx_t_2 = 0; + goto __pyx_L0; + + /* "asyncpg/protocol/codecs/geometry.pyx":43 + * + * + * cdef box_decode(ConnectionSettings settings, FastReadBuffer buf): # <<<<<<<<<<<<<< + * cdef: + * double high_x = hton.unpack_double(buf.read(8)) + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_XDECREF(__pyx_t_6); + __Pyx_XDECREF(__pyx_t_7); + __Pyx_XDECREF(__pyx_t_8); + __Pyx_XDECREF(__pyx_t_10); + __Pyx_XDECREF(__pyx_t_11); + __Pyx_AddTraceback("asyncpg.protocol.protocol.box_decode", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "asyncpg/protocol/codecs/geometry.pyx":53 + * + * + * cdef line_encode(ConnectionSettings settings, WriteBuffer wbuf, obj): # <<<<<<<<<<<<<< + * wbuf.write_int32(24) + * wbuf.write_double(obj[0]) + */ + +static PyObject *__pyx_f_7asyncpg_8protocol_8protocol_line_encode(CYTHON_UNUSED struct __pyx_obj_7asyncpg_8protocol_8protocol_ConnectionSettings *__pyx_v_settings, struct __pyx_obj_7asyncpg_8protocol_8protocol_WriteBuffer *__pyx_v_wbuf, PyObject *__pyx_v_obj) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + double __pyx_t_2; + __Pyx_RefNannySetupContext("line_encode", 0); + + /* "asyncpg/protocol/codecs/geometry.pyx":54 + * + * cdef line_encode(ConnectionSettings settings, WriteBuffer wbuf, obj): + * wbuf.write_int32(24) # <<<<<<<<<<<<<< + * wbuf.write_double(obj[0]) + * wbuf.write_double(obj[1]) + */ + __pyx_t_1 = __pyx_f_7asyncpg_8protocol_8protocol_11WriteBuffer_write_int32(__pyx_v_wbuf, 24); if (unlikely(!__pyx_t_1)) __PYX_ERR(11, 54, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "asyncpg/protocol/codecs/geometry.pyx":55 + * cdef line_encode(ConnectionSettings settings, WriteBuffer wbuf, obj): + * wbuf.write_int32(24) + * wbuf.write_double(obj[0]) # <<<<<<<<<<<<<< + * wbuf.write_double(obj[1]) + * wbuf.write_double(obj[2]) + */ + __pyx_t_1 = __Pyx_GetItemInt(__pyx_v_obj, 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_1)) __PYX_ERR(11, 55, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = __pyx_PyFloat_AsDouble(__pyx_t_1); if (unlikely((__pyx_t_2 == (double)-1) && PyErr_Occurred())) __PYX_ERR(11, 55, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_1 = __pyx_f_7asyncpg_8protocol_8protocol_11WriteBuffer_write_double(__pyx_v_wbuf, __pyx_t_2); if (unlikely(!__pyx_t_1)) __PYX_ERR(11, 55, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "asyncpg/protocol/codecs/geometry.pyx":56 + * wbuf.write_int32(24) + * wbuf.write_double(obj[0]) + * wbuf.write_double(obj[1]) # <<<<<<<<<<<<<< + * wbuf.write_double(obj[2]) + * + */ + __pyx_t_1 = __Pyx_GetItemInt(__pyx_v_obj, 1, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_1)) __PYX_ERR(11, 56, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = __pyx_PyFloat_AsDouble(__pyx_t_1); if (unlikely((__pyx_t_2 == (double)-1) && PyErr_Occurred())) __PYX_ERR(11, 56, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_1 = __pyx_f_7asyncpg_8protocol_8protocol_11WriteBuffer_write_double(__pyx_v_wbuf, __pyx_t_2); if (unlikely(!__pyx_t_1)) __PYX_ERR(11, 56, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "asyncpg/protocol/codecs/geometry.pyx":57 + * wbuf.write_double(obj[0]) + * wbuf.write_double(obj[1]) + * wbuf.write_double(obj[2]) # <<<<<<<<<<<<<< + * + * + */ + __pyx_t_1 = __Pyx_GetItemInt(__pyx_v_obj, 2, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_1)) __PYX_ERR(11, 57, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = __pyx_PyFloat_AsDouble(__pyx_t_1); if (unlikely((__pyx_t_2 == (double)-1) && PyErr_Occurred())) __PYX_ERR(11, 57, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_1 = __pyx_f_7asyncpg_8protocol_8protocol_11WriteBuffer_write_double(__pyx_v_wbuf, __pyx_t_2); if (unlikely(!__pyx_t_1)) __PYX_ERR(11, 57, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "asyncpg/protocol/codecs/geometry.pyx":53 + * + * + * cdef line_encode(ConnectionSettings settings, WriteBuffer wbuf, obj): # <<<<<<<<<<<<<< + * wbuf.write_int32(24) + * wbuf.write_double(obj[0]) + */ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("asyncpg.protocol.protocol.line_encode", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "asyncpg/protocol/codecs/geometry.pyx":60 + * + * + * cdef line_decode(ConnectionSettings settings, FastReadBuffer buf): # <<<<<<<<<<<<<< + * cdef: + * double A = hton.unpack_double(buf.read(8)) + */ + +static PyObject *__pyx_f_7asyncpg_8protocol_8protocol_line_decode(CYTHON_UNUSED struct __pyx_obj_7asyncpg_8protocol_8protocol_ConnectionSettings *__pyx_v_settings, struct __pyx_obj_7asyncpg_8protocol_8protocol_FastReadBuffer *__pyx_v_buf) { + double __pyx_v_A; + double __pyx_v_B; + double __pyx_v_C; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + char const *__pyx_t_1; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + PyObject *__pyx_t_5 = NULL; + PyObject *__pyx_t_6 = NULL; + PyObject *__pyx_t_7 = NULL; + int __pyx_t_8; + PyObject *__pyx_t_9 = NULL; + __Pyx_RefNannySetupContext("line_decode", 0); + + /* "asyncpg/protocol/codecs/geometry.pyx":62 + * cdef line_decode(ConnectionSettings settings, FastReadBuffer buf): + * cdef: + * double A = hton.unpack_double(buf.read(8)) # <<<<<<<<<<<<<< + * double B = hton.unpack_double(buf.read(8)) + * double C = hton.unpack_double(buf.read(8)) + */ + __pyx_t_1 = __pyx_f_7asyncpg_8protocol_8protocol_14FastReadBuffer_read(__pyx_v_buf, 8); if (unlikely(__pyx_t_1 == NULL)) __PYX_ERR(11, 62, __pyx_L1_error) + __pyx_v_A = __pyx_f_7asyncpg_8protocol_4hton_unpack_double(__pyx_t_1); + + /* "asyncpg/protocol/codecs/geometry.pyx":63 + * cdef: + * double A = hton.unpack_double(buf.read(8)) + * double B = hton.unpack_double(buf.read(8)) # <<<<<<<<<<<<<< + * double C = hton.unpack_double(buf.read(8)) + * + */ + __pyx_t_1 = __pyx_f_7asyncpg_8protocol_8protocol_14FastReadBuffer_read(__pyx_v_buf, 8); if (unlikely(__pyx_t_1 == NULL)) __PYX_ERR(11, 63, __pyx_L1_error) + __pyx_v_B = __pyx_f_7asyncpg_8protocol_4hton_unpack_double(__pyx_t_1); + + /* "asyncpg/protocol/codecs/geometry.pyx":64 + * double A = hton.unpack_double(buf.read(8)) + * double B = hton.unpack_double(buf.read(8)) + * double C = hton.unpack_double(buf.read(8)) # <<<<<<<<<<<<<< + * + * return Line(A, B, C) + */ + __pyx_t_1 = __pyx_f_7asyncpg_8protocol_8protocol_14FastReadBuffer_read(__pyx_v_buf, 8); if (unlikely(__pyx_t_1 == NULL)) __PYX_ERR(11, 64, __pyx_L1_error) + __pyx_v_C = __pyx_f_7asyncpg_8protocol_4hton_unpack_double(__pyx_t_1); + + /* "asyncpg/protocol/codecs/geometry.pyx":66 + * double C = hton.unpack_double(buf.read(8)) + * + * return Line(A, B, C) # <<<<<<<<<<<<<< + * + * + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_3 = __Pyx_GetModuleGlobalName(__pyx_n_s_Line); if (unlikely(!__pyx_t_3)) __PYX_ERR(11, 66, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = PyFloat_FromDouble(__pyx_v_A); if (unlikely(!__pyx_t_4)) __PYX_ERR(11, 66, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_5 = PyFloat_FromDouble(__pyx_v_B); if (unlikely(!__pyx_t_5)) __PYX_ERR(11, 66, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_6 = PyFloat_FromDouble(__pyx_v_C); if (unlikely(!__pyx_t_6)) __PYX_ERR(11, 66, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_7 = NULL; + __pyx_t_8 = 0; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_3))) { + __pyx_t_7 = PyMethod_GET_SELF(__pyx_t_3); + if (likely(__pyx_t_7)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); + __Pyx_INCREF(__pyx_t_7); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_3, function); + __pyx_t_8 = 1; + } + } + #if CYTHON_FAST_PYCALL + if (PyFunction_Check(__pyx_t_3)) { + PyObject *__pyx_temp[4] = {__pyx_t_7, __pyx_t_4, __pyx_t_5, __pyx_t_6}; + __pyx_t_2 = __Pyx_PyFunction_FastCall(__pyx_t_3, __pyx_temp+1-__pyx_t_8, 3+__pyx_t_8); if (unlikely(!__pyx_t_2)) __PYX_ERR(11, 66, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + } else + #endif + #if CYTHON_FAST_PYCCALL + if (__Pyx_PyFastCFunction_Check(__pyx_t_3)) { + PyObject *__pyx_temp[4] = {__pyx_t_7, __pyx_t_4, __pyx_t_5, __pyx_t_6}; + __pyx_t_2 = __Pyx_PyCFunction_FastCall(__pyx_t_3, __pyx_temp+1-__pyx_t_8, 3+__pyx_t_8); if (unlikely(!__pyx_t_2)) __PYX_ERR(11, 66, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + } else + #endif + { + __pyx_t_9 = PyTuple_New(3+__pyx_t_8); if (unlikely(!__pyx_t_9)) __PYX_ERR(11, 66, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_9); + if (__pyx_t_7) { + __Pyx_GIVEREF(__pyx_t_7); PyTuple_SET_ITEM(__pyx_t_9, 0, __pyx_t_7); __pyx_t_7 = NULL; + } + __Pyx_GIVEREF(__pyx_t_4); + PyTuple_SET_ITEM(__pyx_t_9, 0+__pyx_t_8, __pyx_t_4); + __Pyx_GIVEREF(__pyx_t_5); + PyTuple_SET_ITEM(__pyx_t_9, 1+__pyx_t_8, __pyx_t_5); + __Pyx_GIVEREF(__pyx_t_6); + PyTuple_SET_ITEM(__pyx_t_9, 2+__pyx_t_8, __pyx_t_6); + __pyx_t_4 = 0; + __pyx_t_5 = 0; + __pyx_t_6 = 0; + __pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_t_9, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(11, 66, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + } + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_r = __pyx_t_2; + __pyx_t_2 = 0; + goto __pyx_L0; + + /* "asyncpg/protocol/codecs/geometry.pyx":60 + * + * + * cdef line_decode(ConnectionSettings settings, FastReadBuffer buf): # <<<<<<<<<<<<<< + * cdef: + * double A = hton.unpack_double(buf.read(8)) + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_XDECREF(__pyx_t_6); + __Pyx_XDECREF(__pyx_t_7); + __Pyx_XDECREF(__pyx_t_9); + __Pyx_AddTraceback("asyncpg.protocol.protocol.line_decode", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "asyncpg/protocol/codecs/geometry.pyx":69 + * + * + * cdef lseg_encode(ConnectionSettings settings, WriteBuffer wbuf, obj): # <<<<<<<<<<<<<< + * wbuf.write_int32(32) + * _encode_points(wbuf, (obj[0], obj[1])) + */ + +static PyObject *__pyx_f_7asyncpg_8protocol_8protocol_lseg_encode(CYTHON_UNUSED struct __pyx_obj_7asyncpg_8protocol_8protocol_ConnectionSettings *__pyx_v_settings, struct __pyx_obj_7asyncpg_8protocol_8protocol_WriteBuffer *__pyx_v_wbuf, PyObject *__pyx_v_obj) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + __Pyx_RefNannySetupContext("lseg_encode", 0); + + /* "asyncpg/protocol/codecs/geometry.pyx":70 + * + * cdef lseg_encode(ConnectionSettings settings, WriteBuffer wbuf, obj): + * wbuf.write_int32(32) # <<<<<<<<<<<<<< + * _encode_points(wbuf, (obj[0], obj[1])) + * + */ + __pyx_t_1 = __pyx_f_7asyncpg_8protocol_8protocol_11WriteBuffer_write_int32(__pyx_v_wbuf, 32); if (unlikely(!__pyx_t_1)) __PYX_ERR(11, 70, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "asyncpg/protocol/codecs/geometry.pyx":71 + * cdef lseg_encode(ConnectionSettings settings, WriteBuffer wbuf, obj): + * wbuf.write_int32(32) + * _encode_points(wbuf, (obj[0], obj[1])) # <<<<<<<<<<<<<< + * + * + */ + __pyx_t_1 = __Pyx_GetItemInt(__pyx_v_obj, 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_1)) __PYX_ERR(11, 71, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = __Pyx_GetItemInt(__pyx_v_obj, 1, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_2)) __PYX_ERR(11, 71, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = PyTuple_New(2); if (unlikely(!__pyx_t_3)) __PYX_ERR(11, 71, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_GIVEREF(__pyx_t_1); + PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_t_1); + __Pyx_GIVEREF(__pyx_t_2); + PyTuple_SET_ITEM(__pyx_t_3, 1, __pyx_t_2); + __pyx_t_1 = 0; + __pyx_t_2 = 0; + __pyx_t_2 = __pyx_f_7asyncpg_8protocol_8protocol__encode_points(__pyx_v_wbuf, __pyx_t_3); if (unlikely(!__pyx_t_2)) __PYX_ERR(11, 71, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "asyncpg/protocol/codecs/geometry.pyx":69 + * + * + * cdef lseg_encode(ConnectionSettings settings, WriteBuffer wbuf, obj): # <<<<<<<<<<<<<< + * wbuf.write_int32(32) + * _encode_points(wbuf, (obj[0], obj[1])) + */ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_AddTraceback("asyncpg.protocol.protocol.lseg_encode", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "asyncpg/protocol/codecs/geometry.pyx":74 + * + * + * cdef lseg_decode(ConnectionSettings settings, FastReadBuffer buf): # <<<<<<<<<<<<<< + * cdef: + * double p1_x = hton.unpack_double(buf.read(8)) + */ + +static PyObject *__pyx_f_7asyncpg_8protocol_8protocol_lseg_decode(CYTHON_UNUSED struct __pyx_obj_7asyncpg_8protocol_8protocol_ConnectionSettings *__pyx_v_settings, struct __pyx_obj_7asyncpg_8protocol_8protocol_FastReadBuffer *__pyx_v_buf) { + double __pyx_v_p1_x; + double __pyx_v_p1_y; + double __pyx_v_p2_x; + double __pyx_v_p2_y; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + char const *__pyx_t_1; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + PyObject *__pyx_t_5 = NULL; + PyObject *__pyx_t_6 = NULL; + PyObject *__pyx_t_7 = NULL; + int __pyx_t_8; + __Pyx_RefNannySetupContext("lseg_decode", 0); + + /* "asyncpg/protocol/codecs/geometry.pyx":76 + * cdef lseg_decode(ConnectionSettings settings, FastReadBuffer buf): + * cdef: + * double p1_x = hton.unpack_double(buf.read(8)) # <<<<<<<<<<<<<< + * double p1_y = hton.unpack_double(buf.read(8)) + * double p2_x = hton.unpack_double(buf.read(8)) + */ + __pyx_t_1 = __pyx_f_7asyncpg_8protocol_8protocol_14FastReadBuffer_read(__pyx_v_buf, 8); if (unlikely(__pyx_t_1 == NULL)) __PYX_ERR(11, 76, __pyx_L1_error) + __pyx_v_p1_x = __pyx_f_7asyncpg_8protocol_4hton_unpack_double(__pyx_t_1); + + /* "asyncpg/protocol/codecs/geometry.pyx":77 + * cdef: + * double p1_x = hton.unpack_double(buf.read(8)) + * double p1_y = hton.unpack_double(buf.read(8)) # <<<<<<<<<<<<<< + * double p2_x = hton.unpack_double(buf.read(8)) + * double p2_y = hton.unpack_double(buf.read(8)) + */ + __pyx_t_1 = __pyx_f_7asyncpg_8protocol_8protocol_14FastReadBuffer_read(__pyx_v_buf, 8); if (unlikely(__pyx_t_1 == NULL)) __PYX_ERR(11, 77, __pyx_L1_error) + __pyx_v_p1_y = __pyx_f_7asyncpg_8protocol_4hton_unpack_double(__pyx_t_1); + + /* "asyncpg/protocol/codecs/geometry.pyx":78 + * double p1_x = hton.unpack_double(buf.read(8)) + * double p1_y = hton.unpack_double(buf.read(8)) + * double p2_x = hton.unpack_double(buf.read(8)) # <<<<<<<<<<<<<< + * double p2_y = hton.unpack_double(buf.read(8)) + * + */ + __pyx_t_1 = __pyx_f_7asyncpg_8protocol_8protocol_14FastReadBuffer_read(__pyx_v_buf, 8); if (unlikely(__pyx_t_1 == NULL)) __PYX_ERR(11, 78, __pyx_L1_error) + __pyx_v_p2_x = __pyx_f_7asyncpg_8protocol_4hton_unpack_double(__pyx_t_1); + + /* "asyncpg/protocol/codecs/geometry.pyx":79 + * double p1_y = hton.unpack_double(buf.read(8)) + * double p2_x = hton.unpack_double(buf.read(8)) + * double p2_y = hton.unpack_double(buf.read(8)) # <<<<<<<<<<<<<< + * + * return LineSegment((p1_x, p1_y), (p2_x, p2_y)) + */ + __pyx_t_1 = __pyx_f_7asyncpg_8protocol_8protocol_14FastReadBuffer_read(__pyx_v_buf, 8); if (unlikely(__pyx_t_1 == NULL)) __PYX_ERR(11, 79, __pyx_L1_error) + __pyx_v_p2_y = __pyx_f_7asyncpg_8protocol_4hton_unpack_double(__pyx_t_1); + + /* "asyncpg/protocol/codecs/geometry.pyx":81 + * double p2_y = hton.unpack_double(buf.read(8)) + * + * return LineSegment((p1_x, p1_y), (p2_x, p2_y)) # <<<<<<<<<<<<<< + * + * + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_3 = __Pyx_GetModuleGlobalName(__pyx_n_s_LineSegment); if (unlikely(!__pyx_t_3)) __PYX_ERR(11, 81, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = PyFloat_FromDouble(__pyx_v_p1_x); if (unlikely(!__pyx_t_4)) __PYX_ERR(11, 81, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_5 = PyFloat_FromDouble(__pyx_v_p1_y); if (unlikely(!__pyx_t_5)) __PYX_ERR(11, 81, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_6 = PyTuple_New(2); if (unlikely(!__pyx_t_6)) __PYX_ERR(11, 81, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_GIVEREF(__pyx_t_4); + PyTuple_SET_ITEM(__pyx_t_6, 0, __pyx_t_4); + __Pyx_GIVEREF(__pyx_t_5); + PyTuple_SET_ITEM(__pyx_t_6, 1, __pyx_t_5); + __pyx_t_4 = 0; + __pyx_t_5 = 0; + __pyx_t_5 = PyFloat_FromDouble(__pyx_v_p2_x); if (unlikely(!__pyx_t_5)) __PYX_ERR(11, 81, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_4 = PyFloat_FromDouble(__pyx_v_p2_y); if (unlikely(!__pyx_t_4)) __PYX_ERR(11, 81, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_7 = PyTuple_New(2); if (unlikely(!__pyx_t_7)) __PYX_ERR(11, 81, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __Pyx_GIVEREF(__pyx_t_5); + PyTuple_SET_ITEM(__pyx_t_7, 0, __pyx_t_5); + __Pyx_GIVEREF(__pyx_t_4); + PyTuple_SET_ITEM(__pyx_t_7, 1, __pyx_t_4); + __pyx_t_5 = 0; + __pyx_t_4 = 0; + __pyx_t_4 = NULL; + __pyx_t_8 = 0; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_3))) { + __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_3); + if (likely(__pyx_t_4)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); + __Pyx_INCREF(__pyx_t_4); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_3, function); + __pyx_t_8 = 1; + } + } + #if CYTHON_FAST_PYCALL + if (PyFunction_Check(__pyx_t_3)) { + PyObject *__pyx_temp[3] = {__pyx_t_4, __pyx_t_6, __pyx_t_7}; + __pyx_t_2 = __Pyx_PyFunction_FastCall(__pyx_t_3, __pyx_temp+1-__pyx_t_8, 2+__pyx_t_8); if (unlikely(!__pyx_t_2)) __PYX_ERR(11, 81, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + } else + #endif + #if CYTHON_FAST_PYCCALL + if (__Pyx_PyFastCFunction_Check(__pyx_t_3)) { + PyObject *__pyx_temp[3] = {__pyx_t_4, __pyx_t_6, __pyx_t_7}; + __pyx_t_2 = __Pyx_PyCFunction_FastCall(__pyx_t_3, __pyx_temp+1-__pyx_t_8, 2+__pyx_t_8); if (unlikely(!__pyx_t_2)) __PYX_ERR(11, 81, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + } else + #endif + { + __pyx_t_5 = PyTuple_New(2+__pyx_t_8); if (unlikely(!__pyx_t_5)) __PYX_ERR(11, 81, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + if (__pyx_t_4) { + __Pyx_GIVEREF(__pyx_t_4); PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_t_4); __pyx_t_4 = NULL; + } + __Pyx_GIVEREF(__pyx_t_6); + PyTuple_SET_ITEM(__pyx_t_5, 0+__pyx_t_8, __pyx_t_6); + __Pyx_GIVEREF(__pyx_t_7); + PyTuple_SET_ITEM(__pyx_t_5, 1+__pyx_t_8, __pyx_t_7); + __pyx_t_6 = 0; + __pyx_t_7 = 0; + __pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_t_5, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(11, 81, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + } + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_r = __pyx_t_2; + __pyx_t_2 = 0; + goto __pyx_L0; + + /* "asyncpg/protocol/codecs/geometry.pyx":74 + * + * + * cdef lseg_decode(ConnectionSettings settings, FastReadBuffer buf): # <<<<<<<<<<<<<< + * cdef: + * double p1_x = hton.unpack_double(buf.read(8)) + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_XDECREF(__pyx_t_6); + __Pyx_XDECREF(__pyx_t_7); + __Pyx_AddTraceback("asyncpg.protocol.protocol.lseg_decode", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "asyncpg/protocol/codecs/geometry.pyx":84 + * + * + * cdef point_encode(ConnectionSettings settings, WriteBuffer wbuf, obj): # <<<<<<<<<<<<<< + * wbuf.write_int32(16) + * wbuf.write_double(obj[0]) + */ + +static PyObject *__pyx_f_7asyncpg_8protocol_8protocol_point_encode(CYTHON_UNUSED struct __pyx_obj_7asyncpg_8protocol_8protocol_ConnectionSettings *__pyx_v_settings, struct __pyx_obj_7asyncpg_8protocol_8protocol_WriteBuffer *__pyx_v_wbuf, PyObject *__pyx_v_obj) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + double __pyx_t_2; + __Pyx_RefNannySetupContext("point_encode", 0); + + /* "asyncpg/protocol/codecs/geometry.pyx":85 + * + * cdef point_encode(ConnectionSettings settings, WriteBuffer wbuf, obj): + * wbuf.write_int32(16) # <<<<<<<<<<<<<< + * wbuf.write_double(obj[0]) + * wbuf.write_double(obj[1]) + */ + __pyx_t_1 = __pyx_f_7asyncpg_8protocol_8protocol_11WriteBuffer_write_int32(__pyx_v_wbuf, 16); if (unlikely(!__pyx_t_1)) __PYX_ERR(11, 85, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "asyncpg/protocol/codecs/geometry.pyx":86 + * cdef point_encode(ConnectionSettings settings, WriteBuffer wbuf, obj): + * wbuf.write_int32(16) + * wbuf.write_double(obj[0]) # <<<<<<<<<<<<<< + * wbuf.write_double(obj[1]) + * + */ + __pyx_t_1 = __Pyx_GetItemInt(__pyx_v_obj, 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_1)) __PYX_ERR(11, 86, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = __pyx_PyFloat_AsDouble(__pyx_t_1); if (unlikely((__pyx_t_2 == (double)-1) && PyErr_Occurred())) __PYX_ERR(11, 86, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_1 = __pyx_f_7asyncpg_8protocol_8protocol_11WriteBuffer_write_double(__pyx_v_wbuf, __pyx_t_2); if (unlikely(!__pyx_t_1)) __PYX_ERR(11, 86, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "asyncpg/protocol/codecs/geometry.pyx":87 + * wbuf.write_int32(16) + * wbuf.write_double(obj[0]) + * wbuf.write_double(obj[1]) # <<<<<<<<<<<<<< + * + * + */ + __pyx_t_1 = __Pyx_GetItemInt(__pyx_v_obj, 1, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_1)) __PYX_ERR(11, 87, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = __pyx_PyFloat_AsDouble(__pyx_t_1); if (unlikely((__pyx_t_2 == (double)-1) && PyErr_Occurred())) __PYX_ERR(11, 87, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_1 = __pyx_f_7asyncpg_8protocol_8protocol_11WriteBuffer_write_double(__pyx_v_wbuf, __pyx_t_2); if (unlikely(!__pyx_t_1)) __PYX_ERR(11, 87, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "asyncpg/protocol/codecs/geometry.pyx":84 + * + * + * cdef point_encode(ConnectionSettings settings, WriteBuffer wbuf, obj): # <<<<<<<<<<<<<< + * wbuf.write_int32(16) + * wbuf.write_double(obj[0]) + */ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("asyncpg.protocol.protocol.point_encode", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "asyncpg/protocol/codecs/geometry.pyx":90 + * + * + * cdef point_decode(ConnectionSettings settings, FastReadBuffer buf): # <<<<<<<<<<<<<< + * cdef: + * double x = hton.unpack_double(buf.read(8)) + */ + +static PyObject *__pyx_f_7asyncpg_8protocol_8protocol_point_decode(CYTHON_UNUSED struct __pyx_obj_7asyncpg_8protocol_8protocol_ConnectionSettings *__pyx_v_settings, struct __pyx_obj_7asyncpg_8protocol_8protocol_FastReadBuffer *__pyx_v_buf) { + double __pyx_v_x; + double __pyx_v_y; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + char const *__pyx_t_1; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + PyObject *__pyx_t_5 = NULL; + PyObject *__pyx_t_6 = NULL; + int __pyx_t_7; + PyObject *__pyx_t_8 = NULL; + __Pyx_RefNannySetupContext("point_decode", 0); + + /* "asyncpg/protocol/codecs/geometry.pyx":92 + * cdef point_decode(ConnectionSettings settings, FastReadBuffer buf): + * cdef: + * double x = hton.unpack_double(buf.read(8)) # <<<<<<<<<<<<<< + * double y = hton.unpack_double(buf.read(8)) + * + */ + __pyx_t_1 = __pyx_f_7asyncpg_8protocol_8protocol_14FastReadBuffer_read(__pyx_v_buf, 8); if (unlikely(__pyx_t_1 == NULL)) __PYX_ERR(11, 92, __pyx_L1_error) + __pyx_v_x = __pyx_f_7asyncpg_8protocol_4hton_unpack_double(__pyx_t_1); + + /* "asyncpg/protocol/codecs/geometry.pyx":93 + * cdef: + * double x = hton.unpack_double(buf.read(8)) + * double y = hton.unpack_double(buf.read(8)) # <<<<<<<<<<<<<< + * + * return Point(x, y) + */ + __pyx_t_1 = __pyx_f_7asyncpg_8protocol_8protocol_14FastReadBuffer_read(__pyx_v_buf, 8); if (unlikely(__pyx_t_1 == NULL)) __PYX_ERR(11, 93, __pyx_L1_error) + __pyx_v_y = __pyx_f_7asyncpg_8protocol_4hton_unpack_double(__pyx_t_1); + + /* "asyncpg/protocol/codecs/geometry.pyx":95 + * double y = hton.unpack_double(buf.read(8)) + * + * return Point(x, y) # <<<<<<<<<<<<<< + * + * + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_3 = __Pyx_GetModuleGlobalName(__pyx_n_s_Point); if (unlikely(!__pyx_t_3)) __PYX_ERR(11, 95, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = PyFloat_FromDouble(__pyx_v_x); if (unlikely(!__pyx_t_4)) __PYX_ERR(11, 95, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_5 = PyFloat_FromDouble(__pyx_v_y); if (unlikely(!__pyx_t_5)) __PYX_ERR(11, 95, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_6 = NULL; + __pyx_t_7 = 0; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_3))) { + __pyx_t_6 = PyMethod_GET_SELF(__pyx_t_3); + if (likely(__pyx_t_6)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); + __Pyx_INCREF(__pyx_t_6); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_3, function); + __pyx_t_7 = 1; + } + } + #if CYTHON_FAST_PYCALL + if (PyFunction_Check(__pyx_t_3)) { + PyObject *__pyx_temp[3] = {__pyx_t_6, __pyx_t_4, __pyx_t_5}; + __pyx_t_2 = __Pyx_PyFunction_FastCall(__pyx_t_3, __pyx_temp+1-__pyx_t_7, 2+__pyx_t_7); if (unlikely(!__pyx_t_2)) __PYX_ERR(11, 95, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + } else + #endif + #if CYTHON_FAST_PYCCALL + if (__Pyx_PyFastCFunction_Check(__pyx_t_3)) { + PyObject *__pyx_temp[3] = {__pyx_t_6, __pyx_t_4, __pyx_t_5}; + __pyx_t_2 = __Pyx_PyCFunction_FastCall(__pyx_t_3, __pyx_temp+1-__pyx_t_7, 2+__pyx_t_7); if (unlikely(!__pyx_t_2)) __PYX_ERR(11, 95, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + } else + #endif + { + __pyx_t_8 = PyTuple_New(2+__pyx_t_7); if (unlikely(!__pyx_t_8)) __PYX_ERR(11, 95, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + if (__pyx_t_6) { + __Pyx_GIVEREF(__pyx_t_6); PyTuple_SET_ITEM(__pyx_t_8, 0, __pyx_t_6); __pyx_t_6 = NULL; + } + __Pyx_GIVEREF(__pyx_t_4); + PyTuple_SET_ITEM(__pyx_t_8, 0+__pyx_t_7, __pyx_t_4); + __Pyx_GIVEREF(__pyx_t_5); + PyTuple_SET_ITEM(__pyx_t_8, 1+__pyx_t_7, __pyx_t_5); + __pyx_t_4 = 0; + __pyx_t_5 = 0; + __pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_t_8, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(11, 95, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + } + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_r = __pyx_t_2; + __pyx_t_2 = 0; + goto __pyx_L0; + + /* "asyncpg/protocol/codecs/geometry.pyx":90 + * + * + * cdef point_decode(ConnectionSettings settings, FastReadBuffer buf): # <<<<<<<<<<<<<< + * cdef: + * double x = hton.unpack_double(buf.read(8)) + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_XDECREF(__pyx_t_6); + __Pyx_XDECREF(__pyx_t_8); + __Pyx_AddTraceback("asyncpg.protocol.protocol.point_decode", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "asyncpg/protocol/codecs/geometry.pyx":98 + * + * + * cdef path_encode(ConnectionSettings settings, WriteBuffer wbuf, obj): # <<<<<<<<<<<<<< + * cdef: + * int8_t is_closed = 0 + */ + +static PyObject *__pyx_f_7asyncpg_8protocol_8protocol_path_encode(CYTHON_UNUSED struct __pyx_obj_7asyncpg_8protocol_8protocol_ConnectionSettings *__pyx_v_settings, struct __pyx_obj_7asyncpg_8protocol_8protocol_WriteBuffer *__pyx_v_wbuf, PyObject *__pyx_v_obj) { + int8_t __pyx_v_is_closed; + Py_ssize_t __pyx_v_npts; + Py_ssize_t __pyx_v_encoded_len; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + PyObject *__pyx_t_2 = NULL; + int __pyx_t_3; + int8_t __pyx_t_4; + Py_ssize_t __pyx_t_5; + __Pyx_RefNannySetupContext("path_encode", 0); + + /* "asyncpg/protocol/codecs/geometry.pyx":100 + * cdef path_encode(ConnectionSettings settings, WriteBuffer wbuf, obj): + * cdef: + * int8_t is_closed = 0 # <<<<<<<<<<<<<< + * ssize_t npts + * ssize_t encoded_len + */ + __pyx_v_is_closed = 0; + + /* "asyncpg/protocol/codecs/geometry.pyx":105 + * int32_t i + * + * if cpython.PyTuple_Check(obj): # <<<<<<<<<<<<<< + * is_closed = 1 + * elif cpython.PyList_Check(obj): + */ + __pyx_t_1 = (PyTuple_Check(__pyx_v_obj) != 0); + if (__pyx_t_1) { + + /* "asyncpg/protocol/codecs/geometry.pyx":106 + * + * if cpython.PyTuple_Check(obj): + * is_closed = 1 # <<<<<<<<<<<<<< + * elif cpython.PyList_Check(obj): + * is_closed = 0 + */ + __pyx_v_is_closed = 1; + + /* "asyncpg/protocol/codecs/geometry.pyx":105 + * int32_t i + * + * if cpython.PyTuple_Check(obj): # <<<<<<<<<<<<<< + * is_closed = 1 + * elif cpython.PyList_Check(obj): + */ + goto __pyx_L3; + } + + /* "asyncpg/protocol/codecs/geometry.pyx":107 + * if cpython.PyTuple_Check(obj): + * is_closed = 1 + * elif cpython.PyList_Check(obj): # <<<<<<<<<<<<<< + * is_closed = 0 + * elif isinstance(obj, Path): + */ + __pyx_t_1 = (PyList_Check(__pyx_v_obj) != 0); + if (__pyx_t_1) { + + /* "asyncpg/protocol/codecs/geometry.pyx":108 + * is_closed = 1 + * elif cpython.PyList_Check(obj): + * is_closed = 0 # <<<<<<<<<<<<<< + * elif isinstance(obj, Path): + * is_closed = obj.is_closed + */ + __pyx_v_is_closed = 0; + + /* "asyncpg/protocol/codecs/geometry.pyx":107 + * if cpython.PyTuple_Check(obj): + * is_closed = 1 + * elif cpython.PyList_Check(obj): # <<<<<<<<<<<<<< + * is_closed = 0 + * elif isinstance(obj, Path): + */ + goto __pyx_L3; + } + + /* "asyncpg/protocol/codecs/geometry.pyx":109 + * elif cpython.PyList_Check(obj): + * is_closed = 0 + * elif isinstance(obj, Path): # <<<<<<<<<<<<<< + * is_closed = obj.is_closed + * + */ + __pyx_t_2 = __Pyx_GetModuleGlobalName(__pyx_n_s_Path); if (unlikely(!__pyx_t_2)) __PYX_ERR(11, 109, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_1 = PyObject_IsInstance(__pyx_v_obj, __pyx_t_2); if (unlikely(__pyx_t_1 == -1)) __PYX_ERR(11, 109, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_3 = (__pyx_t_1 != 0); + if (__pyx_t_3) { + + /* "asyncpg/protocol/codecs/geometry.pyx":110 + * is_closed = 0 + * elif isinstance(obj, Path): + * is_closed = obj.is_closed # <<<<<<<<<<<<<< + * + * npts = len(obj) + */ + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_obj, __pyx_n_s_is_closed); if (unlikely(!__pyx_t_2)) __PYX_ERR(11, 110, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_4 = __Pyx_PyInt_As_int8_t(__pyx_t_2); if (unlikely((__pyx_t_4 == ((int8_t)-1)) && PyErr_Occurred())) __PYX_ERR(11, 110, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_v_is_closed = __pyx_t_4; + + /* "asyncpg/protocol/codecs/geometry.pyx":109 + * elif cpython.PyList_Check(obj): + * is_closed = 0 + * elif isinstance(obj, Path): # <<<<<<<<<<<<<< + * is_closed = obj.is_closed + * + */ + } + __pyx_L3:; + + /* "asyncpg/protocol/codecs/geometry.pyx":112 + * is_closed = obj.is_closed + * + * npts = len(obj) # <<<<<<<<<<<<<< + * encoded_len = 1 + 4 + 16 * npts + * if encoded_len > _MAXINT32: + */ + __pyx_t_5 = PyObject_Length(__pyx_v_obj); if (unlikely(__pyx_t_5 == -1)) __PYX_ERR(11, 112, __pyx_L1_error) + __pyx_v_npts = __pyx_t_5; + + /* "asyncpg/protocol/codecs/geometry.pyx":113 + * + * npts = len(obj) + * encoded_len = 1 + 4 + 16 * npts # <<<<<<<<<<<<<< + * if encoded_len > _MAXINT32: + * raise ValueError('path value too long') + */ + __pyx_v_encoded_len = (5 + (16 * __pyx_v_npts)); + + /* "asyncpg/protocol/codecs/geometry.pyx":114 + * npts = len(obj) + * encoded_len = 1 + 4 + 16 * npts + * if encoded_len > _MAXINT32: # <<<<<<<<<<<<<< + * raise ValueError('path value too long') + * + */ + __pyx_t_3 = ((__pyx_v_encoded_len > 0x7FFFFFFF) != 0); + if (__pyx_t_3) { + + /* "asyncpg/protocol/codecs/geometry.pyx":115 + * encoded_len = 1 + 4 + 16 * npts + * if encoded_len > _MAXINT32: + * raise ValueError('path value too long') # <<<<<<<<<<<<<< + * + * wbuf.write_int32(encoded_len) + */ + __pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__34, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(11, 115, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_Raise(__pyx_t_2, 0, 0, 0); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __PYX_ERR(11, 115, __pyx_L1_error) + + /* "asyncpg/protocol/codecs/geometry.pyx":114 + * npts = len(obj) + * encoded_len = 1 + 4 + 16 * npts + * if encoded_len > _MAXINT32: # <<<<<<<<<<<<<< + * raise ValueError('path value too long') + * + */ + } + + /* "asyncpg/protocol/codecs/geometry.pyx":117 + * raise ValueError('path value too long') + * + * wbuf.write_int32(encoded_len) # <<<<<<<<<<<<<< + * wbuf.write_byte(is_closed) + * wbuf.write_int32(npts) + */ + __pyx_t_2 = __pyx_f_7asyncpg_8protocol_8protocol_11WriteBuffer_write_int32(__pyx_v_wbuf, ((int32_t)__pyx_v_encoded_len)); if (unlikely(!__pyx_t_2)) __PYX_ERR(11, 117, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "asyncpg/protocol/codecs/geometry.pyx":118 + * + * wbuf.write_int32(encoded_len) + * wbuf.write_byte(is_closed) # <<<<<<<<<<<<<< + * wbuf.write_int32(npts) + * + */ + __pyx_t_2 = __pyx_f_7asyncpg_8protocol_8protocol_11WriteBuffer_write_byte(__pyx_v_wbuf, __pyx_v_is_closed); if (unlikely(!__pyx_t_2)) __PYX_ERR(11, 118, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "asyncpg/protocol/codecs/geometry.pyx":119 + * wbuf.write_int32(encoded_len) + * wbuf.write_byte(is_closed) + * wbuf.write_int32(npts) # <<<<<<<<<<<<<< + * + * _encode_points(wbuf, obj) + */ + __pyx_t_2 = __pyx_f_7asyncpg_8protocol_8protocol_11WriteBuffer_write_int32(__pyx_v_wbuf, ((int32_t)__pyx_v_npts)); if (unlikely(!__pyx_t_2)) __PYX_ERR(11, 119, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "asyncpg/protocol/codecs/geometry.pyx":121 + * wbuf.write_int32(npts) + * + * _encode_points(wbuf, obj) # <<<<<<<<<<<<<< + * + * + */ + __pyx_t_2 = __pyx_f_7asyncpg_8protocol_8protocol__encode_points(__pyx_v_wbuf, __pyx_v_obj); if (unlikely(!__pyx_t_2)) __PYX_ERR(11, 121, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "asyncpg/protocol/codecs/geometry.pyx":98 + * + * + * cdef path_encode(ConnectionSettings settings, WriteBuffer wbuf, obj): # <<<<<<<<<<<<<< + * cdef: + * int8_t is_closed = 0 + */ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_2); + __Pyx_AddTraceback("asyncpg.protocol.protocol.path_encode", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "asyncpg/protocol/codecs/geometry.pyx":124 + * + * + * cdef path_decode(ConnectionSettings settings, FastReadBuffer buf): # <<<<<<<<<<<<<< + * cdef: + * int8_t is_closed = buf.read(1)[0] + */ + +static PyObject *__pyx_f_7asyncpg_8protocol_8protocol_path_decode(CYTHON_UNUSED struct __pyx_obj_7asyncpg_8protocol_8protocol_ConnectionSettings *__pyx_v_settings, struct __pyx_obj_7asyncpg_8protocol_8protocol_FastReadBuffer *__pyx_v_buf) { + int8_t __pyx_v_is_closed; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + char const *__pyx_t_1; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + PyObject *__pyx_t_5 = NULL; + __Pyx_RefNannySetupContext("path_decode", 0); + + /* "asyncpg/protocol/codecs/geometry.pyx":126 + * cdef path_decode(ConnectionSettings settings, FastReadBuffer buf): + * cdef: + * int8_t is_closed = buf.read(1)[0] # <<<<<<<<<<<<<< + * + * return Path(*_decode_points(buf), is_closed=is_closed == 1) + */ + __pyx_t_1 = __pyx_f_7asyncpg_8protocol_8protocol_14FastReadBuffer_read(__pyx_v_buf, 1); if (unlikely(__pyx_t_1 == NULL)) __PYX_ERR(11, 126, __pyx_L1_error) + __pyx_v_is_closed = ((int8_t)(__pyx_t_1[0])); + + /* "asyncpg/protocol/codecs/geometry.pyx":128 + * int8_t is_closed = buf.read(1)[0] + * + * return Path(*_decode_points(buf), is_closed=is_closed == 1) # <<<<<<<<<<<<<< + * + * + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_2 = __Pyx_GetModuleGlobalName(__pyx_n_s_Path); if (unlikely(!__pyx_t_2)) __PYX_ERR(11, 128, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = __pyx_f_7asyncpg_8protocol_8protocol__decode_points(__pyx_v_buf); if (unlikely(!__pyx_t_3)) __PYX_ERR(11, 128, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = PySequence_Tuple(__pyx_t_3); if (unlikely(!__pyx_t_4)) __PYX_ERR(11, 128, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_3 = PyDict_New(); if (unlikely(!__pyx_t_3)) __PYX_ERR(11, 128, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_5 = __Pyx_PyBool_FromLong((__pyx_v_is_closed == 1)); if (unlikely(!__pyx_t_5)) __PYX_ERR(11, 128, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + if (PyDict_SetItem(__pyx_t_3, __pyx_n_s_is_closed, __pyx_t_5) < 0) __PYX_ERR(11, 128, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __pyx_t_5 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_t_4, __pyx_t_3); if (unlikely(!__pyx_t_5)) __PYX_ERR(11, 128, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_r = __pyx_t_5; + __pyx_t_5 = 0; + goto __pyx_L0; + + /* "asyncpg/protocol/codecs/geometry.pyx":124 + * + * + * cdef path_decode(ConnectionSettings settings, FastReadBuffer buf): # <<<<<<<<<<<<<< + * cdef: + * int8_t is_closed = buf.read(1)[0] + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_AddTraceback("asyncpg.protocol.protocol.path_decode", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "asyncpg/protocol/codecs/geometry.pyx":131 + * + * + * cdef poly_encode(ConnectionSettings settings, WriteBuffer wbuf, obj): # <<<<<<<<<<<<<< + * cdef: + * bint is_closed + */ + +static PyObject *__pyx_f_7asyncpg_8protocol_8protocol_poly_encode(CYTHON_UNUSED struct __pyx_obj_7asyncpg_8protocol_8protocol_ConnectionSettings *__pyx_v_settings, struct __pyx_obj_7asyncpg_8protocol_8protocol_WriteBuffer *__pyx_v_wbuf, PyObject *__pyx_v_obj) { + Py_ssize_t __pyx_v_npts; + Py_ssize_t __pyx_v_encoded_len; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + Py_ssize_t __pyx_t_1; + int __pyx_t_2; + PyObject *__pyx_t_3 = NULL; + __Pyx_RefNannySetupContext("poly_encode", 0); + + /* "asyncpg/protocol/codecs/geometry.pyx":138 + * int32_t i + * + * npts = len(obj) # <<<<<<<<<<<<<< + * encoded_len = 4 + 16 * npts + * if encoded_len > _MAXINT32: + */ + __pyx_t_1 = PyObject_Length(__pyx_v_obj); if (unlikely(__pyx_t_1 == -1)) __PYX_ERR(11, 138, __pyx_L1_error) + __pyx_v_npts = __pyx_t_1; + + /* "asyncpg/protocol/codecs/geometry.pyx":139 + * + * npts = len(obj) + * encoded_len = 4 + 16 * npts # <<<<<<<<<<<<<< + * if encoded_len > _MAXINT32: + * raise ValueError('polygon value too long') + */ + __pyx_v_encoded_len = (4 + (16 * __pyx_v_npts)); + + /* "asyncpg/protocol/codecs/geometry.pyx":140 + * npts = len(obj) + * encoded_len = 4 + 16 * npts + * if encoded_len > _MAXINT32: # <<<<<<<<<<<<<< + * raise ValueError('polygon value too long') + * + */ + __pyx_t_2 = ((__pyx_v_encoded_len > 0x7FFFFFFF) != 0); + if (__pyx_t_2) { + + /* "asyncpg/protocol/codecs/geometry.pyx":141 + * encoded_len = 4 + 16 * npts + * if encoded_len > _MAXINT32: + * raise ValueError('polygon value too long') # <<<<<<<<<<<<<< + * + * wbuf.write_int32(encoded_len) + */ + __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__35, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(11, 141, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_Raise(__pyx_t_3, 0, 0, 0); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __PYX_ERR(11, 141, __pyx_L1_error) + + /* "asyncpg/protocol/codecs/geometry.pyx":140 + * npts = len(obj) + * encoded_len = 4 + 16 * npts + * if encoded_len > _MAXINT32: # <<<<<<<<<<<<<< + * raise ValueError('polygon value too long') + * + */ + } + + /* "asyncpg/protocol/codecs/geometry.pyx":143 + * raise ValueError('polygon value too long') + * + * wbuf.write_int32(encoded_len) # <<<<<<<<<<<<<< + * wbuf.write_int32(npts) + * _encode_points(wbuf, obj) + */ + __pyx_t_3 = __pyx_f_7asyncpg_8protocol_8protocol_11WriteBuffer_write_int32(__pyx_v_wbuf, ((int32_t)__pyx_v_encoded_len)); if (unlikely(!__pyx_t_3)) __PYX_ERR(11, 143, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + + /* "asyncpg/protocol/codecs/geometry.pyx":144 + * + * wbuf.write_int32(encoded_len) + * wbuf.write_int32(npts) # <<<<<<<<<<<<<< + * _encode_points(wbuf, obj) + * + */ + __pyx_t_3 = __pyx_f_7asyncpg_8protocol_8protocol_11WriteBuffer_write_int32(__pyx_v_wbuf, ((int32_t)__pyx_v_npts)); if (unlikely(!__pyx_t_3)) __PYX_ERR(11, 144, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + + /* "asyncpg/protocol/codecs/geometry.pyx":145 + * wbuf.write_int32(encoded_len) + * wbuf.write_int32(npts) + * _encode_points(wbuf, obj) # <<<<<<<<<<<<<< + * + * + */ + __pyx_t_3 = __pyx_f_7asyncpg_8protocol_8protocol__encode_points(__pyx_v_wbuf, __pyx_v_obj); if (unlikely(!__pyx_t_3)) __PYX_ERR(11, 145, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + + /* "asyncpg/protocol/codecs/geometry.pyx":131 + * + * + * cdef poly_encode(ConnectionSettings settings, WriteBuffer wbuf, obj): # <<<<<<<<<<<<<< + * cdef: + * bint is_closed + */ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_3); + __Pyx_AddTraceback("asyncpg.protocol.protocol.poly_encode", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "asyncpg/protocol/codecs/geometry.pyx":148 + * + * + * cdef poly_decode(ConnectionSettings settings, FastReadBuffer buf): # <<<<<<<<<<<<<< + * return Polygon(*_decode_points(buf)) + * + */ + +static PyObject *__pyx_f_7asyncpg_8protocol_8protocol_poly_decode(CYTHON_UNUSED struct __pyx_obj_7asyncpg_8protocol_8protocol_ConnectionSettings *__pyx_v_settings, struct __pyx_obj_7asyncpg_8protocol_8protocol_FastReadBuffer *__pyx_v_buf) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + __Pyx_RefNannySetupContext("poly_decode", 0); + + /* "asyncpg/protocol/codecs/geometry.pyx":149 + * + * cdef poly_decode(ConnectionSettings settings, FastReadBuffer buf): + * return Polygon(*_decode_points(buf)) # <<<<<<<<<<<<<< + * + * + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_GetModuleGlobalName(__pyx_n_s_Polygon); if (unlikely(!__pyx_t_1)) __PYX_ERR(11, 149, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = __pyx_f_7asyncpg_8protocol_8protocol__decode_points(__pyx_v_buf); if (unlikely(!__pyx_t_2)) __PYX_ERR(11, 149, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = PySequence_Tuple(__pyx_t_2); if (unlikely(!__pyx_t_3)) __PYX_ERR(11, 149, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_t_3, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(11, 149, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_r = __pyx_t_2; + __pyx_t_2 = 0; + goto __pyx_L0; + + /* "asyncpg/protocol/codecs/geometry.pyx":148 + * + * + * cdef poly_decode(ConnectionSettings settings, FastReadBuffer buf): # <<<<<<<<<<<<<< + * return Polygon(*_decode_points(buf)) + * + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_AddTraceback("asyncpg.protocol.protocol.poly_decode", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "asyncpg/protocol/codecs/geometry.pyx":152 + * + * + * cdef circle_encode(ConnectionSettings settings, WriteBuffer wbuf, obj): # <<<<<<<<<<<<<< + * wbuf.write_int32(24) + * wbuf.write_double(obj[0][0]) + */ + +static PyObject *__pyx_f_7asyncpg_8protocol_8protocol_circle_encode(CYTHON_UNUSED struct __pyx_obj_7asyncpg_8protocol_8protocol_ConnectionSettings *__pyx_v_settings, struct __pyx_obj_7asyncpg_8protocol_8protocol_WriteBuffer *__pyx_v_wbuf, PyObject *__pyx_v_obj) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + double __pyx_t_3; + __Pyx_RefNannySetupContext("circle_encode", 0); + + /* "asyncpg/protocol/codecs/geometry.pyx":153 + * + * cdef circle_encode(ConnectionSettings settings, WriteBuffer wbuf, obj): + * wbuf.write_int32(24) # <<<<<<<<<<<<<< + * wbuf.write_double(obj[0][0]) + * wbuf.write_double(obj[0][1]) + */ + __pyx_t_1 = __pyx_f_7asyncpg_8protocol_8protocol_11WriteBuffer_write_int32(__pyx_v_wbuf, 24); if (unlikely(!__pyx_t_1)) __PYX_ERR(11, 153, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "asyncpg/protocol/codecs/geometry.pyx":154 + * cdef circle_encode(ConnectionSettings settings, WriteBuffer wbuf, obj): + * wbuf.write_int32(24) + * wbuf.write_double(obj[0][0]) # <<<<<<<<<<<<<< + * wbuf.write_double(obj[0][1]) + * wbuf.write_double(obj[1]) + */ + __pyx_t_1 = __Pyx_GetItemInt(__pyx_v_obj, 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_1)) __PYX_ERR(11, 154, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = __Pyx_GetItemInt(__pyx_t_1, 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_2)) __PYX_ERR(11, 154, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_3 = __pyx_PyFloat_AsDouble(__pyx_t_2); if (unlikely((__pyx_t_3 == (double)-1) && PyErr_Occurred())) __PYX_ERR(11, 154, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_2 = __pyx_f_7asyncpg_8protocol_8protocol_11WriteBuffer_write_double(__pyx_v_wbuf, __pyx_t_3); if (unlikely(!__pyx_t_2)) __PYX_ERR(11, 154, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "asyncpg/protocol/codecs/geometry.pyx":155 + * wbuf.write_int32(24) + * wbuf.write_double(obj[0][0]) + * wbuf.write_double(obj[0][1]) # <<<<<<<<<<<<<< + * wbuf.write_double(obj[1]) + * + */ + __pyx_t_2 = __Pyx_GetItemInt(__pyx_v_obj, 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_2)) __PYX_ERR(11, 155, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_1 = __Pyx_GetItemInt(__pyx_t_2, 1, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_1)) __PYX_ERR(11, 155, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_3 = __pyx_PyFloat_AsDouble(__pyx_t_1); if (unlikely((__pyx_t_3 == (double)-1) && PyErr_Occurred())) __PYX_ERR(11, 155, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_1 = __pyx_f_7asyncpg_8protocol_8protocol_11WriteBuffer_write_double(__pyx_v_wbuf, __pyx_t_3); if (unlikely(!__pyx_t_1)) __PYX_ERR(11, 155, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "asyncpg/protocol/codecs/geometry.pyx":156 + * wbuf.write_double(obj[0][0]) + * wbuf.write_double(obj[0][1]) + * wbuf.write_double(obj[1]) # <<<<<<<<<<<<<< + * + * + */ + __pyx_t_1 = __Pyx_GetItemInt(__pyx_v_obj, 1, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_1)) __PYX_ERR(11, 156, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_3 = __pyx_PyFloat_AsDouble(__pyx_t_1); if (unlikely((__pyx_t_3 == (double)-1) && PyErr_Occurred())) __PYX_ERR(11, 156, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_1 = __pyx_f_7asyncpg_8protocol_8protocol_11WriteBuffer_write_double(__pyx_v_wbuf, __pyx_t_3); if (unlikely(!__pyx_t_1)) __PYX_ERR(11, 156, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "asyncpg/protocol/codecs/geometry.pyx":152 + * + * + * cdef circle_encode(ConnectionSettings settings, WriteBuffer wbuf, obj): # <<<<<<<<<<<<<< + * wbuf.write_int32(24) + * wbuf.write_double(obj[0][0]) + */ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_AddTraceback("asyncpg.protocol.protocol.circle_encode", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "asyncpg/protocol/codecs/geometry.pyx":159 + * + * + * cdef circle_decode(ConnectionSettings settings, FastReadBuffer buf): # <<<<<<<<<<<<<< + * cdef: + * double center_x = hton.unpack_double(buf.read(8)) + */ + +static PyObject *__pyx_f_7asyncpg_8protocol_8protocol_circle_decode(CYTHON_UNUSED struct __pyx_obj_7asyncpg_8protocol_8protocol_ConnectionSettings *__pyx_v_settings, struct __pyx_obj_7asyncpg_8protocol_8protocol_FastReadBuffer *__pyx_v_buf) { + double __pyx_v_center_x; + double __pyx_v_center_y; + double __pyx_v_radius; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + char const *__pyx_t_1; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + PyObject *__pyx_t_5 = NULL; + PyObject *__pyx_t_6 = NULL; + int __pyx_t_7; + PyObject *__pyx_t_8 = NULL; + __Pyx_RefNannySetupContext("circle_decode", 0); + + /* "asyncpg/protocol/codecs/geometry.pyx":161 + * cdef circle_decode(ConnectionSettings settings, FastReadBuffer buf): + * cdef: + * double center_x = hton.unpack_double(buf.read(8)) # <<<<<<<<<<<<<< + * double center_y = hton.unpack_double(buf.read(8)) + * double radius = hton.unpack_double(buf.read(8)) + */ + __pyx_t_1 = __pyx_f_7asyncpg_8protocol_8protocol_14FastReadBuffer_read(__pyx_v_buf, 8); if (unlikely(__pyx_t_1 == NULL)) __PYX_ERR(11, 161, __pyx_L1_error) + __pyx_v_center_x = __pyx_f_7asyncpg_8protocol_4hton_unpack_double(__pyx_t_1); + + /* "asyncpg/protocol/codecs/geometry.pyx":162 + * cdef: + * double center_x = hton.unpack_double(buf.read(8)) + * double center_y = hton.unpack_double(buf.read(8)) # <<<<<<<<<<<<<< + * double radius = hton.unpack_double(buf.read(8)) + * + */ + __pyx_t_1 = __pyx_f_7asyncpg_8protocol_8protocol_14FastReadBuffer_read(__pyx_v_buf, 8); if (unlikely(__pyx_t_1 == NULL)) __PYX_ERR(11, 162, __pyx_L1_error) + __pyx_v_center_y = __pyx_f_7asyncpg_8protocol_4hton_unpack_double(__pyx_t_1); + + /* "asyncpg/protocol/codecs/geometry.pyx":163 + * double center_x = hton.unpack_double(buf.read(8)) + * double center_y = hton.unpack_double(buf.read(8)) + * double radius = hton.unpack_double(buf.read(8)) # <<<<<<<<<<<<<< + * + * return Circle((center_x, center_y), radius) + */ + __pyx_t_1 = __pyx_f_7asyncpg_8protocol_8protocol_14FastReadBuffer_read(__pyx_v_buf, 8); if (unlikely(__pyx_t_1 == NULL)) __PYX_ERR(11, 163, __pyx_L1_error) + __pyx_v_radius = __pyx_f_7asyncpg_8protocol_4hton_unpack_double(__pyx_t_1); + + /* "asyncpg/protocol/codecs/geometry.pyx":165 + * double radius = hton.unpack_double(buf.read(8)) + * + * return Circle((center_x, center_y), radius) # <<<<<<<<<<<<<< + * + * + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_3 = __Pyx_GetModuleGlobalName(__pyx_n_s_Circle); if (unlikely(!__pyx_t_3)) __PYX_ERR(11, 165, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = PyFloat_FromDouble(__pyx_v_center_x); if (unlikely(!__pyx_t_4)) __PYX_ERR(11, 165, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_5 = PyFloat_FromDouble(__pyx_v_center_y); if (unlikely(!__pyx_t_5)) __PYX_ERR(11, 165, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_6 = PyTuple_New(2); if (unlikely(!__pyx_t_6)) __PYX_ERR(11, 165, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_GIVEREF(__pyx_t_4); + PyTuple_SET_ITEM(__pyx_t_6, 0, __pyx_t_4); + __Pyx_GIVEREF(__pyx_t_5); + PyTuple_SET_ITEM(__pyx_t_6, 1, __pyx_t_5); + __pyx_t_4 = 0; + __pyx_t_5 = 0; + __pyx_t_5 = PyFloat_FromDouble(__pyx_v_radius); if (unlikely(!__pyx_t_5)) __PYX_ERR(11, 165, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_4 = NULL; + __pyx_t_7 = 0; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_3))) { + __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_3); + if (likely(__pyx_t_4)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); + __Pyx_INCREF(__pyx_t_4); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_3, function); + __pyx_t_7 = 1; + } + } + #if CYTHON_FAST_PYCALL + if (PyFunction_Check(__pyx_t_3)) { + PyObject *__pyx_temp[3] = {__pyx_t_4, __pyx_t_6, __pyx_t_5}; + __pyx_t_2 = __Pyx_PyFunction_FastCall(__pyx_t_3, __pyx_temp+1-__pyx_t_7, 2+__pyx_t_7); if (unlikely(!__pyx_t_2)) __PYX_ERR(11, 165, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + } else + #endif + #if CYTHON_FAST_PYCCALL + if (__Pyx_PyFastCFunction_Check(__pyx_t_3)) { + PyObject *__pyx_temp[3] = {__pyx_t_4, __pyx_t_6, __pyx_t_5}; + __pyx_t_2 = __Pyx_PyCFunction_FastCall(__pyx_t_3, __pyx_temp+1-__pyx_t_7, 2+__pyx_t_7); if (unlikely(!__pyx_t_2)) __PYX_ERR(11, 165, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + } else + #endif + { + __pyx_t_8 = PyTuple_New(2+__pyx_t_7); if (unlikely(!__pyx_t_8)) __PYX_ERR(11, 165, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + if (__pyx_t_4) { + __Pyx_GIVEREF(__pyx_t_4); PyTuple_SET_ITEM(__pyx_t_8, 0, __pyx_t_4); __pyx_t_4 = NULL; + } + __Pyx_GIVEREF(__pyx_t_6); + PyTuple_SET_ITEM(__pyx_t_8, 0+__pyx_t_7, __pyx_t_6); + __Pyx_GIVEREF(__pyx_t_5); + PyTuple_SET_ITEM(__pyx_t_8, 1+__pyx_t_7, __pyx_t_5); + __pyx_t_6 = 0; + __pyx_t_5 = 0; + __pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_t_8, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(11, 165, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + } + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_r = __pyx_t_2; + __pyx_t_2 = 0; + goto __pyx_L0; + + /* "asyncpg/protocol/codecs/geometry.pyx":159 + * + * + * cdef circle_decode(ConnectionSettings settings, FastReadBuffer buf): # <<<<<<<<<<<<<< + * cdef: + * double center_x = hton.unpack_double(buf.read(8)) + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_XDECREF(__pyx_t_6); + __Pyx_XDECREF(__pyx_t_8); + __Pyx_AddTraceback("asyncpg.protocol.protocol.circle_decode", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "asyncpg/protocol/codecs/geometry.pyx":168 + * + * + * cdef init_geometry_codecs(): # <<<<<<<<<<<<<< + * register_core_codec(BOXOID, + * &box_encode, + */ + +static PyObject *__pyx_f_7asyncpg_8protocol_8protocol_init_geometry_codecs(void) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + __Pyx_RefNannySetupContext("init_geometry_codecs", 0); + + /* "asyncpg/protocol/codecs/geometry.pyx":169 + * + * cdef init_geometry_codecs(): + * register_core_codec(BOXOID, # <<<<<<<<<<<<<< + * &box_encode, + * &box_decode, + */ + __pyx_t_1 = __pyx_f_7asyncpg_8protocol_8protocol_register_core_codec(0x25B, ((__pyx_t_7asyncpg_8protocol_8protocol_encode_func)(&__pyx_f_7asyncpg_8protocol_8protocol_box_encode)), ((__pyx_t_7asyncpg_8protocol_8protocol_decode_func)(&__pyx_f_7asyncpg_8protocol_8protocol_box_decode)), __pyx_e_7asyncpg_8protocol_8protocol_PG_FORMAT_BINARY); if (unlikely(!__pyx_t_1)) __PYX_ERR(11, 169, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "asyncpg/protocol/codecs/geometry.pyx":174 + * PG_FORMAT_BINARY) + * + * register_core_codec(LINEOID, # <<<<<<<<<<<<<< + * &line_encode, + * &line_decode, + */ + __pyx_t_1 = __pyx_f_7asyncpg_8protocol_8protocol_register_core_codec(0x274, ((__pyx_t_7asyncpg_8protocol_8protocol_encode_func)(&__pyx_f_7asyncpg_8protocol_8protocol_line_encode)), ((__pyx_t_7asyncpg_8protocol_8protocol_decode_func)(&__pyx_f_7asyncpg_8protocol_8protocol_line_decode)), __pyx_e_7asyncpg_8protocol_8protocol_PG_FORMAT_BINARY); if (unlikely(!__pyx_t_1)) __PYX_ERR(11, 174, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "asyncpg/protocol/codecs/geometry.pyx":179 + * PG_FORMAT_BINARY) + * + * register_core_codec(LSEGOID, # <<<<<<<<<<<<<< + * &lseg_encode, + * &lseg_decode, + */ + __pyx_t_1 = __pyx_f_7asyncpg_8protocol_8protocol_register_core_codec(0x259, ((__pyx_t_7asyncpg_8protocol_8protocol_encode_func)(&__pyx_f_7asyncpg_8protocol_8protocol_lseg_encode)), ((__pyx_t_7asyncpg_8protocol_8protocol_decode_func)(&__pyx_f_7asyncpg_8protocol_8protocol_lseg_decode)), __pyx_e_7asyncpg_8protocol_8protocol_PG_FORMAT_BINARY); if (unlikely(!__pyx_t_1)) __PYX_ERR(11, 179, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "asyncpg/protocol/codecs/geometry.pyx":184 + * PG_FORMAT_BINARY) + * + * register_core_codec(POINTOID, # <<<<<<<<<<<<<< + * &point_encode, + * &point_decode, + */ + __pyx_t_1 = __pyx_f_7asyncpg_8protocol_8protocol_register_core_codec(0x258, ((__pyx_t_7asyncpg_8protocol_8protocol_encode_func)(&__pyx_f_7asyncpg_8protocol_8protocol_point_encode)), ((__pyx_t_7asyncpg_8protocol_8protocol_decode_func)(&__pyx_f_7asyncpg_8protocol_8protocol_point_decode)), __pyx_e_7asyncpg_8protocol_8protocol_PG_FORMAT_BINARY); if (unlikely(!__pyx_t_1)) __PYX_ERR(11, 184, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "asyncpg/protocol/codecs/geometry.pyx":189 + * PG_FORMAT_BINARY) + * + * register_core_codec(PATHOID, # <<<<<<<<<<<<<< + * &path_encode, + * &path_decode, + */ + __pyx_t_1 = __pyx_f_7asyncpg_8protocol_8protocol_register_core_codec(0x25A, ((__pyx_t_7asyncpg_8protocol_8protocol_encode_func)(&__pyx_f_7asyncpg_8protocol_8protocol_path_encode)), ((__pyx_t_7asyncpg_8protocol_8protocol_decode_func)(&__pyx_f_7asyncpg_8protocol_8protocol_path_decode)), __pyx_e_7asyncpg_8protocol_8protocol_PG_FORMAT_BINARY); if (unlikely(!__pyx_t_1)) __PYX_ERR(11, 189, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "asyncpg/protocol/codecs/geometry.pyx":194 + * PG_FORMAT_BINARY) + * + * register_core_codec(POLYGONOID, # <<<<<<<<<<<<<< + * &poly_encode, + * &poly_decode, + */ + __pyx_t_1 = __pyx_f_7asyncpg_8protocol_8protocol_register_core_codec(0x25C, ((__pyx_t_7asyncpg_8protocol_8protocol_encode_func)(&__pyx_f_7asyncpg_8protocol_8protocol_poly_encode)), ((__pyx_t_7asyncpg_8protocol_8protocol_decode_func)(&__pyx_f_7asyncpg_8protocol_8protocol_poly_decode)), __pyx_e_7asyncpg_8protocol_8protocol_PG_FORMAT_BINARY); if (unlikely(!__pyx_t_1)) __PYX_ERR(11, 194, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "asyncpg/protocol/codecs/geometry.pyx":199 + * PG_FORMAT_BINARY) + * + * register_core_codec(CIRCLEOID, # <<<<<<<<<<<<<< + * &circle_encode, + * &circle_decode, + */ + __pyx_t_1 = __pyx_f_7asyncpg_8protocol_8protocol_register_core_codec(0x2CE, ((__pyx_t_7asyncpg_8protocol_8protocol_encode_func)(&__pyx_f_7asyncpg_8protocol_8protocol_circle_encode)), ((__pyx_t_7asyncpg_8protocol_8protocol_decode_func)(&__pyx_f_7asyncpg_8protocol_8protocol_circle_decode)), __pyx_e_7asyncpg_8protocol_8protocol_PG_FORMAT_BINARY); if (unlikely(!__pyx_t_1)) __PYX_ERR(11, 199, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "asyncpg/protocol/codecs/geometry.pyx":168 + * + * + * cdef init_geometry_codecs(): # <<<<<<<<<<<<<< + * register_core_codec(BOXOID, + * &box_encode, + */ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("asyncpg.protocol.protocol.init_geometry_codecs", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "asyncpg/protocol/codecs/int.pyx":8 + * + * + * cdef bool_encode(ConnectionSettings settings, WriteBuffer buf, obj): # <<<<<<<<<<<<<< + * if not cpython.PyBool_Check(obj): + * raise TypeError('a boolean is required (got type {})'.format( + */ + +static PyObject *__pyx_f_7asyncpg_8protocol_8protocol_bool_encode(CYTHON_UNUSED struct __pyx_obj_7asyncpg_8protocol_8protocol_ConnectionSettings *__pyx_v_settings, struct __pyx_obj_7asyncpg_8protocol_8protocol_WriteBuffer *__pyx_v_buf, PyObject *__pyx_v_obj) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + PyObject *__pyx_t_5 = NULL; + PyObject *__pyx_t_6 = NULL; + char __pyx_t_7; + __Pyx_RefNannySetupContext("bool_encode", 0); + + /* "asyncpg/protocol/codecs/int.pyx":9 + * + * cdef bool_encode(ConnectionSettings settings, WriteBuffer buf, obj): + * if not cpython.PyBool_Check(obj): # <<<<<<<<<<<<<< + * raise TypeError('a boolean is required (got type {})'.format( + * type(obj).__name__)) + */ + __pyx_t_1 = ((!(PyBool_Check(__pyx_v_obj) != 0)) != 0); + if (__pyx_t_1) { + + /* "asyncpg/protocol/codecs/int.pyx":10 + * cdef bool_encode(ConnectionSettings settings, WriteBuffer buf, obj): + * if not cpython.PyBool_Check(obj): + * raise TypeError('a boolean is required (got type {})'.format( # <<<<<<<<<<<<<< + * type(obj).__name__)) + * + */ + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_kp_u_a_boolean_is_required_got_type, __pyx_n_s_format); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 10, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + + /* "asyncpg/protocol/codecs/int.pyx":11 + * if not cpython.PyBool_Check(obj): + * raise TypeError('a boolean is required (got type {})'.format( + * type(obj).__name__)) # <<<<<<<<<<<<<< + * + * buf.write_int32(1) + */ + __pyx_t_4 = __Pyx_PyObject_GetAttrStr(((PyObject *)Py_TYPE(__pyx_v_obj)), __pyx_n_s_name_2); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 11, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_5 = NULL; + if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_3))) { + __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_3); + if (likely(__pyx_t_5)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); + __Pyx_INCREF(__pyx_t_5); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_3, function); + } + } + if (!__pyx_t_5) { + __pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_4); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 10, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_GOTREF(__pyx_t_2); + } else { + #if CYTHON_FAST_PYCALL + if (PyFunction_Check(__pyx_t_3)) { + PyObject *__pyx_temp[2] = {__pyx_t_5, __pyx_t_4}; + __pyx_t_2 = __Pyx_PyFunction_FastCall(__pyx_t_3, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 10, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + } else + #endif + #if CYTHON_FAST_PYCCALL + if (__Pyx_PyFastCFunction_Check(__pyx_t_3)) { + PyObject *__pyx_temp[2] = {__pyx_t_5, __pyx_t_4}; + __pyx_t_2 = __Pyx_PyCFunction_FastCall(__pyx_t_3, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 10, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + } else + #endif + { + __pyx_t_6 = PyTuple_New(1+1); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 10, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_GIVEREF(__pyx_t_5); PyTuple_SET_ITEM(__pyx_t_6, 0, __pyx_t_5); __pyx_t_5 = NULL; + __Pyx_GIVEREF(__pyx_t_4); + PyTuple_SET_ITEM(__pyx_t_6, 0+1, __pyx_t_4); + __pyx_t_4 = 0; + __pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_t_6, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 10, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + } + } + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + + /* "asyncpg/protocol/codecs/int.pyx":10 + * cdef bool_encode(ConnectionSettings settings, WriteBuffer buf, obj): + * if not cpython.PyBool_Check(obj): + * raise TypeError('a boolean is required (got type {})'.format( # <<<<<<<<<<<<<< + * type(obj).__name__)) + * + */ + __pyx_t_3 = PyTuple_New(1); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 10, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_GIVEREF(__pyx_t_2); + PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_t_2); + __pyx_t_2 = 0; + __pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_t_3, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 10, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_Raise(__pyx_t_2, 0, 0, 0); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __PYX_ERR(3, 10, __pyx_L1_error) + + /* "asyncpg/protocol/codecs/int.pyx":9 + * + * cdef bool_encode(ConnectionSettings settings, WriteBuffer buf, obj): + * if not cpython.PyBool_Check(obj): # <<<<<<<<<<<<<< + * raise TypeError('a boolean is required (got type {})'.format( + * type(obj).__name__)) + */ + } + + /* "asyncpg/protocol/codecs/int.pyx":13 + * type(obj).__name__)) + * + * buf.write_int32(1) # <<<<<<<<<<<<<< + * buf.write_byte(b'\x01' if obj is True else b'\x00') + * + */ + __pyx_t_2 = __pyx_f_7asyncpg_8protocol_8protocol_11WriteBuffer_write_int32(__pyx_v_buf, 1); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 13, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "asyncpg/protocol/codecs/int.pyx":14 + * + * buf.write_int32(1) + * buf.write_byte(b'\x01' if obj is True else b'\x00') # <<<<<<<<<<<<<< + * + * + */ + __pyx_t_1 = (__pyx_v_obj == Py_True); + if ((__pyx_t_1 != 0)) { + __pyx_t_7 = '\x01'; + } else { + __pyx_t_7 = '\x00'; + } + __pyx_t_2 = __pyx_f_7asyncpg_8protocol_8protocol_11WriteBuffer_write_byte(__pyx_v_buf, __pyx_t_7); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 14, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "asyncpg/protocol/codecs/int.pyx":8 + * + * + * cdef bool_encode(ConnectionSettings settings, WriteBuffer buf, obj): # <<<<<<<<<<<<<< + * if not cpython.PyBool_Check(obj): + * raise TypeError('a boolean is required (got type {})'.format( + */ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_XDECREF(__pyx_t_6); + __Pyx_AddTraceback("asyncpg.protocol.protocol.bool_encode", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "asyncpg/protocol/codecs/int.pyx":17 + * + * + * cdef bool_decode(ConnectionSettings settings, FastReadBuffer buf): # <<<<<<<<<<<<<< + * return buf.read(1)[0] is b'\x01' + * + */ + +static PyObject *__pyx_f_7asyncpg_8protocol_8protocol_bool_decode(CYTHON_UNUSED struct __pyx_obj_7asyncpg_8protocol_8protocol_ConnectionSettings *__pyx_v_settings, struct __pyx_obj_7asyncpg_8protocol_8protocol_FastReadBuffer *__pyx_v_buf) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + char const *__pyx_t_1; + PyObject *__pyx_t_2 = NULL; + __Pyx_RefNannySetupContext("bool_decode", 0); + + /* "asyncpg/protocol/codecs/int.pyx":18 + * + * cdef bool_decode(ConnectionSettings settings, FastReadBuffer buf): + * return buf.read(1)[0] is b'\x01' # <<<<<<<<<<<<<< + * + * + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __pyx_f_7asyncpg_8protocol_8protocol_14FastReadBuffer_read(__pyx_v_buf, 1); if (unlikely(__pyx_t_1 == NULL)) __PYX_ERR(3, 18, __pyx_L1_error) + __pyx_t_2 = __Pyx_PyBool_FromLong(((__pyx_t_1[0]) == '\x01')); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 18, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_r = __pyx_t_2; + __pyx_t_2 = 0; + goto __pyx_L0; + + /* "asyncpg/protocol/codecs/int.pyx":17 + * + * + * cdef bool_decode(ConnectionSettings settings, FastReadBuffer buf): # <<<<<<<<<<<<<< + * return buf.read(1)[0] is b'\x01' + * + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_2); + __Pyx_AddTraceback("asyncpg.protocol.protocol.bool_decode", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "asyncpg/protocol/codecs/int.pyx":21 + * + * + * cdef int2_encode(ConnectionSettings settings, WriteBuffer buf, obj): # <<<<<<<<<<<<<< + * cdef long val = cpython.PyLong_AsLong(obj) + * if val < -32767 or val > 32767: + */ + +static PyObject *__pyx_f_7asyncpg_8protocol_8protocol_int2_encode(CYTHON_UNUSED struct __pyx_obj_7asyncpg_8protocol_8protocol_ConnectionSettings *__pyx_v_settings, struct __pyx_obj_7asyncpg_8protocol_8protocol_WriteBuffer *__pyx_v_buf, PyObject *__pyx_v_obj) { + long __pyx_v_val; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + long __pyx_t_1; + int __pyx_t_2; + int __pyx_t_3; + PyObject *__pyx_t_4 = NULL; + PyObject *__pyx_t_5 = NULL; + PyObject *__pyx_t_6 = NULL; + PyObject *__pyx_t_7 = NULL; + PyObject *__pyx_t_8 = NULL; + __Pyx_RefNannySetupContext("int2_encode", 0); + + /* "asyncpg/protocol/codecs/int.pyx":22 + * + * cdef int2_encode(ConnectionSettings settings, WriteBuffer buf, obj): + * cdef long val = cpython.PyLong_AsLong(obj) # <<<<<<<<<<<<<< + * if val < -32767 or val > 32767: + * raise ValueError( + */ + __pyx_t_1 = PyLong_AsLong(__pyx_v_obj); if (unlikely(__pyx_t_1 == -1L && PyErr_Occurred())) __PYX_ERR(3, 22, __pyx_L1_error) + __pyx_v_val = __pyx_t_1; + + /* "asyncpg/protocol/codecs/int.pyx":23 + * cdef int2_encode(ConnectionSettings settings, WriteBuffer buf, obj): + * cdef long val = cpython.PyLong_AsLong(obj) + * if val < -32767 or val > 32767: # <<<<<<<<<<<<<< + * raise ValueError( + * 'integer too large to be encoded as INT2: {!r}'.format(val)) + */ + __pyx_t_3 = ((__pyx_v_val < -32767L) != 0); + if (!__pyx_t_3) { + } else { + __pyx_t_2 = __pyx_t_3; + goto __pyx_L4_bool_binop_done; + } + __pyx_t_3 = ((__pyx_v_val > 0x7FFF) != 0); + __pyx_t_2 = __pyx_t_3; + __pyx_L4_bool_binop_done:; + if (__pyx_t_2) { + + /* "asyncpg/protocol/codecs/int.pyx":25 + * if val < -32767 or val > 32767: + * raise ValueError( + * 'integer too large to be encoded as INT2: {!r}'.format(val)) # <<<<<<<<<<<<<< + * + * buf.write_int32(2) + */ + __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_kp_u_integer_too_large_to_be_encoded, __pyx_n_s_format); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 25, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_6 = __Pyx_PyInt_From_long(__pyx_v_val); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 25, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_7 = NULL; + if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_5))) { + __pyx_t_7 = PyMethod_GET_SELF(__pyx_t_5); + if (likely(__pyx_t_7)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_5); + __Pyx_INCREF(__pyx_t_7); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_5, function); + } + } + if (!__pyx_t_7) { + __pyx_t_4 = __Pyx_PyObject_CallOneArg(__pyx_t_5, __pyx_t_6); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 25, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_GOTREF(__pyx_t_4); + } else { + #if CYTHON_FAST_PYCALL + if (PyFunction_Check(__pyx_t_5)) { + PyObject *__pyx_temp[2] = {__pyx_t_7, __pyx_t_6}; + __pyx_t_4 = __Pyx_PyFunction_FastCall(__pyx_t_5, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 25, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + } else + #endif + #if CYTHON_FAST_PYCCALL + if (__Pyx_PyFastCFunction_Check(__pyx_t_5)) { + PyObject *__pyx_temp[2] = {__pyx_t_7, __pyx_t_6}; + __pyx_t_4 = __Pyx_PyCFunction_FastCall(__pyx_t_5, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 25, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + } else + #endif + { + __pyx_t_8 = PyTuple_New(1+1); if (unlikely(!__pyx_t_8)) __PYX_ERR(3, 25, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __Pyx_GIVEREF(__pyx_t_7); PyTuple_SET_ITEM(__pyx_t_8, 0, __pyx_t_7); __pyx_t_7 = NULL; + __Pyx_GIVEREF(__pyx_t_6); + PyTuple_SET_ITEM(__pyx_t_8, 0+1, __pyx_t_6); + __pyx_t_6 = 0; + __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_5, __pyx_t_8, NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 25, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + } + } + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + + /* "asyncpg/protocol/codecs/int.pyx":24 + * cdef long val = cpython.PyLong_AsLong(obj) + * if val < -32767 or val > 32767: + * raise ValueError( # <<<<<<<<<<<<<< + * 'integer too large to be encoded as INT2: {!r}'.format(val)) + * + */ + __pyx_t_5 = PyTuple_New(1); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 24, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_GIVEREF(__pyx_t_4); + PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_t_4); + __pyx_t_4 = 0; + __pyx_t_4 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_t_5, NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 24, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_Raise(__pyx_t_4, 0, 0, 0); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __PYX_ERR(3, 24, __pyx_L1_error) + + /* "asyncpg/protocol/codecs/int.pyx":23 + * cdef int2_encode(ConnectionSettings settings, WriteBuffer buf, obj): + * cdef long val = cpython.PyLong_AsLong(obj) + * if val < -32767 or val > 32767: # <<<<<<<<<<<<<< + * raise ValueError( + * 'integer too large to be encoded as INT2: {!r}'.format(val)) + */ + } + + /* "asyncpg/protocol/codecs/int.pyx":27 + * 'integer too large to be encoded as INT2: {!r}'.format(val)) + * + * buf.write_int32(2) # <<<<<<<<<<<<<< + * buf.write_int16(val) + * + */ + __pyx_t_4 = __pyx_f_7asyncpg_8protocol_8protocol_11WriteBuffer_write_int32(__pyx_v_buf, 2); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 27, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + + /* "asyncpg/protocol/codecs/int.pyx":28 + * + * buf.write_int32(2) + * buf.write_int16(val) # <<<<<<<<<<<<<< + * + * + */ + __pyx_t_4 = __pyx_f_7asyncpg_8protocol_8protocol_11WriteBuffer_write_int16(__pyx_v_buf, ((int16_t)__pyx_v_val)); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 28, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + + /* "asyncpg/protocol/codecs/int.pyx":21 + * + * + * cdef int2_encode(ConnectionSettings settings, WriteBuffer buf, obj): # <<<<<<<<<<<<<< + * cdef long val = cpython.PyLong_AsLong(obj) + * if val < -32767 or val > 32767: + */ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_4); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_XDECREF(__pyx_t_6); + __Pyx_XDECREF(__pyx_t_7); + __Pyx_XDECREF(__pyx_t_8); + __Pyx_AddTraceback("asyncpg.protocol.protocol.int2_encode", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "asyncpg/protocol/codecs/int.pyx":31 + * + * + * cdef int2_decode(ConnectionSettings settings, FastReadBuffer buf): # <<<<<<<<<<<<<< + * return cpython.PyLong_FromLong(hton.unpack_int16(buf.read(2))) + * + */ + +static PyObject *__pyx_f_7asyncpg_8protocol_8protocol_int2_decode(CYTHON_UNUSED struct __pyx_obj_7asyncpg_8protocol_8protocol_ConnectionSettings *__pyx_v_settings, struct __pyx_obj_7asyncpg_8protocol_8protocol_FastReadBuffer *__pyx_v_buf) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + char const *__pyx_t_1; + PyObject *__pyx_t_2 = NULL; + __Pyx_RefNannySetupContext("int2_decode", 0); + + /* "asyncpg/protocol/codecs/int.pyx":32 + * + * cdef int2_decode(ConnectionSettings settings, FastReadBuffer buf): + * return cpython.PyLong_FromLong(hton.unpack_int16(buf.read(2))) # <<<<<<<<<<<<<< + * + * + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __pyx_f_7asyncpg_8protocol_8protocol_14FastReadBuffer_read(__pyx_v_buf, 2); if (unlikely(__pyx_t_1 == NULL)) __PYX_ERR(3, 32, __pyx_L1_error) + __pyx_t_2 = PyLong_FromLong(__pyx_f_7asyncpg_8protocol_4hton_unpack_int16(__pyx_t_1)); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 32, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_r = __pyx_t_2; + __pyx_t_2 = 0; + goto __pyx_L0; + + /* "asyncpg/protocol/codecs/int.pyx":31 + * + * + * cdef int2_decode(ConnectionSettings settings, FastReadBuffer buf): # <<<<<<<<<<<<<< + * return cpython.PyLong_FromLong(hton.unpack_int16(buf.read(2))) + * + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_2); + __Pyx_AddTraceback("asyncpg.protocol.protocol.int2_decode", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "asyncpg/protocol/codecs/int.pyx":35 + * + * + * cdef int4_encode(ConnectionSettings settings, WriteBuffer buf, obj): # <<<<<<<<<<<<<< + * cdef int32_t val = cpython.PyLong_AsLong(obj) + * + */ + +static PyObject *__pyx_f_7asyncpg_8protocol_8protocol_int4_encode(CYTHON_UNUSED struct __pyx_obj_7asyncpg_8protocol_8protocol_ConnectionSettings *__pyx_v_settings, struct __pyx_obj_7asyncpg_8protocol_8protocol_WriteBuffer *__pyx_v_buf, PyObject *__pyx_v_obj) { + int32_t __pyx_v_val; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + long __pyx_t_1; + PyObject *__pyx_t_2 = NULL; + __Pyx_RefNannySetupContext("int4_encode", 0); + + /* "asyncpg/protocol/codecs/int.pyx":36 + * + * cdef int4_encode(ConnectionSettings settings, WriteBuffer buf, obj): + * cdef int32_t val = cpython.PyLong_AsLong(obj) # <<<<<<<<<<<<<< + * + * buf.write_int32(4) + */ + __pyx_t_1 = PyLong_AsLong(__pyx_v_obj); if (unlikely(__pyx_t_1 == -1L && PyErr_Occurred())) __PYX_ERR(3, 36, __pyx_L1_error) + __pyx_v_val = ((int32_t)__pyx_t_1); + + /* "asyncpg/protocol/codecs/int.pyx":38 + * cdef int32_t val = cpython.PyLong_AsLong(obj) + * + * buf.write_int32(4) # <<<<<<<<<<<<<< + * buf.write_int32(val) + * + */ + __pyx_t_2 = __pyx_f_7asyncpg_8protocol_8protocol_11WriteBuffer_write_int32(__pyx_v_buf, 4); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 38, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "asyncpg/protocol/codecs/int.pyx":39 + * + * buf.write_int32(4) + * buf.write_int32(val) # <<<<<<<<<<<<<< + * + * + */ + __pyx_t_2 = __pyx_f_7asyncpg_8protocol_8protocol_11WriteBuffer_write_int32(__pyx_v_buf, __pyx_v_val); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 39, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "asyncpg/protocol/codecs/int.pyx":35 + * + * + * cdef int4_encode(ConnectionSettings settings, WriteBuffer buf, obj): # <<<<<<<<<<<<<< + * cdef int32_t val = cpython.PyLong_AsLong(obj) + * + */ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_2); + __Pyx_AddTraceback("asyncpg.protocol.protocol.int4_encode", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "asyncpg/protocol/codecs/int.pyx":42 + * + * + * cdef int4_decode(ConnectionSettings settings, FastReadBuffer buf): # <<<<<<<<<<<<<< + * return cpython.PyLong_FromLong(hton.unpack_int32(buf.read(4))) + * + */ + +static PyObject *__pyx_f_7asyncpg_8protocol_8protocol_int4_decode(CYTHON_UNUSED struct __pyx_obj_7asyncpg_8protocol_8protocol_ConnectionSettings *__pyx_v_settings, struct __pyx_obj_7asyncpg_8protocol_8protocol_FastReadBuffer *__pyx_v_buf) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + char const *__pyx_t_1; + PyObject *__pyx_t_2 = NULL; + __Pyx_RefNannySetupContext("int4_decode", 0); + + /* "asyncpg/protocol/codecs/int.pyx":43 + * + * cdef int4_decode(ConnectionSettings settings, FastReadBuffer buf): + * return cpython.PyLong_FromLong(hton.unpack_int32(buf.read(4))) # <<<<<<<<<<<<<< + * + * + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __pyx_f_7asyncpg_8protocol_8protocol_14FastReadBuffer_read(__pyx_v_buf, 4); if (unlikely(__pyx_t_1 == NULL)) __PYX_ERR(3, 43, __pyx_L1_error) + __pyx_t_2 = PyLong_FromLong(__pyx_f_7asyncpg_8protocol_4hton_unpack_int32(__pyx_t_1)); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 43, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_r = __pyx_t_2; + __pyx_t_2 = 0; + goto __pyx_L0; + + /* "asyncpg/protocol/codecs/int.pyx":42 + * + * + * cdef int4_decode(ConnectionSettings settings, FastReadBuffer buf): # <<<<<<<<<<<<<< + * return cpython.PyLong_FromLong(hton.unpack_int32(buf.read(4))) + * + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_2); + __Pyx_AddTraceback("asyncpg.protocol.protocol.int4_decode", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "asyncpg/protocol/codecs/int.pyx":46 + * + * + * cdef int8_encode(ConnectionSettings settings, WriteBuffer buf, obj): # <<<<<<<<<<<<<< + * cdef int64_t val = cpython.PyLong_AsLongLong(obj) + * buf.write_int32(8) + */ + +static PyObject *__pyx_f_7asyncpg_8protocol_8protocol_int8_encode(CYTHON_UNUSED struct __pyx_obj_7asyncpg_8protocol_8protocol_ConnectionSettings *__pyx_v_settings, struct __pyx_obj_7asyncpg_8protocol_8protocol_WriteBuffer *__pyx_v_buf, PyObject *__pyx_v_obj) { + int64_t __pyx_v_val; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PY_LONG_LONG __pyx_t_1; + PyObject *__pyx_t_2 = NULL; + __Pyx_RefNannySetupContext("int8_encode", 0); + + /* "asyncpg/protocol/codecs/int.pyx":47 + * + * cdef int8_encode(ConnectionSettings settings, WriteBuffer buf, obj): + * cdef int64_t val = cpython.PyLong_AsLongLong(obj) # <<<<<<<<<<<<<< + * buf.write_int32(8) + * buf.write_int64(val) + */ + __pyx_t_1 = PyLong_AsLongLong(__pyx_v_obj); if (unlikely(__pyx_t_1 == -1LL && PyErr_Occurred())) __PYX_ERR(3, 47, __pyx_L1_error) + __pyx_v_val = __pyx_t_1; + + /* "asyncpg/protocol/codecs/int.pyx":48 + * cdef int8_encode(ConnectionSettings settings, WriteBuffer buf, obj): + * cdef int64_t val = cpython.PyLong_AsLongLong(obj) + * buf.write_int32(8) # <<<<<<<<<<<<<< + * buf.write_int64(val) + * + */ + __pyx_t_2 = __pyx_f_7asyncpg_8protocol_8protocol_11WriteBuffer_write_int32(__pyx_v_buf, 8); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 48, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "asyncpg/protocol/codecs/int.pyx":49 + * cdef int64_t val = cpython.PyLong_AsLongLong(obj) + * buf.write_int32(8) + * buf.write_int64(val) # <<<<<<<<<<<<<< + * + * + */ + __pyx_t_2 = __pyx_f_7asyncpg_8protocol_8protocol_11WriteBuffer_write_int64(__pyx_v_buf, __pyx_v_val); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 49, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "asyncpg/protocol/codecs/int.pyx":46 + * + * + * cdef int8_encode(ConnectionSettings settings, WriteBuffer buf, obj): # <<<<<<<<<<<<<< + * cdef int64_t val = cpython.PyLong_AsLongLong(obj) + * buf.write_int32(8) + */ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_2); + __Pyx_AddTraceback("asyncpg.protocol.protocol.int8_encode", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "asyncpg/protocol/codecs/int.pyx":52 + * + * + * cdef int8_decode(ConnectionSettings settings, FastReadBuffer buf): # <<<<<<<<<<<<<< + * return cpython.PyLong_FromLongLong(hton.unpack_int64(buf.read(8))) + * + */ + +static PyObject *__pyx_f_7asyncpg_8protocol_8protocol_int8_decode(CYTHON_UNUSED struct __pyx_obj_7asyncpg_8protocol_8protocol_ConnectionSettings *__pyx_v_settings, struct __pyx_obj_7asyncpg_8protocol_8protocol_FastReadBuffer *__pyx_v_buf) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + char const *__pyx_t_1; + PyObject *__pyx_t_2 = NULL; + __Pyx_RefNannySetupContext("int8_decode", 0); + + /* "asyncpg/protocol/codecs/int.pyx":53 + * + * cdef int8_decode(ConnectionSettings settings, FastReadBuffer buf): + * return cpython.PyLong_FromLongLong(hton.unpack_int64(buf.read(8))) # <<<<<<<<<<<<<< + * + * + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __pyx_f_7asyncpg_8protocol_8protocol_14FastReadBuffer_read(__pyx_v_buf, 8); if (unlikely(__pyx_t_1 == NULL)) __PYX_ERR(3, 53, __pyx_L1_error) + __pyx_t_2 = PyLong_FromLongLong(__pyx_f_7asyncpg_8protocol_4hton_unpack_int64(__pyx_t_1)); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 53, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_r = __pyx_t_2; + __pyx_t_2 = 0; + goto __pyx_L0; + + /* "asyncpg/protocol/codecs/int.pyx":52 + * + * + * cdef int8_decode(ConnectionSettings settings, FastReadBuffer buf): # <<<<<<<<<<<<<< + * return cpython.PyLong_FromLongLong(hton.unpack_int64(buf.read(8))) + * + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_2); + __Pyx_AddTraceback("asyncpg.protocol.protocol.int8_decode", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "asyncpg/protocol/codecs/int.pyx":56 + * + * + * cdef init_int_codecs(): # <<<<<<<<<<<<<< + * + * register_core_codec(BOOLOID, + */ + +static PyObject *__pyx_f_7asyncpg_8protocol_8protocol_init_int_codecs(void) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + __Pyx_RefNannySetupContext("init_int_codecs", 0); + + /* "asyncpg/protocol/codecs/int.pyx":58 + * cdef init_int_codecs(): + * + * register_core_codec(BOOLOID, # <<<<<<<<<<<<<< + * &bool_encode, + * &bool_decode, + */ + __pyx_t_1 = __pyx_f_7asyncpg_8protocol_8protocol_register_core_codec(16, ((__pyx_t_7asyncpg_8protocol_8protocol_encode_func)(&__pyx_f_7asyncpg_8protocol_8protocol_bool_encode)), ((__pyx_t_7asyncpg_8protocol_8protocol_decode_func)(&__pyx_f_7asyncpg_8protocol_8protocol_bool_decode)), __pyx_e_7asyncpg_8protocol_8protocol_PG_FORMAT_BINARY); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 58, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "asyncpg/protocol/codecs/int.pyx":63 + * PG_FORMAT_BINARY) + * + * register_core_codec(INT2OID, # <<<<<<<<<<<<<< + * &int2_encode, + * &int2_decode, + */ + __pyx_t_1 = __pyx_f_7asyncpg_8protocol_8protocol_register_core_codec(21, ((__pyx_t_7asyncpg_8protocol_8protocol_encode_func)(&__pyx_f_7asyncpg_8protocol_8protocol_int2_encode)), ((__pyx_t_7asyncpg_8protocol_8protocol_decode_func)(&__pyx_f_7asyncpg_8protocol_8protocol_int2_decode)), __pyx_e_7asyncpg_8protocol_8protocol_PG_FORMAT_BINARY); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 63, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "asyncpg/protocol/codecs/int.pyx":68 + * PG_FORMAT_BINARY) + * + * register_core_codec(INT4OID, # <<<<<<<<<<<<<< + * &int4_encode, + * &int4_decode, + */ + __pyx_t_1 = __pyx_f_7asyncpg_8protocol_8protocol_register_core_codec(23, ((__pyx_t_7asyncpg_8protocol_8protocol_encode_func)(&__pyx_f_7asyncpg_8protocol_8protocol_int4_encode)), ((__pyx_t_7asyncpg_8protocol_8protocol_decode_func)(&__pyx_f_7asyncpg_8protocol_8protocol_int4_decode)), __pyx_e_7asyncpg_8protocol_8protocol_PG_FORMAT_BINARY); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 68, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "asyncpg/protocol/codecs/int.pyx":73 + * PG_FORMAT_BINARY) + * + * register_core_codec(INT8OID, # <<<<<<<<<<<<<< + * &int8_encode, + * &int8_decode, + */ + __pyx_t_1 = __pyx_f_7asyncpg_8protocol_8protocol_register_core_codec(20, ((__pyx_t_7asyncpg_8protocol_8protocol_encode_func)(&__pyx_f_7asyncpg_8protocol_8protocol_int8_encode)), ((__pyx_t_7asyncpg_8protocol_8protocol_decode_func)(&__pyx_f_7asyncpg_8protocol_8protocol_int8_decode)), __pyx_e_7asyncpg_8protocol_8protocol_PG_FORMAT_BINARY); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 73, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "asyncpg/protocol/codecs/int.pyx":56 + * + * + * cdef init_int_codecs(): # <<<<<<<<<<<<<< + * + * register_core_codec(BOOLOID, + */ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("asyncpg.protocol.protocol.init_int_codecs", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "asyncpg/protocol/codecs/json.pyx":8 + * + * + * cdef jsonb_encode(ConnectionSettings settings, WriteBuffer buf, obj): # <<<<<<<<<<<<<< + * cdef: + * char *str + */ + +static PyObject *__pyx_f_7asyncpg_8protocol_8protocol_jsonb_encode(struct __pyx_obj_7asyncpg_8protocol_8protocol_ConnectionSettings *__pyx_v_settings, struct __pyx_obj_7asyncpg_8protocol_8protocol_WriteBuffer *__pyx_v_buf, PyObject *__pyx_v_obj) { + char *__pyx_v_str; + Py_ssize_t __pyx_v_size; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_t_2; + __Pyx_RefNannySetupContext("jsonb_encode", 0); + + /* "asyncpg/protocol/codecs/json.pyx":13 + * ssize_t size + * + * as_pg_string_and_size(settings, obj, &str, &size) # <<<<<<<<<<<<<< + * + * if size > 0x7fffffff - 1: + */ + __pyx_t_1 = __pyx_f_7asyncpg_8protocol_8protocol_as_pg_string_and_size(__pyx_v_settings, __pyx_v_obj, (&__pyx_v_str), (&__pyx_v_size)); if (unlikely(!__pyx_t_1)) __PYX_ERR(12, 13, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "asyncpg/protocol/codecs/json.pyx":15 + * as_pg_string_and_size(settings, obj, &str, &size) + * + * if size > 0x7fffffff - 1: # <<<<<<<<<<<<<< + * raise ValueError('string too long') + * + */ + __pyx_t_2 = ((__pyx_v_size > 0x7FFFFFFE) != 0); + if (__pyx_t_2) { + + /* "asyncpg/protocol/codecs/json.pyx":16 + * + * if size > 0x7fffffff - 1: + * raise ValueError('string too long') # <<<<<<<<<<<<<< + * + * buf.write_int32(size + 1) + */ + __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__36, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(12, 16, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_Raise(__pyx_t_1, 0, 0, 0); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __PYX_ERR(12, 16, __pyx_L1_error) + + /* "asyncpg/protocol/codecs/json.pyx":15 + * as_pg_string_and_size(settings, obj, &str, &size) + * + * if size > 0x7fffffff - 1: # <<<<<<<<<<<<<< + * raise ValueError('string too long') + * + */ + } + + /* "asyncpg/protocol/codecs/json.pyx":18 + * raise ValueError('string too long') + * + * buf.write_int32(size + 1) # <<<<<<<<<<<<<< + * buf.write_byte(1) # JSONB format version + * buf.write_cstr(str, size) + */ + __pyx_t_1 = __pyx_f_7asyncpg_8protocol_8protocol_11WriteBuffer_write_int32(__pyx_v_buf, (((int32_t)__pyx_v_size) + 1)); if (unlikely(!__pyx_t_1)) __PYX_ERR(12, 18, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "asyncpg/protocol/codecs/json.pyx":19 + * + * buf.write_int32(size + 1) + * buf.write_byte(1) # JSONB format version # <<<<<<<<<<<<<< + * buf.write_cstr(str, size) + * + */ + __pyx_t_1 = __pyx_f_7asyncpg_8protocol_8protocol_11WriteBuffer_write_byte(__pyx_v_buf, 1); if (unlikely(!__pyx_t_1)) __PYX_ERR(12, 19, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "asyncpg/protocol/codecs/json.pyx":20 + * buf.write_int32(size + 1) + * buf.write_byte(1) # JSONB format version + * buf.write_cstr(str, size) # <<<<<<<<<<<<<< + * + * + */ + __pyx_t_1 = __pyx_f_7asyncpg_8protocol_8protocol_11WriteBuffer_write_cstr(__pyx_v_buf, __pyx_v_str, __pyx_v_size); if (unlikely(!__pyx_t_1)) __PYX_ERR(12, 20, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "asyncpg/protocol/codecs/json.pyx":8 + * + * + * cdef jsonb_encode(ConnectionSettings settings, WriteBuffer buf, obj): # <<<<<<<<<<<<<< + * cdef: + * char *str + */ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("asyncpg.protocol.protocol.jsonb_encode", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "asyncpg/protocol/codecs/json.pyx":23 + * + * + * cdef jsonb_decode(ConnectionSettings settings, FastReadBuffer buf): # <<<<<<<<<<<<<< + * cdef uint8_t format = buf.read(1)[0] + * + */ + +static PyObject *__pyx_f_7asyncpg_8protocol_8protocol_jsonb_decode(struct __pyx_obj_7asyncpg_8protocol_8protocol_ConnectionSettings *__pyx_v_settings, struct __pyx_obj_7asyncpg_8protocol_8protocol_FastReadBuffer *__pyx_v_buf) { + uint8_t __pyx_v_format; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + char const *__pyx_t_1; + int __pyx_t_2; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + PyObject *__pyx_t_5 = NULL; + PyObject *__pyx_t_6 = NULL; + PyObject *__pyx_t_7 = NULL; + __Pyx_RefNannySetupContext("jsonb_decode", 0); + + /* "asyncpg/protocol/codecs/json.pyx":24 + * + * cdef jsonb_decode(ConnectionSettings settings, FastReadBuffer buf): + * cdef uint8_t format = buf.read(1)[0] # <<<<<<<<<<<<<< + * + * if format != 1: + */ + __pyx_t_1 = __pyx_f_7asyncpg_8protocol_8protocol_14FastReadBuffer_read(__pyx_v_buf, 1); if (unlikely(__pyx_t_1 == NULL)) __PYX_ERR(12, 24, __pyx_L1_error) + __pyx_v_format = ((uint8_t)(__pyx_t_1[0])); + + /* "asyncpg/protocol/codecs/json.pyx":26 + * cdef uint8_t format = buf.read(1)[0] + * + * if format != 1: # <<<<<<<<<<<<<< + * raise ValueError('unexpected JSONB format: {}'.format(format)) + * + */ + __pyx_t_2 = ((__pyx_v_format != 1) != 0); + if (__pyx_t_2) { + + /* "asyncpg/protocol/codecs/json.pyx":27 + * + * if format != 1: + * raise ValueError('unexpected JSONB format: {}'.format(format)) # <<<<<<<<<<<<<< + * + * return text_decode(settings, buf) + */ + __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_kp_u_unexpected_JSONB_format, __pyx_n_s_format); if (unlikely(!__pyx_t_4)) __PYX_ERR(12, 27, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_5 = __Pyx_PyInt_From_uint8_t(__pyx_v_format); if (unlikely(!__pyx_t_5)) __PYX_ERR(12, 27, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_6 = NULL; + if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_4))) { + __pyx_t_6 = PyMethod_GET_SELF(__pyx_t_4); + if (likely(__pyx_t_6)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4); + __Pyx_INCREF(__pyx_t_6); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_4, function); + } + } + if (!__pyx_t_6) { + __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_t_5); if (unlikely(!__pyx_t_3)) __PYX_ERR(12, 27, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_GOTREF(__pyx_t_3); + } else { + #if CYTHON_FAST_PYCALL + if (PyFunction_Check(__pyx_t_4)) { + PyObject *__pyx_temp[2] = {__pyx_t_6, __pyx_t_5}; + __pyx_t_3 = __Pyx_PyFunction_FastCall(__pyx_t_4, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_3)) __PYX_ERR(12, 27, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + } else + #endif + #if CYTHON_FAST_PYCCALL + if (__Pyx_PyFastCFunction_Check(__pyx_t_4)) { + PyObject *__pyx_temp[2] = {__pyx_t_6, __pyx_t_5}; + __pyx_t_3 = __Pyx_PyCFunction_FastCall(__pyx_t_4, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_3)) __PYX_ERR(12, 27, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + } else + #endif + { + __pyx_t_7 = PyTuple_New(1+1); if (unlikely(!__pyx_t_7)) __PYX_ERR(12, 27, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __Pyx_GIVEREF(__pyx_t_6); PyTuple_SET_ITEM(__pyx_t_7, 0, __pyx_t_6); __pyx_t_6 = NULL; + __Pyx_GIVEREF(__pyx_t_5); + PyTuple_SET_ITEM(__pyx_t_7, 0+1, __pyx_t_5); + __pyx_t_5 = 0; + __pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_4, __pyx_t_7, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(12, 27, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + } + } + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_4 = PyTuple_New(1); if (unlikely(!__pyx_t_4)) __PYX_ERR(12, 27, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_GIVEREF(__pyx_t_3); + PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_3); + __pyx_t_3 = 0; + __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_t_4, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(12, 27, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_Raise(__pyx_t_3, 0, 0, 0); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __PYX_ERR(12, 27, __pyx_L1_error) + + /* "asyncpg/protocol/codecs/json.pyx":26 + * cdef uint8_t format = buf.read(1)[0] + * + * if format != 1: # <<<<<<<<<<<<<< + * raise ValueError('unexpected JSONB format: {}'.format(format)) + * + */ + } + + /* "asyncpg/protocol/codecs/json.pyx":29 + * raise ValueError('unexpected JSONB format: {}'.format(format)) + * + * return text_decode(settings, buf) # <<<<<<<<<<<<<< + * + * + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_3 = __pyx_f_7asyncpg_8protocol_8protocol_text_decode(__pyx_v_settings, __pyx_v_buf); if (unlikely(!__pyx_t_3)) __PYX_ERR(12, 29, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_r = __pyx_t_3; + __pyx_t_3 = 0; + goto __pyx_L0; + + /* "asyncpg/protocol/codecs/json.pyx":23 + * + * + * cdef jsonb_decode(ConnectionSettings settings, FastReadBuffer buf): # <<<<<<<<<<<<<< + * cdef uint8_t format = buf.read(1)[0] + * + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_XDECREF(__pyx_t_6); + __Pyx_XDECREF(__pyx_t_7); + __Pyx_AddTraceback("asyncpg.protocol.protocol.jsonb_decode", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "asyncpg/protocol/codecs/json.pyx":32 + * + * + * cdef init_json_codecs(): # <<<<<<<<<<<<<< + * register_core_codec(JSONOID, + * &text_encode, + */ + +static PyObject *__pyx_f_7asyncpg_8protocol_8protocol_init_json_codecs(void) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + __Pyx_RefNannySetupContext("init_json_codecs", 0); + + /* "asyncpg/protocol/codecs/json.pyx":33 + * + * cdef init_json_codecs(): + * register_core_codec(JSONOID, # <<<<<<<<<<<<<< + * &text_encode, + * &text_decode, + */ + __pyx_t_1 = __pyx_f_7asyncpg_8protocol_8protocol_register_core_codec(0x72, ((__pyx_t_7asyncpg_8protocol_8protocol_encode_func)(&__pyx_f_7asyncpg_8protocol_8protocol_text_encode)), ((__pyx_t_7asyncpg_8protocol_8protocol_decode_func)(&__pyx_f_7asyncpg_8protocol_8protocol_text_decode)), __pyx_e_7asyncpg_8protocol_8protocol_PG_FORMAT_BINARY); if (unlikely(!__pyx_t_1)) __PYX_ERR(12, 33, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "asyncpg/protocol/codecs/json.pyx":37 + * &text_decode, + * PG_FORMAT_BINARY) + * register_core_codec(JSONBOID, # <<<<<<<<<<<<<< + * &jsonb_encode, + * &jsonb_decode, + */ + __pyx_t_1 = __pyx_f_7asyncpg_8protocol_8protocol_register_core_codec(0xEDA, ((__pyx_t_7asyncpg_8protocol_8protocol_encode_func)(&__pyx_f_7asyncpg_8protocol_8protocol_jsonb_encode)), ((__pyx_t_7asyncpg_8protocol_8protocol_decode_func)(&__pyx_f_7asyncpg_8protocol_8protocol_jsonb_decode)), __pyx_e_7asyncpg_8protocol_8protocol_PG_FORMAT_BINARY); if (unlikely(!__pyx_t_1)) __PYX_ERR(12, 37, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "asyncpg/protocol/codecs/json.pyx":32 + * + * + * cdef init_json_codecs(): # <<<<<<<<<<<<<< + * register_core_codec(JSONOID, + * &text_encode, + */ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("asyncpg.protocol.protocol.init_json_codecs", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "asyncpg/protocol/codecs/money.pyx":8 + * + * + * cdef init_monetary_codecs(): # <<<<<<<<<<<<<< + * moneyoids = [ + * MONEYOID, + */ + +static PyObject *__pyx_f_7asyncpg_8protocol_8protocol_init_monetary_codecs(void) { + PyObject *__pyx_v_moneyoids = NULL; + PyObject *__pyx_v_oid = NULL; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + Py_ssize_t __pyx_t_2; + PyObject *__pyx_t_3 = NULL; + uint32_t __pyx_t_4; + __Pyx_RefNannySetupContext("init_monetary_codecs", 0); + + /* "asyncpg/protocol/codecs/money.pyx":9 + * + * cdef init_monetary_codecs(): + * moneyoids = [ # <<<<<<<<<<<<<< + * MONEYOID, + * ] + */ + __pyx_t_1 = PyList_New(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(13, 9, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_INCREF(__pyx_int_790); + __Pyx_GIVEREF(__pyx_int_790); + PyList_SET_ITEM(__pyx_t_1, 0, __pyx_int_790); + __pyx_v_moneyoids = ((PyObject*)__pyx_t_1); + __pyx_t_1 = 0; + + /* "asyncpg/protocol/codecs/money.pyx":13 + * ] + * + * for oid in moneyoids: # <<<<<<<<<<<<<< + * register_core_codec(oid, + * &text_encode, + */ + __pyx_t_1 = __pyx_v_moneyoids; __Pyx_INCREF(__pyx_t_1); __pyx_t_2 = 0; + for (;;) { + if (__pyx_t_2 >= PyList_GET_SIZE(__pyx_t_1)) break; + #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + __pyx_t_3 = PyList_GET_ITEM(__pyx_t_1, __pyx_t_2); __Pyx_INCREF(__pyx_t_3); __pyx_t_2++; if (unlikely(0 < 0)) __PYX_ERR(13, 13, __pyx_L1_error) + #else + __pyx_t_3 = PySequence_ITEM(__pyx_t_1, __pyx_t_2); __pyx_t_2++; if (unlikely(!__pyx_t_3)) __PYX_ERR(13, 13, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + #endif + __Pyx_XDECREF_SET(__pyx_v_oid, __pyx_t_3); + __pyx_t_3 = 0; + + /* "asyncpg/protocol/codecs/money.pyx":14 + * + * for oid in moneyoids: + * register_core_codec(oid, # <<<<<<<<<<<<<< + * &text_encode, + * &text_decode, + */ + __pyx_t_4 = __Pyx_PyInt_As_uint32_t(__pyx_v_oid); if (unlikely((__pyx_t_4 == ((uint32_t)-1)) && PyErr_Occurred())) __PYX_ERR(13, 14, __pyx_L1_error) + + /* "asyncpg/protocol/codecs/money.pyx":17 + * &text_encode, + * &text_decode, + * PG_FORMAT_TEXT) # <<<<<<<<<<<<<< + * + * + */ + __pyx_t_3 = __pyx_f_7asyncpg_8protocol_8protocol_register_core_codec(__pyx_t_4, ((__pyx_t_7asyncpg_8protocol_8protocol_encode_func)(&__pyx_f_7asyncpg_8protocol_8protocol_text_encode)), ((__pyx_t_7asyncpg_8protocol_8protocol_decode_func)(&__pyx_f_7asyncpg_8protocol_8protocol_text_decode)), __pyx_e_7asyncpg_8protocol_8protocol_PG_FORMAT_TEXT); if (unlikely(!__pyx_t_3)) __PYX_ERR(13, 14, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + + /* "asyncpg/protocol/codecs/money.pyx":13 + * ] + * + * for oid in moneyoids: # <<<<<<<<<<<<<< + * register_core_codec(oid, + * &text_encode, + */ + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "asyncpg/protocol/codecs/money.pyx":8 + * + * + * cdef init_monetary_codecs(): # <<<<<<<<<<<<<< + * moneyoids = [ + * MONEYOID, + */ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_AddTraceback("asyncpg.protocol.protocol.init_monetary_codecs", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XDECREF(__pyx_v_moneyoids); + __Pyx_XDECREF(__pyx_v_oid); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "asyncpg/protocol/codecs/network.pyx":21 + * + * + * cdef inline _net_encode(WriteBuffer buf, int32_t version, uint8_t bits, # <<<<<<<<<<<<<< + * int8_t is_cidr, bytes addr): + * + */ + +static CYTHON_INLINE PyObject *__pyx_f_7asyncpg_8protocol_8protocol__net_encode(struct __pyx_obj_7asyncpg_8protocol_8protocol_WriteBuffer *__pyx_v_buf, int32_t __pyx_v_version, uint8_t __pyx_v_bits, int8_t __pyx_v_is_cidr, PyObject *__pyx_v_addr) { + char *__pyx_v_addrbytes; + Py_ssize_t __pyx_v_addrlen; + int8_t __pyx_v_family; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + int8_t __pyx_t_1; + int __pyx_t_2; + PyObject *__pyx_t_3 = NULL; + __Pyx_RefNannySetupContext("_net_encode", 0); + + /* "asyncpg/protocol/codecs/network.pyx":29 + * int8_t family + * + * family = PGSQL_AF_INET if version == 4 else PGSQL_AF_INET6 # <<<<<<<<<<<<<< + * cpython.PyBytes_AsStringAndSize(addr, &addrbytes, &addrlen) + * + */ + if (((__pyx_v_version == 4) != 0)) { + __pyx_t_1 = 2; + } else { + __pyx_t_1 = 3; + } + __pyx_v_family = __pyx_t_1; + + /* "asyncpg/protocol/codecs/network.pyx":30 + * + * family = PGSQL_AF_INET if version == 4 else PGSQL_AF_INET6 + * cpython.PyBytes_AsStringAndSize(addr, &addrbytes, &addrlen) # <<<<<<<<<<<<<< + * + * buf.write_int32(4 + addrlen) + */ + __pyx_t_2 = PyBytes_AsStringAndSize(__pyx_v_addr, (&__pyx_v_addrbytes), ((Py_ssize_t *)(&__pyx_v_addrlen))); if (unlikely(__pyx_t_2 == -1)) __PYX_ERR(14, 30, __pyx_L1_error) + + /* "asyncpg/protocol/codecs/network.pyx":32 + * cpython.PyBytes_AsStringAndSize(addr, &addrbytes, &addrlen) + * + * buf.write_int32(4 + addrlen) # <<<<<<<<<<<<<< + * buf.write_byte(family) + * buf.write_byte(bits) + */ + __pyx_t_3 = __pyx_f_7asyncpg_8protocol_8protocol_11WriteBuffer_write_int32(__pyx_v_buf, (4 + ((int32_t)__pyx_v_addrlen))); if (unlikely(!__pyx_t_3)) __PYX_ERR(14, 32, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + + /* "asyncpg/protocol/codecs/network.pyx":33 + * + * buf.write_int32(4 + addrlen) + * buf.write_byte(family) # <<<<<<<<<<<<<< + * buf.write_byte(bits) + * buf.write_byte(is_cidr) + */ + __pyx_t_3 = __pyx_f_7asyncpg_8protocol_8protocol_11WriteBuffer_write_byte(__pyx_v_buf, __pyx_v_family); if (unlikely(!__pyx_t_3)) __PYX_ERR(14, 33, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + + /* "asyncpg/protocol/codecs/network.pyx":34 + * buf.write_int32(4 + addrlen) + * buf.write_byte(family) + * buf.write_byte(bits) # <<<<<<<<<<<<<< + * buf.write_byte(is_cidr) + * buf.write_byte(addrlen) + */ + __pyx_t_3 = __pyx_f_7asyncpg_8protocol_8protocol_11WriteBuffer_write_byte(__pyx_v_buf, ((int8_t)__pyx_v_bits)); if (unlikely(!__pyx_t_3)) __PYX_ERR(14, 34, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + + /* "asyncpg/protocol/codecs/network.pyx":35 + * buf.write_byte(family) + * buf.write_byte(bits) + * buf.write_byte(is_cidr) # <<<<<<<<<<<<<< + * buf.write_byte(addrlen) + * buf.write_cstr(addrbytes, addrlen) + */ + __pyx_t_3 = __pyx_f_7asyncpg_8protocol_8protocol_11WriteBuffer_write_byte(__pyx_v_buf, __pyx_v_is_cidr); if (unlikely(!__pyx_t_3)) __PYX_ERR(14, 35, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + + /* "asyncpg/protocol/codecs/network.pyx":36 + * buf.write_byte(bits) + * buf.write_byte(is_cidr) + * buf.write_byte(addrlen) # <<<<<<<<<<<<<< + * buf.write_cstr(addrbytes, addrlen) + * + */ + __pyx_t_3 = __pyx_f_7asyncpg_8protocol_8protocol_11WriteBuffer_write_byte(__pyx_v_buf, ((int8_t)__pyx_v_addrlen)); if (unlikely(!__pyx_t_3)) __PYX_ERR(14, 36, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + + /* "asyncpg/protocol/codecs/network.pyx":37 + * buf.write_byte(is_cidr) + * buf.write_byte(addrlen) + * buf.write_cstr(addrbytes, addrlen) # <<<<<<<<<<<<<< + * + * + */ + __pyx_t_3 = __pyx_f_7asyncpg_8protocol_8protocol_11WriteBuffer_write_cstr(__pyx_v_buf, __pyx_v_addrbytes, __pyx_v_addrlen); if (unlikely(!__pyx_t_3)) __PYX_ERR(14, 37, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + + /* "asyncpg/protocol/codecs/network.pyx":21 + * + * + * cdef inline _net_encode(WriteBuffer buf, int32_t version, uint8_t bits, # <<<<<<<<<<<<<< + * int8_t is_cidr, bytes addr): + * + */ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_3); + __Pyx_AddTraceback("asyncpg.protocol.protocol._net_encode", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "asyncpg/protocol/codecs/network.pyx":40 + * + * + * cdef net_decode(ConnectionSettings settings, FastReadBuffer buf): # <<<<<<<<<<<<<< + * cdef: + * int32_t family = buf.read(1)[0] + */ + +static PyObject *__pyx_f_7asyncpg_8protocol_8protocol_net_decode(CYTHON_UNUSED struct __pyx_obj_7asyncpg_8protocol_8protocol_ConnectionSettings *__pyx_v_settings, struct __pyx_obj_7asyncpg_8protocol_8protocol_FastReadBuffer *__pyx_v_buf) { + int32_t __pyx_v_family; + uint8_t __pyx_v_bits; + uint32_t __pyx_v_is_cidr; + uint32_t __pyx_v_addrlen; + PyObject *__pyx_v_addr = 0; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + char const *__pyx_t_1; + int __pyx_t_2; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + PyObject *__pyx_t_5 = NULL; + PyObject *__pyx_t_6 = NULL; + PyObject *__pyx_t_7 = NULL; + long __pyx_t_8; + int __pyx_t_9; + __Pyx_RefNannySetupContext("net_decode", 0); + + /* "asyncpg/protocol/codecs/network.pyx":42 + * cdef net_decode(ConnectionSettings settings, FastReadBuffer buf): + * cdef: + * int32_t family = buf.read(1)[0] # <<<<<<<<<<<<<< + * uint8_t bits = buf.read(1)[0] + * uint32_t is_cidr = buf.read(1)[0] + */ + __pyx_t_1 = __pyx_f_7asyncpg_8protocol_8protocol_14FastReadBuffer_read(__pyx_v_buf, 1); if (unlikely(__pyx_t_1 == NULL)) __PYX_ERR(14, 42, __pyx_L1_error) + __pyx_v_family = ((int32_t)(__pyx_t_1[0])); + + /* "asyncpg/protocol/codecs/network.pyx":43 + * cdef: + * int32_t family = buf.read(1)[0] + * uint8_t bits = buf.read(1)[0] # <<<<<<<<<<<<<< + * uint32_t is_cidr = buf.read(1)[0] + * uint32_t addrlen = buf.read(1)[0] + */ + __pyx_t_1 = __pyx_f_7asyncpg_8protocol_8protocol_14FastReadBuffer_read(__pyx_v_buf, 1); if (unlikely(__pyx_t_1 == NULL)) __PYX_ERR(14, 43, __pyx_L1_error) + __pyx_v_bits = ((uint8_t)(__pyx_t_1[0])); + + /* "asyncpg/protocol/codecs/network.pyx":44 + * int32_t family = buf.read(1)[0] + * uint8_t bits = buf.read(1)[0] + * uint32_t is_cidr = buf.read(1)[0] # <<<<<<<<<<<<<< + * uint32_t addrlen = buf.read(1)[0] + * bytes addr + */ + __pyx_t_1 = __pyx_f_7asyncpg_8protocol_8protocol_14FastReadBuffer_read(__pyx_v_buf, 1); if (unlikely(__pyx_t_1 == NULL)) __PYX_ERR(14, 44, __pyx_L1_error) + __pyx_v_is_cidr = ((uint32_t)(__pyx_t_1[0])); + + /* "asyncpg/protocol/codecs/network.pyx":45 + * uint8_t bits = buf.read(1)[0] + * uint32_t is_cidr = buf.read(1)[0] + * uint32_t addrlen = buf.read(1)[0] # <<<<<<<<<<<<<< + * bytes addr + * + */ + __pyx_t_1 = __pyx_f_7asyncpg_8protocol_8protocol_14FastReadBuffer_read(__pyx_v_buf, 1); if (unlikely(__pyx_t_1 == NULL)) __PYX_ERR(14, 45, __pyx_L1_error) + __pyx_v_addrlen = ((uint32_t)(__pyx_t_1[0])); + + /* "asyncpg/protocol/codecs/network.pyx":48 + * bytes addr + * + * if family != PGSQL_AF_INET and family != PGSQL_AF_INET6: # <<<<<<<<<<<<<< + * raise ValueError('invalid address family in "{}" value'.format( + * 'cidr' if is_cidr else 'inet' + */ + switch (__pyx_v_family) { + case 2: + case 3: + __pyx_t_2 = 0; + break; + default: + __pyx_t_2 = 1; + break; + } + if (__pyx_t_2) { + + /* "asyncpg/protocol/codecs/network.pyx":49 + * + * if family != PGSQL_AF_INET and family != PGSQL_AF_INET6: + * raise ValueError('invalid address family in "{}" value'.format( # <<<<<<<<<<<<<< + * 'cidr' if is_cidr else 'inet' + * )) + */ + __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_kp_u_invalid_address_family_in_value, __pyx_n_s_format); if (unlikely(!__pyx_t_4)) __PYX_ERR(14, 49, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + + /* "asyncpg/protocol/codecs/network.pyx":50 + * if family != PGSQL_AF_INET and family != PGSQL_AF_INET6: + * raise ValueError('invalid address family in "{}" value'.format( + * 'cidr' if is_cidr else 'inet' # <<<<<<<<<<<<<< + * )) + * + */ + if ((__pyx_v_is_cidr != 0)) { + __Pyx_INCREF(__pyx_n_u_cidr); + __pyx_t_5 = __pyx_n_u_cidr; + } else { + __Pyx_INCREF(__pyx_n_u_inet); + __pyx_t_5 = __pyx_n_u_inet; + } + __pyx_t_6 = NULL; + if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_4))) { + __pyx_t_6 = PyMethod_GET_SELF(__pyx_t_4); + if (likely(__pyx_t_6)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4); + __Pyx_INCREF(__pyx_t_6); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_4, function); + } + } + if (!__pyx_t_6) { + __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_t_5); if (unlikely(!__pyx_t_3)) __PYX_ERR(14, 49, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_GOTREF(__pyx_t_3); + } else { + #if CYTHON_FAST_PYCALL + if (PyFunction_Check(__pyx_t_4)) { + PyObject *__pyx_temp[2] = {__pyx_t_6, __pyx_t_5}; + __pyx_t_3 = __Pyx_PyFunction_FastCall(__pyx_t_4, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_3)) __PYX_ERR(14, 49, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + } else + #endif + #if CYTHON_FAST_PYCCALL + if (__Pyx_PyFastCFunction_Check(__pyx_t_4)) { + PyObject *__pyx_temp[2] = {__pyx_t_6, __pyx_t_5}; + __pyx_t_3 = __Pyx_PyCFunction_FastCall(__pyx_t_4, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_3)) __PYX_ERR(14, 49, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + } else + #endif + { + __pyx_t_7 = PyTuple_New(1+1); if (unlikely(!__pyx_t_7)) __PYX_ERR(14, 49, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __Pyx_GIVEREF(__pyx_t_6); PyTuple_SET_ITEM(__pyx_t_7, 0, __pyx_t_6); __pyx_t_6 = NULL; + __Pyx_GIVEREF(__pyx_t_5); + PyTuple_SET_ITEM(__pyx_t_7, 0+1, __pyx_t_5); + __pyx_t_5 = 0; + __pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_4, __pyx_t_7, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(14, 49, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + } + } + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + + /* "asyncpg/protocol/codecs/network.pyx":49 + * + * if family != PGSQL_AF_INET and family != PGSQL_AF_INET6: + * raise ValueError('invalid address family in "{}" value'.format( # <<<<<<<<<<<<<< + * 'cidr' if is_cidr else 'inet' + * )) + */ + __pyx_t_4 = PyTuple_New(1); if (unlikely(!__pyx_t_4)) __PYX_ERR(14, 49, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_GIVEREF(__pyx_t_3); + PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_3); + __pyx_t_3 = 0; + __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_t_4, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(14, 49, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_Raise(__pyx_t_3, 0, 0, 0); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __PYX_ERR(14, 49, __pyx_L1_error) + + /* "asyncpg/protocol/codecs/network.pyx":48 + * bytes addr + * + * if family != PGSQL_AF_INET and family != PGSQL_AF_INET6: # <<<<<<<<<<<<<< + * raise ValueError('invalid address family in "{}" value'.format( + * 'cidr' if is_cidr else 'inet' + */ + } + + /* "asyncpg/protocol/codecs/network.pyx":53 + * )) + * + * if bits > (32 if family == PGSQL_AF_INET else 128): # <<<<<<<<<<<<<< + * raise ValueError('invalid bits in "{}" value'.format( + * 'cidr' if is_cidr else 'inet' + */ + if (((__pyx_v_family == 2) != 0)) { + __pyx_t_8 = 32; + } else { + __pyx_t_8 = 0x80; + } + __pyx_t_2 = ((__pyx_v_bits > __pyx_t_8) != 0); + if (__pyx_t_2) { + + /* "asyncpg/protocol/codecs/network.pyx":54 + * + * if bits > (32 if family == PGSQL_AF_INET else 128): + * raise ValueError('invalid bits in "{}" value'.format( # <<<<<<<<<<<<<< + * 'cidr' if is_cidr else 'inet' + * )) + */ + __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_kp_u_invalid_bits_in_value, __pyx_n_s_format); if (unlikely(!__pyx_t_4)) __PYX_ERR(14, 54, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + + /* "asyncpg/protocol/codecs/network.pyx":55 + * if bits > (32 if family == PGSQL_AF_INET else 128): + * raise ValueError('invalid bits in "{}" value'.format( + * 'cidr' if is_cidr else 'inet' # <<<<<<<<<<<<<< + * )) + * + */ + if ((__pyx_v_is_cidr != 0)) { + __Pyx_INCREF(__pyx_n_u_cidr); + __pyx_t_7 = __pyx_n_u_cidr; + } else { + __Pyx_INCREF(__pyx_n_u_inet); + __pyx_t_7 = __pyx_n_u_inet; + } + __pyx_t_5 = NULL; + if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_4))) { + __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_4); + if (likely(__pyx_t_5)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4); + __Pyx_INCREF(__pyx_t_5); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_4, function); + } + } + if (!__pyx_t_5) { + __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_t_7); if (unlikely(!__pyx_t_3)) __PYX_ERR(14, 54, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_GOTREF(__pyx_t_3); + } else { + #if CYTHON_FAST_PYCALL + if (PyFunction_Check(__pyx_t_4)) { + PyObject *__pyx_temp[2] = {__pyx_t_5, __pyx_t_7}; + __pyx_t_3 = __Pyx_PyFunction_FastCall(__pyx_t_4, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_3)) __PYX_ERR(14, 54, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + } else + #endif + #if CYTHON_FAST_PYCCALL + if (__Pyx_PyFastCFunction_Check(__pyx_t_4)) { + PyObject *__pyx_temp[2] = {__pyx_t_5, __pyx_t_7}; + __pyx_t_3 = __Pyx_PyCFunction_FastCall(__pyx_t_4, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_3)) __PYX_ERR(14, 54, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + } else + #endif + { + __pyx_t_6 = PyTuple_New(1+1); if (unlikely(!__pyx_t_6)) __PYX_ERR(14, 54, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_GIVEREF(__pyx_t_5); PyTuple_SET_ITEM(__pyx_t_6, 0, __pyx_t_5); __pyx_t_5 = NULL; + __Pyx_GIVEREF(__pyx_t_7); + PyTuple_SET_ITEM(__pyx_t_6, 0+1, __pyx_t_7); + __pyx_t_7 = 0; + __pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_4, __pyx_t_6, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(14, 54, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + } + } + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + + /* "asyncpg/protocol/codecs/network.pyx":54 + * + * if bits > (32 if family == PGSQL_AF_INET else 128): + * raise ValueError('invalid bits in "{}" value'.format( # <<<<<<<<<<<<<< + * 'cidr' if is_cidr else 'inet' + * )) + */ + __pyx_t_4 = PyTuple_New(1); if (unlikely(!__pyx_t_4)) __PYX_ERR(14, 54, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_GIVEREF(__pyx_t_3); + PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_3); + __pyx_t_3 = 0; + __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_t_4, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(14, 54, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_Raise(__pyx_t_3, 0, 0, 0); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __PYX_ERR(14, 54, __pyx_L1_error) + + /* "asyncpg/protocol/codecs/network.pyx":53 + * )) + * + * if bits > (32 if family == PGSQL_AF_INET else 128): # <<<<<<<<<<<<<< + * raise ValueError('invalid bits in "{}" value'.format( + * 'cidr' if is_cidr else 'inet' + */ + } + + /* "asyncpg/protocol/codecs/network.pyx":58 + * )) + * + * if addrlen != (4 if family == PGSQL_AF_INET else 16): # <<<<<<<<<<<<<< + * raise ValueError('invalid length in "{}" value'.format( + * 'cidr' if is_cidr else 'inet' + */ + if (((__pyx_v_family == 2) != 0)) { + __pyx_t_8 = 4; + } else { + __pyx_t_8 = 16; + } + __pyx_t_2 = ((__pyx_v_addrlen != __pyx_t_8) != 0); + if (__pyx_t_2) { + + /* "asyncpg/protocol/codecs/network.pyx":59 + * + * if addrlen != (4 if family == PGSQL_AF_INET else 16): + * raise ValueError('invalid length in "{}" value'.format( # <<<<<<<<<<<<<< + * 'cidr' if is_cidr else 'inet' + * )) + */ + __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_kp_u_invalid_length_in_value, __pyx_n_s_format); if (unlikely(!__pyx_t_4)) __PYX_ERR(14, 59, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + + /* "asyncpg/protocol/codecs/network.pyx":60 + * if addrlen != (4 if family == PGSQL_AF_INET else 16): + * raise ValueError('invalid length in "{}" value'.format( + * 'cidr' if is_cidr else 'inet' # <<<<<<<<<<<<<< + * )) + * + */ + if ((__pyx_v_is_cidr != 0)) { + __Pyx_INCREF(__pyx_n_u_cidr); + __pyx_t_6 = __pyx_n_u_cidr; + } else { + __Pyx_INCREF(__pyx_n_u_inet); + __pyx_t_6 = __pyx_n_u_inet; + } + __pyx_t_7 = NULL; + if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_4))) { + __pyx_t_7 = PyMethod_GET_SELF(__pyx_t_4); + if (likely(__pyx_t_7)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4); + __Pyx_INCREF(__pyx_t_7); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_4, function); + } + } + if (!__pyx_t_7) { + __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_t_6); if (unlikely(!__pyx_t_3)) __PYX_ERR(14, 59, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_GOTREF(__pyx_t_3); + } else { + #if CYTHON_FAST_PYCALL + if (PyFunction_Check(__pyx_t_4)) { + PyObject *__pyx_temp[2] = {__pyx_t_7, __pyx_t_6}; + __pyx_t_3 = __Pyx_PyFunction_FastCall(__pyx_t_4, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_3)) __PYX_ERR(14, 59, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + } else + #endif + #if CYTHON_FAST_PYCCALL + if (__Pyx_PyFastCFunction_Check(__pyx_t_4)) { + PyObject *__pyx_temp[2] = {__pyx_t_7, __pyx_t_6}; + __pyx_t_3 = __Pyx_PyCFunction_FastCall(__pyx_t_4, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_3)) __PYX_ERR(14, 59, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + } else + #endif + { + __pyx_t_5 = PyTuple_New(1+1); if (unlikely(!__pyx_t_5)) __PYX_ERR(14, 59, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_GIVEREF(__pyx_t_7); PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_t_7); __pyx_t_7 = NULL; + __Pyx_GIVEREF(__pyx_t_6); + PyTuple_SET_ITEM(__pyx_t_5, 0+1, __pyx_t_6); + __pyx_t_6 = 0; + __pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_4, __pyx_t_5, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(14, 59, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + } + } + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + + /* "asyncpg/protocol/codecs/network.pyx":59 + * + * if addrlen != (4 if family == PGSQL_AF_INET else 16): + * raise ValueError('invalid length in "{}" value'.format( # <<<<<<<<<<<<<< + * 'cidr' if is_cidr else 'inet' + * )) + */ + __pyx_t_4 = PyTuple_New(1); if (unlikely(!__pyx_t_4)) __PYX_ERR(14, 59, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_GIVEREF(__pyx_t_3); + PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_3); + __pyx_t_3 = 0; + __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_t_4, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(14, 59, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_Raise(__pyx_t_3, 0, 0, 0); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __PYX_ERR(14, 59, __pyx_L1_error) + + /* "asyncpg/protocol/codecs/network.pyx":58 + * )) + * + * if addrlen != (4 if family == PGSQL_AF_INET else 16): # <<<<<<<<<<<<<< + * raise ValueError('invalid length in "{}" value'.format( + * 'cidr' if is_cidr else 'inet' + */ + } + + /* "asyncpg/protocol/codecs/network.pyx":63 + * )) + * + * addr = cpython.PyBytes_FromStringAndSize(buf.read(addrlen), addrlen) # <<<<<<<<<<<<<< + * + * if is_cidr or bits > 0: + */ + __pyx_t_1 = __pyx_f_7asyncpg_8protocol_8protocol_14FastReadBuffer_read(__pyx_v_buf, __pyx_v_addrlen); if (unlikely(__pyx_t_1 == NULL)) __PYX_ERR(14, 63, __pyx_L1_error) + __pyx_t_3 = PyBytes_FromStringAndSize(__pyx_t_1, __pyx_v_addrlen); if (unlikely(!__pyx_t_3)) __PYX_ERR(14, 63, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_v_addr = ((PyObject*)__pyx_t_3); + __pyx_t_3 = 0; + + /* "asyncpg/protocol/codecs/network.pyx":65 + * addr = cpython.PyBytes_FromStringAndSize(buf.read(addrlen), addrlen) + * + * if is_cidr or bits > 0: # <<<<<<<<<<<<<< + * return _ipnet(addr).supernet(new_prefix=cpython.PyLong_FromLong(bits)) + * else: + */ + __pyx_t_9 = (__pyx_v_is_cidr != 0); + if (!__pyx_t_9) { + } else { + __pyx_t_2 = __pyx_t_9; + goto __pyx_L7_bool_binop_done; + } + __pyx_t_9 = ((__pyx_v_bits > 0) != 0); + __pyx_t_2 = __pyx_t_9; + __pyx_L7_bool_binop_done:; + if (__pyx_t_2) { + + /* "asyncpg/protocol/codecs/network.pyx":66 + * + * if is_cidr or bits > 0: + * return _ipnet(addr).supernet(new_prefix=cpython.PyLong_FromLong(bits)) # <<<<<<<<<<<<<< + * else: + * return _ipaddr(addr) + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_4 = __Pyx_GetModuleGlobalName(__pyx_n_s_ipnet); if (unlikely(!__pyx_t_4)) __PYX_ERR(14, 66, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_5 = NULL; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_4))) { + __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_4); + if (likely(__pyx_t_5)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4); + __Pyx_INCREF(__pyx_t_5); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_4, function); + } + } + if (!__pyx_t_5) { + __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_v_addr); if (unlikely(!__pyx_t_3)) __PYX_ERR(14, 66, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + } else { + #if CYTHON_FAST_PYCALL + if (PyFunction_Check(__pyx_t_4)) { + PyObject *__pyx_temp[2] = {__pyx_t_5, __pyx_v_addr}; + __pyx_t_3 = __Pyx_PyFunction_FastCall(__pyx_t_4, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_3)) __PYX_ERR(14, 66, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_GOTREF(__pyx_t_3); + } else + #endif + #if CYTHON_FAST_PYCCALL + if (__Pyx_PyFastCFunction_Check(__pyx_t_4)) { + PyObject *__pyx_temp[2] = {__pyx_t_5, __pyx_v_addr}; + __pyx_t_3 = __Pyx_PyCFunction_FastCall(__pyx_t_4, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_3)) __PYX_ERR(14, 66, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_GOTREF(__pyx_t_3); + } else + #endif + { + __pyx_t_6 = PyTuple_New(1+1); if (unlikely(!__pyx_t_6)) __PYX_ERR(14, 66, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_GIVEREF(__pyx_t_5); PyTuple_SET_ITEM(__pyx_t_6, 0, __pyx_t_5); __pyx_t_5 = NULL; + __Pyx_INCREF(__pyx_v_addr); + __Pyx_GIVEREF(__pyx_v_addr); + PyTuple_SET_ITEM(__pyx_t_6, 0+1, __pyx_v_addr); + __pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_4, __pyx_t_6, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(14, 66, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + } + } + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_supernet); if (unlikely(!__pyx_t_4)) __PYX_ERR(14, 66, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_3 = PyDict_New(); if (unlikely(!__pyx_t_3)) __PYX_ERR(14, 66, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_6 = PyLong_FromLong(__pyx_v_bits); if (unlikely(!__pyx_t_6)) __PYX_ERR(14, 66, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + if (PyDict_SetItem(__pyx_t_3, __pyx_n_s_new_prefix, __pyx_t_6) < 0) __PYX_ERR(14, 66, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __pyx_t_6 = __Pyx_PyObject_Call(__pyx_t_4, __pyx_empty_tuple, __pyx_t_3); if (unlikely(!__pyx_t_6)) __PYX_ERR(14, 66, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_r = __pyx_t_6; + __pyx_t_6 = 0; + goto __pyx_L0; + + /* "asyncpg/protocol/codecs/network.pyx":65 + * addr = cpython.PyBytes_FromStringAndSize(buf.read(addrlen), addrlen) + * + * if is_cidr or bits > 0: # <<<<<<<<<<<<<< + * return _ipnet(addr).supernet(new_prefix=cpython.PyLong_FromLong(bits)) + * else: + */ + } + + /* "asyncpg/protocol/codecs/network.pyx":68 + * return _ipnet(addr).supernet(new_prefix=cpython.PyLong_FromLong(bits)) + * else: + * return _ipaddr(addr) # <<<<<<<<<<<<<< + * + * + */ + /*else*/ { + __Pyx_XDECREF(__pyx_r); + __pyx_t_3 = __Pyx_GetModuleGlobalName(__pyx_n_s_ipaddr); if (unlikely(!__pyx_t_3)) __PYX_ERR(14, 68, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = NULL; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_3))) { + __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_3); + if (likely(__pyx_t_4)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); + __Pyx_INCREF(__pyx_t_4); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_3, function); + } + } + if (!__pyx_t_4) { + __pyx_t_6 = __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_v_addr); if (unlikely(!__pyx_t_6)) __PYX_ERR(14, 68, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + } else { + #if CYTHON_FAST_PYCALL + if (PyFunction_Check(__pyx_t_3)) { + PyObject *__pyx_temp[2] = {__pyx_t_4, __pyx_v_addr}; + __pyx_t_6 = __Pyx_PyFunction_FastCall(__pyx_t_3, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_6)) __PYX_ERR(14, 68, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_GOTREF(__pyx_t_6); + } else + #endif + #if CYTHON_FAST_PYCCALL + if (__Pyx_PyFastCFunction_Check(__pyx_t_3)) { + PyObject *__pyx_temp[2] = {__pyx_t_4, __pyx_v_addr}; + __pyx_t_6 = __Pyx_PyCFunction_FastCall(__pyx_t_3, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_6)) __PYX_ERR(14, 68, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_GOTREF(__pyx_t_6); + } else + #endif + { + __pyx_t_5 = PyTuple_New(1+1); if (unlikely(!__pyx_t_5)) __PYX_ERR(14, 68, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_GIVEREF(__pyx_t_4); PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_t_4); __pyx_t_4 = NULL; + __Pyx_INCREF(__pyx_v_addr); + __Pyx_GIVEREF(__pyx_v_addr); + PyTuple_SET_ITEM(__pyx_t_5, 0+1, __pyx_v_addr); + __pyx_t_6 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_t_5, NULL); if (unlikely(!__pyx_t_6)) __PYX_ERR(14, 68, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + } + } + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_r = __pyx_t_6; + __pyx_t_6 = 0; + goto __pyx_L0; + } + + /* "asyncpg/protocol/codecs/network.pyx":40 + * + * + * cdef net_decode(ConnectionSettings settings, FastReadBuffer buf): # <<<<<<<<<<<<<< + * cdef: + * int32_t family = buf.read(1)[0] + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_XDECREF(__pyx_t_6); + __Pyx_XDECREF(__pyx_t_7); + __Pyx_AddTraceback("asyncpg.protocol.protocol.net_decode", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XDECREF(__pyx_v_addr); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "asyncpg/protocol/codecs/network.pyx":71 + * + * + * cdef cidr_encode(ConnectionSettings settings, WriteBuffer buf, obj): # <<<<<<<<<<<<<< + * cdef: + * object ipnet + */ + +static PyObject *__pyx_f_7asyncpg_8protocol_8protocol_cidr_encode(CYTHON_UNUSED struct __pyx_obj_7asyncpg_8protocol_8protocol_ConnectionSettings *__pyx_v_settings, struct __pyx_obj_7asyncpg_8protocol_8protocol_WriteBuffer *__pyx_v_buf, PyObject *__pyx_v_obj) { + PyObject *__pyx_v_ipnet = 0; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + int32_t __pyx_t_5; + uint8_t __pyx_t_6; + __Pyx_RefNannySetupContext("cidr_encode", 0); + + /* "asyncpg/protocol/codecs/network.pyx":75 + * object ipnet + * + * ipnet = _ipnet(obj) # <<<<<<<<<<<<<< + * _net_encode(buf, ipnet.version, ipnet.prefixlen, 1, + * ipnet.network_address.packed) + */ + __pyx_t_2 = __Pyx_GetModuleGlobalName(__pyx_n_s_ipnet); if (unlikely(!__pyx_t_2)) __PYX_ERR(14, 75, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = NULL; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_3)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_3); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + } + } + if (!__pyx_t_3) { + __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_v_obj); if (unlikely(!__pyx_t_1)) __PYX_ERR(14, 75, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + } else { + #if CYTHON_FAST_PYCALL + if (PyFunction_Check(__pyx_t_2)) { + PyObject *__pyx_temp[2] = {__pyx_t_3, __pyx_v_obj}; + __pyx_t_1 = __Pyx_PyFunction_FastCall(__pyx_t_2, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_1)) __PYX_ERR(14, 75, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_GOTREF(__pyx_t_1); + } else + #endif + #if CYTHON_FAST_PYCCALL + if (__Pyx_PyFastCFunction_Check(__pyx_t_2)) { + PyObject *__pyx_temp[2] = {__pyx_t_3, __pyx_v_obj}; + __pyx_t_1 = __Pyx_PyCFunction_FastCall(__pyx_t_2, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_1)) __PYX_ERR(14, 75, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_GOTREF(__pyx_t_1); + } else + #endif + { + __pyx_t_4 = PyTuple_New(1+1); if (unlikely(!__pyx_t_4)) __PYX_ERR(14, 75, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_GIVEREF(__pyx_t_3); PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_3); __pyx_t_3 = NULL; + __Pyx_INCREF(__pyx_v_obj); + __Pyx_GIVEREF(__pyx_v_obj); + PyTuple_SET_ITEM(__pyx_t_4, 0+1, __pyx_v_obj); + __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_t_4, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(14, 75, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + } + } + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_v_ipnet = __pyx_t_1; + __pyx_t_1 = 0; + + /* "asyncpg/protocol/codecs/network.pyx":76 + * + * ipnet = _ipnet(obj) + * _net_encode(buf, ipnet.version, ipnet.prefixlen, 1, # <<<<<<<<<<<<<< + * ipnet.network_address.packed) + * + */ + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_ipnet, __pyx_n_s_version); if (unlikely(!__pyx_t_1)) __PYX_ERR(14, 76, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_5 = __Pyx_PyInt_As_int32_t(__pyx_t_1); if (unlikely((__pyx_t_5 == ((int32_t)-1)) && PyErr_Occurred())) __PYX_ERR(14, 76, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_ipnet, __pyx_n_s_prefixlen); if (unlikely(!__pyx_t_1)) __PYX_ERR(14, 76, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_6 = __Pyx_PyInt_As_uint8_t(__pyx_t_1); if (unlikely((__pyx_t_6 == ((uint8_t)-1)) && PyErr_Occurred())) __PYX_ERR(14, 76, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "asyncpg/protocol/codecs/network.pyx":77 + * ipnet = _ipnet(obj) + * _net_encode(buf, ipnet.version, ipnet.prefixlen, 1, + * ipnet.network_address.packed) # <<<<<<<<<<<<<< + * + * + */ + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_ipnet, __pyx_n_s_network_address); if (unlikely(!__pyx_t_1)) __PYX_ERR(14, 77, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_packed); if (unlikely(!__pyx_t_2)) __PYX_ERR(14, 77, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + if (!(likely(PyBytes_CheckExact(__pyx_t_2))||((__pyx_t_2) == Py_None)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "bytes", Py_TYPE(__pyx_t_2)->tp_name), 0))) __PYX_ERR(14, 77, __pyx_L1_error) + + /* "asyncpg/protocol/codecs/network.pyx":76 + * + * ipnet = _ipnet(obj) + * _net_encode(buf, ipnet.version, ipnet.prefixlen, 1, # <<<<<<<<<<<<<< + * ipnet.network_address.packed) + * + */ + __pyx_t_1 = __pyx_f_7asyncpg_8protocol_8protocol__net_encode(__pyx_v_buf, __pyx_t_5, __pyx_t_6, 1, ((PyObject*)__pyx_t_2)); if (unlikely(!__pyx_t_1)) __PYX_ERR(14, 76, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "asyncpg/protocol/codecs/network.pyx":71 + * + * + * cdef cidr_encode(ConnectionSettings settings, WriteBuffer buf, obj): # <<<<<<<<<<<<<< + * cdef: + * object ipnet + */ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_AddTraceback("asyncpg.protocol.protocol.cidr_encode", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XDECREF(__pyx_v_ipnet); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "asyncpg/protocol/codecs/network.pyx":80 + * + * + * cdef inet_encode(ConnectionSettings settings, WriteBuffer buf, obj): # <<<<<<<<<<<<<< + * cdef: + * object ipaddr + */ + +static PyObject *__pyx_f_7asyncpg_8protocol_8protocol_inet_encode(struct __pyx_obj_7asyncpg_8protocol_8protocol_ConnectionSettings *__pyx_v_settings, struct __pyx_obj_7asyncpg_8protocol_8protocol_WriteBuffer *__pyx_v_buf, PyObject *__pyx_v_obj) { + PyObject *__pyx_v_ipaddr = 0; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + PyObject *__pyx_t_5 = NULL; + PyObject *__pyx_t_6 = NULL; + PyObject *__pyx_t_7 = NULL; + int32_t __pyx_t_8; + int __pyx_t_9; + __Pyx_RefNannySetupContext("inet_encode", 0); + + /* "asyncpg/protocol/codecs/network.pyx":84 + * object ipaddr + * + * try: # <<<<<<<<<<<<<< + * ipaddr = _ipaddr(obj) + * except ValueError: + */ + { + __Pyx_PyThreadState_declare + __Pyx_PyThreadState_assign + __Pyx_ExceptionSave(&__pyx_t_1, &__pyx_t_2, &__pyx_t_3); + __Pyx_XGOTREF(__pyx_t_1); + __Pyx_XGOTREF(__pyx_t_2); + __Pyx_XGOTREF(__pyx_t_3); + /*try:*/ { + + /* "asyncpg/protocol/codecs/network.pyx":85 + * + * try: + * ipaddr = _ipaddr(obj) # <<<<<<<<<<<<<< + * except ValueError: + * # PostgreSQL accepts *both* CIDR and host values + */ + __pyx_t_5 = __Pyx_GetModuleGlobalName(__pyx_n_s_ipaddr); if (unlikely(!__pyx_t_5)) __PYX_ERR(14, 85, __pyx_L3_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_6 = NULL; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_5))) { + __pyx_t_6 = PyMethod_GET_SELF(__pyx_t_5); + if (likely(__pyx_t_6)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_5); + __Pyx_INCREF(__pyx_t_6); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_5, function); + } + } + if (!__pyx_t_6) { + __pyx_t_4 = __Pyx_PyObject_CallOneArg(__pyx_t_5, __pyx_v_obj); if (unlikely(!__pyx_t_4)) __PYX_ERR(14, 85, __pyx_L3_error) + __Pyx_GOTREF(__pyx_t_4); + } else { + #if CYTHON_FAST_PYCALL + if (PyFunction_Check(__pyx_t_5)) { + PyObject *__pyx_temp[2] = {__pyx_t_6, __pyx_v_obj}; + __pyx_t_4 = __Pyx_PyFunction_FastCall(__pyx_t_5, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_4)) __PYX_ERR(14, 85, __pyx_L3_error) + __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_GOTREF(__pyx_t_4); + } else + #endif + #if CYTHON_FAST_PYCCALL + if (__Pyx_PyFastCFunction_Check(__pyx_t_5)) { + PyObject *__pyx_temp[2] = {__pyx_t_6, __pyx_v_obj}; + __pyx_t_4 = __Pyx_PyCFunction_FastCall(__pyx_t_5, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_4)) __PYX_ERR(14, 85, __pyx_L3_error) + __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_GOTREF(__pyx_t_4); + } else + #endif + { + __pyx_t_7 = PyTuple_New(1+1); if (unlikely(!__pyx_t_7)) __PYX_ERR(14, 85, __pyx_L3_error) + __Pyx_GOTREF(__pyx_t_7); + __Pyx_GIVEREF(__pyx_t_6); PyTuple_SET_ITEM(__pyx_t_7, 0, __pyx_t_6); __pyx_t_6 = NULL; + __Pyx_INCREF(__pyx_v_obj); + __Pyx_GIVEREF(__pyx_v_obj); + PyTuple_SET_ITEM(__pyx_t_7, 0+1, __pyx_v_obj); + __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_5, __pyx_t_7, NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(14, 85, __pyx_L3_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + } + } + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __pyx_v_ipaddr = __pyx_t_4; + __pyx_t_4 = 0; + + /* "asyncpg/protocol/codecs/network.pyx":84 + * object ipaddr + * + * try: # <<<<<<<<<<<<<< + * ipaddr = _ipaddr(obj) + * except ValueError: + */ + } + + /* "asyncpg/protocol/codecs/network.pyx":91 + * cidr_encode(settings, buf, obj) + * else: + * _net_encode(buf, ipaddr.version, 0, 0, ipaddr.packed) # <<<<<<<<<<<<<< + * + * + */ + /*else:*/ { + __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_ipaddr, __pyx_n_s_version); if (unlikely(!__pyx_t_4)) __PYX_ERR(14, 91, __pyx_L5_except_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_8 = __Pyx_PyInt_As_int32_t(__pyx_t_4); if (unlikely((__pyx_t_8 == ((int32_t)-1)) && PyErr_Occurred())) __PYX_ERR(14, 91, __pyx_L5_except_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_ipaddr, __pyx_n_s_packed); if (unlikely(!__pyx_t_4)) __PYX_ERR(14, 91, __pyx_L5_except_error) + __Pyx_GOTREF(__pyx_t_4); + if (!(likely(PyBytes_CheckExact(__pyx_t_4))||((__pyx_t_4) == Py_None)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "bytes", Py_TYPE(__pyx_t_4)->tp_name), 0))) __PYX_ERR(14, 91, __pyx_L5_except_error) + __pyx_t_5 = __pyx_f_7asyncpg_8protocol_8protocol__net_encode(__pyx_v_buf, __pyx_t_8, 0, 0, ((PyObject*)__pyx_t_4)); if (unlikely(!__pyx_t_5)) __PYX_ERR(14, 91, __pyx_L5_except_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + } + __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + goto __pyx_L10_try_end; + __pyx_L3_error:; + __Pyx_PyThreadState_assign + __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + + /* "asyncpg/protocol/codecs/network.pyx":86 + * try: + * ipaddr = _ipaddr(obj) + * except ValueError: # <<<<<<<<<<<<<< + * # PostgreSQL accepts *both* CIDR and host values + * # for the host datatype. + */ + __pyx_t_9 = __Pyx_PyErr_ExceptionMatches(__pyx_builtin_ValueError); + if (__pyx_t_9) { + __Pyx_AddTraceback("asyncpg.protocol.protocol.inet_encode", __pyx_clineno, __pyx_lineno, __pyx_filename); + if (__Pyx_GetException(&__pyx_t_5, &__pyx_t_4, &__pyx_t_7) < 0) __PYX_ERR(14, 86, __pyx_L5_except_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_GOTREF(__pyx_t_4); + __Pyx_GOTREF(__pyx_t_7); + + /* "asyncpg/protocol/codecs/network.pyx":89 + * # PostgreSQL accepts *both* CIDR and host values + * # for the host datatype. + * cidr_encode(settings, buf, obj) # <<<<<<<<<<<<<< + * else: + * _net_encode(buf, ipaddr.version, 0, 0, ipaddr.packed) + */ + __pyx_t_6 = __pyx_f_7asyncpg_8protocol_8protocol_cidr_encode(__pyx_v_settings, __pyx_v_buf, __pyx_v_obj); if (unlikely(!__pyx_t_6)) __PYX_ERR(14, 89, __pyx_L5_except_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + goto __pyx_L4_exception_handled; + } + goto __pyx_L5_except_error; + __pyx_L5_except_error:; + + /* "asyncpg/protocol/codecs/network.pyx":84 + * object ipaddr + * + * try: # <<<<<<<<<<<<<< + * ipaddr = _ipaddr(obj) + * except ValueError: + */ + __Pyx_PyThreadState_assign + __Pyx_XGIVEREF(__pyx_t_1); + __Pyx_XGIVEREF(__pyx_t_2); + __Pyx_XGIVEREF(__pyx_t_3); + __Pyx_ExceptionReset(__pyx_t_1, __pyx_t_2, __pyx_t_3); + goto __pyx_L1_error; + __pyx_L4_exception_handled:; + __Pyx_PyThreadState_assign + __Pyx_XGIVEREF(__pyx_t_1); + __Pyx_XGIVEREF(__pyx_t_2); + __Pyx_XGIVEREF(__pyx_t_3); + __Pyx_ExceptionReset(__pyx_t_1, __pyx_t_2, __pyx_t_3); + __pyx_L10_try_end:; + } + + /* "asyncpg/protocol/codecs/network.pyx":80 + * + * + * cdef inet_encode(ConnectionSettings settings, WriteBuffer buf, obj): # <<<<<<<<<<<<<< + * cdef: + * object ipaddr + */ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_4); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_XDECREF(__pyx_t_6); + __Pyx_XDECREF(__pyx_t_7); + __Pyx_AddTraceback("asyncpg.protocol.protocol.inet_encode", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XDECREF(__pyx_v_ipaddr); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "asyncpg/protocol/codecs/network.pyx":94 + * + * + * cdef init_network_codecs(): # <<<<<<<<<<<<<< + * register_core_codec(CIDROID, + * &cidr_encode, + */ + +static PyObject *__pyx_f_7asyncpg_8protocol_8protocol_init_network_codecs(void) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + __Pyx_RefNannySetupContext("init_network_codecs", 0); + + /* "asyncpg/protocol/codecs/network.pyx":95 + * + * cdef init_network_codecs(): + * register_core_codec(CIDROID, # <<<<<<<<<<<<<< + * &cidr_encode, + * &net_decode, + */ + __pyx_t_1 = __pyx_f_7asyncpg_8protocol_8protocol_register_core_codec(0x28A, ((__pyx_t_7asyncpg_8protocol_8protocol_encode_func)(&__pyx_f_7asyncpg_8protocol_8protocol_cidr_encode)), ((__pyx_t_7asyncpg_8protocol_8protocol_decode_func)(&__pyx_f_7asyncpg_8protocol_8protocol_net_decode)), __pyx_e_7asyncpg_8protocol_8protocol_PG_FORMAT_BINARY); if (unlikely(!__pyx_t_1)) __PYX_ERR(14, 95, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "asyncpg/protocol/codecs/network.pyx":100 + * PG_FORMAT_BINARY) + * + * register_core_codec(INETOID, # <<<<<<<<<<<<<< + * &inet_encode, + * &net_decode, + */ + __pyx_t_1 = __pyx_f_7asyncpg_8protocol_8protocol_register_core_codec(0x365, ((__pyx_t_7asyncpg_8protocol_8protocol_encode_func)(&__pyx_f_7asyncpg_8protocol_8protocol_inet_encode)), ((__pyx_t_7asyncpg_8protocol_8protocol_decode_func)(&__pyx_f_7asyncpg_8protocol_8protocol_net_decode)), __pyx_e_7asyncpg_8protocol_8protocol_PG_FORMAT_BINARY); if (unlikely(!__pyx_t_1)) __PYX_ERR(14, 100, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "asyncpg/protocol/codecs/network.pyx":105 + * PG_FORMAT_BINARY) + * + * register_core_codec(MACADDROID, # <<<<<<<<<<<<<< + * &text_encode, + * &text_decode, + */ + __pyx_t_1 = __pyx_f_7asyncpg_8protocol_8protocol_register_core_codec(0x33D, ((__pyx_t_7asyncpg_8protocol_8protocol_encode_func)(&__pyx_f_7asyncpg_8protocol_8protocol_text_encode)), ((__pyx_t_7asyncpg_8protocol_8protocol_decode_func)(&__pyx_f_7asyncpg_8protocol_8protocol_text_decode)), __pyx_e_7asyncpg_8protocol_8protocol_PG_FORMAT_TEXT); if (unlikely(!__pyx_t_1)) __PYX_ERR(14, 105, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "asyncpg/protocol/codecs/network.pyx":94 + * + * + * cdef init_network_codecs(): # <<<<<<<<<<<<<< + * register_core_codec(CIDROID, + * &cidr_encode, + */ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("asyncpg.protocol.protocol.init_network_codecs", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "asyncpg/protocol/codecs/numeric.pyx":14 + * + * + * cdef numeric_encode(ConnectionSettings settings, WriteBuffer buf, obj): # <<<<<<<<<<<<<< + * text_encode(settings, buf, str(obj)) + * + */ + +static PyObject *__pyx_f_7asyncpg_8protocol_8protocol_numeric_encode(struct __pyx_obj_7asyncpg_8protocol_8protocol_ConnectionSettings *__pyx_v_settings, struct __pyx_obj_7asyncpg_8protocol_8protocol_WriteBuffer *__pyx_v_buf, PyObject *__pyx_v_obj) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + __Pyx_RefNannySetupContext("numeric_encode", 0); + + /* "asyncpg/protocol/codecs/numeric.pyx":15 + * + * cdef numeric_encode(ConnectionSettings settings, WriteBuffer buf, obj): + * text_encode(settings, buf, str(obj)) # <<<<<<<<<<<<<< + * + * + */ + __pyx_t_1 = PyTuple_New(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(15, 15, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_INCREF(__pyx_v_obj); + __Pyx_GIVEREF(__pyx_v_obj); + PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_v_obj); + __pyx_t_2 = __Pyx_PyObject_Call(((PyObject *)(&PyUnicode_Type)), __pyx_t_1, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(15, 15, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_1 = __pyx_f_7asyncpg_8protocol_8protocol_text_encode(__pyx_v_settings, __pyx_v_buf, __pyx_t_2); if (unlikely(!__pyx_t_1)) __PYX_ERR(15, 15, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "asyncpg/protocol/codecs/numeric.pyx":14 + * + * + * cdef numeric_encode(ConnectionSettings settings, WriteBuffer buf, obj): # <<<<<<<<<<<<<< + * text_encode(settings, buf, str(obj)) + * + */ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_AddTraceback("asyncpg.protocol.protocol.numeric_encode", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "asyncpg/protocol/codecs/numeric.pyx":18 + * + * + * cdef numeric_decode(ConnectionSettings settings, FastReadBuffer buf): # <<<<<<<<<<<<<< + * return _Dec(text_decode(settings, buf)) + * + */ + +static PyObject *__pyx_f_7asyncpg_8protocol_8protocol_numeric_decode(struct __pyx_obj_7asyncpg_8protocol_8protocol_ConnectionSettings *__pyx_v_settings, struct __pyx_obj_7asyncpg_8protocol_8protocol_FastReadBuffer *__pyx_v_buf) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + PyObject *__pyx_t_5 = NULL; + __Pyx_RefNannySetupContext("numeric_decode", 0); + + /* "asyncpg/protocol/codecs/numeric.pyx":19 + * + * cdef numeric_decode(ConnectionSettings settings, FastReadBuffer buf): + * return _Dec(text_decode(settings, buf)) # <<<<<<<<<<<<<< + * + * + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_2 = __Pyx_GetModuleGlobalName(__pyx_n_s_Dec); if (unlikely(!__pyx_t_2)) __PYX_ERR(15, 19, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = __pyx_f_7asyncpg_8protocol_8protocol_text_decode(__pyx_v_settings, __pyx_v_buf); if (unlikely(!__pyx_t_3)) __PYX_ERR(15, 19, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = NULL; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_4)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_4); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + } + } + if (!__pyx_t_4) { + __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_3); if (unlikely(!__pyx_t_1)) __PYX_ERR(15, 19, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_GOTREF(__pyx_t_1); + } else { + #if CYTHON_FAST_PYCALL + if (PyFunction_Check(__pyx_t_2)) { + PyObject *__pyx_temp[2] = {__pyx_t_4, __pyx_t_3}; + __pyx_t_1 = __Pyx_PyFunction_FastCall(__pyx_t_2, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_1)) __PYX_ERR(15, 19, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + } else + #endif + #if CYTHON_FAST_PYCCALL + if (__Pyx_PyFastCFunction_Check(__pyx_t_2)) { + PyObject *__pyx_temp[2] = {__pyx_t_4, __pyx_t_3}; + __pyx_t_1 = __Pyx_PyCFunction_FastCall(__pyx_t_2, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_1)) __PYX_ERR(15, 19, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + } else + #endif + { + __pyx_t_5 = PyTuple_New(1+1); if (unlikely(!__pyx_t_5)) __PYX_ERR(15, 19, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_GIVEREF(__pyx_t_4); PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_t_4); __pyx_t_4 = NULL; + __Pyx_GIVEREF(__pyx_t_3); + PyTuple_SET_ITEM(__pyx_t_5, 0+1, __pyx_t_3); + __pyx_t_3 = 0; + __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_t_5, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(15, 19, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + } + } + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "asyncpg/protocol/codecs/numeric.pyx":18 + * + * + * cdef numeric_decode(ConnectionSettings settings, FastReadBuffer buf): # <<<<<<<<<<<<<< + * return _Dec(text_decode(settings, buf)) + * + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_AddTraceback("asyncpg.protocol.protocol.numeric_decode", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "asyncpg/protocol/codecs/numeric.pyx":22 + * + * + * cdef init_numeric_codecs(): # <<<<<<<<<<<<<< + * register_core_codec(NUMERICOID, + * &numeric_encode, + */ + +static PyObject *__pyx_f_7asyncpg_8protocol_8protocol_init_numeric_codecs(void) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + __Pyx_RefNannySetupContext("init_numeric_codecs", 0); + + /* "asyncpg/protocol/codecs/numeric.pyx":23 + * + * cdef init_numeric_codecs(): + * register_core_codec(NUMERICOID, # <<<<<<<<<<<<<< + * &numeric_encode, + * &numeric_decode, + */ + __pyx_t_1 = __pyx_f_7asyncpg_8protocol_8protocol_register_core_codec(0x6A4, ((__pyx_t_7asyncpg_8protocol_8protocol_encode_func)(&__pyx_f_7asyncpg_8protocol_8protocol_numeric_encode)), ((__pyx_t_7asyncpg_8protocol_8protocol_decode_func)(&__pyx_f_7asyncpg_8protocol_8protocol_numeric_decode)), __pyx_e_7asyncpg_8protocol_8protocol_PG_FORMAT_TEXT); if (unlikely(!__pyx_t_1)) __PYX_ERR(15, 23, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "asyncpg/protocol/codecs/numeric.pyx":22 + * + * + * cdef init_numeric_codecs(): # <<<<<<<<<<<<<< + * register_core_codec(NUMERICOID, + * &numeric_encode, + */ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("asyncpg.protocol.protocol.init_numeric_codecs", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "asyncpg/protocol/codecs/tsearch.pyx":8 + * + * + * cdef init_tsearch_codecs(): # <<<<<<<<<<<<<< + * ts_oids = [ + * TSQUERYOID, + */ + +static PyObject *__pyx_f_7asyncpg_8protocol_8protocol_init_tsearch_codecs(void) { + PyObject *__pyx_v_ts_oids = NULL; + PyObject *__pyx_v_oid = NULL; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + Py_ssize_t __pyx_t_2; + PyObject *__pyx_t_3 = NULL; + uint32_t __pyx_t_4; + __Pyx_RefNannySetupContext("init_tsearch_codecs", 0); + + /* "asyncpg/protocol/codecs/tsearch.pyx":9 + * + * cdef init_tsearch_codecs(): + * ts_oids = [ # <<<<<<<<<<<<<< + * TSQUERYOID, + * TSVECTOROID, + */ + __pyx_t_1 = PyList_New(2); if (unlikely(!__pyx_t_1)) __PYX_ERR(16, 9, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_INCREF(__pyx_int_3615); + __Pyx_GIVEREF(__pyx_int_3615); + PyList_SET_ITEM(__pyx_t_1, 0, __pyx_int_3615); + __Pyx_INCREF(__pyx_int_3614); + __Pyx_GIVEREF(__pyx_int_3614); + PyList_SET_ITEM(__pyx_t_1, 1, __pyx_int_3614); + __pyx_v_ts_oids = ((PyObject*)__pyx_t_1); + __pyx_t_1 = 0; + + /* "asyncpg/protocol/codecs/tsearch.pyx":14 + * ] + * + * for oid in ts_oids: # <<<<<<<<<<<<<< + * register_core_codec(oid, + * &text_encode, + */ + __pyx_t_1 = __pyx_v_ts_oids; __Pyx_INCREF(__pyx_t_1); __pyx_t_2 = 0; + for (;;) { + if (__pyx_t_2 >= PyList_GET_SIZE(__pyx_t_1)) break; + #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + __pyx_t_3 = PyList_GET_ITEM(__pyx_t_1, __pyx_t_2); __Pyx_INCREF(__pyx_t_3); __pyx_t_2++; if (unlikely(0 < 0)) __PYX_ERR(16, 14, __pyx_L1_error) + #else + __pyx_t_3 = PySequence_ITEM(__pyx_t_1, __pyx_t_2); __pyx_t_2++; if (unlikely(!__pyx_t_3)) __PYX_ERR(16, 14, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + #endif + __Pyx_XDECREF_SET(__pyx_v_oid, __pyx_t_3); + __pyx_t_3 = 0; + + /* "asyncpg/protocol/codecs/tsearch.pyx":15 + * + * for oid in ts_oids: + * register_core_codec(oid, # <<<<<<<<<<<<<< + * &text_encode, + * &text_decode, + */ + __pyx_t_4 = __Pyx_PyInt_As_uint32_t(__pyx_v_oid); if (unlikely((__pyx_t_4 == ((uint32_t)-1)) && PyErr_Occurred())) __PYX_ERR(16, 15, __pyx_L1_error) + + /* "asyncpg/protocol/codecs/tsearch.pyx":18 + * &text_encode, + * &text_decode, + * PG_FORMAT_TEXT) # <<<<<<<<<<<<<< + * + * register_core_codec(GTSVECTOROID, + */ + __pyx_t_3 = __pyx_f_7asyncpg_8protocol_8protocol_register_core_codec(__pyx_t_4, ((__pyx_t_7asyncpg_8protocol_8protocol_encode_func)(&__pyx_f_7asyncpg_8protocol_8protocol_text_encode)), ((__pyx_t_7asyncpg_8protocol_8protocol_decode_func)(&__pyx_f_7asyncpg_8protocol_8protocol_text_decode)), __pyx_e_7asyncpg_8protocol_8protocol_PG_FORMAT_TEXT); if (unlikely(!__pyx_t_3)) __PYX_ERR(16, 15, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + + /* "asyncpg/protocol/codecs/tsearch.pyx":14 + * ] + * + * for oid in ts_oids: # <<<<<<<<<<<<<< + * register_core_codec(oid, + * &text_encode, + */ + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "asyncpg/protocol/codecs/tsearch.pyx":20 + * PG_FORMAT_TEXT) + * + * register_core_codec(GTSVECTOROID, # <<<<<<<<<<<<<< + * NULL, + * &text_decode, + */ + __pyx_t_1 = __pyx_f_7asyncpg_8protocol_8protocol_register_core_codec(0xE3A, NULL, ((__pyx_t_7asyncpg_8protocol_8protocol_decode_func)(&__pyx_f_7asyncpg_8protocol_8protocol_text_decode)), __pyx_e_7asyncpg_8protocol_8protocol_PG_FORMAT_TEXT); if (unlikely(!__pyx_t_1)) __PYX_ERR(16, 20, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "asyncpg/protocol/codecs/tsearch.pyx":8 + * + * + * cdef init_tsearch_codecs(): # <<<<<<<<<<<<<< + * ts_oids = [ + * TSQUERYOID, + */ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_AddTraceback("asyncpg.protocol.protocol.init_tsearch_codecs", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XDECREF(__pyx_v_ts_oids); + __Pyx_XDECREF(__pyx_v_oid); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "asyncpg/protocol/codecs/txid.pyx":8 + * + * + * cdef txid_snapshot_encode(ConnectionSettings settings, WriteBuffer buf, obj): # <<<<<<<<<<<<<< + * cdef: + * ssize_t nxip + */ + +static PyObject *__pyx_f_7asyncpg_8protocol_8protocol_txid_snapshot_encode(CYTHON_UNUSED struct __pyx_obj_7asyncpg_8protocol_8protocol_ConnectionSettings *__pyx_v_settings, struct __pyx_obj_7asyncpg_8protocol_8protocol_WriteBuffer *__pyx_v_buf, PyObject *__pyx_v_obj) { + Py_ssize_t __pyx_v_nxip; + CYTHON_UNUSED int64_t __pyx_v_xmin; + CYTHON_UNUSED int64_t __pyx_v_xmax; + int __pyx_v_i; + struct __pyx_obj_7asyncpg_8protocol_8protocol_WriteBuffer *__pyx_v_xip_buf = 0; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_t_2; + int __pyx_t_3; + PyObject *__pyx_t_4 = NULL; + PyObject *__pyx_t_5 = NULL; + PyObject *__pyx_t_6 = NULL; + Py_ssize_t __pyx_t_7; + int64_t __pyx_t_8; + Py_ssize_t __pyx_t_9; + int __pyx_t_10; + int32_t __pyx_t_11; + __Pyx_RefNannySetupContext("txid_snapshot_encode", 0); + + /* "asyncpg/protocol/codecs/txid.pyx":14 + * int64_t xmax + * int i + * WriteBuffer xip_buf = WriteBuffer.new() # <<<<<<<<<<<<<< + * + * if not (cpython.PyTuple_Check(obj) or cpython.PyList_Check(obj)): + */ + __pyx_t_1 = ((PyObject *)__pyx_f_7asyncpg_8protocol_8protocol_11WriteBuffer_new()); if (unlikely(!__pyx_t_1)) __PYX_ERR(17, 14, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_v_xip_buf = ((struct __pyx_obj_7asyncpg_8protocol_8protocol_WriteBuffer *)__pyx_t_1); + __pyx_t_1 = 0; + + /* "asyncpg/protocol/codecs/txid.pyx":16 + * WriteBuffer xip_buf = WriteBuffer.new() + * + * if not (cpython.PyTuple_Check(obj) or cpython.PyList_Check(obj)): # <<<<<<<<<<<<<< + * raise TypeError( + * 'list or tuple expected (got type {})'.format(type(obj))) + */ + __pyx_t_3 = (PyTuple_Check(__pyx_v_obj) != 0); + if (!__pyx_t_3) { + } else { + __pyx_t_2 = __pyx_t_3; + goto __pyx_L4_bool_binop_done; + } + __pyx_t_3 = (PyList_Check(__pyx_v_obj) != 0); + __pyx_t_2 = __pyx_t_3; + __pyx_L4_bool_binop_done:; + __pyx_t_3 = ((!__pyx_t_2) != 0); + if (__pyx_t_3) { + + /* "asyncpg/protocol/codecs/txid.pyx":18 + * if not (cpython.PyTuple_Check(obj) or cpython.PyList_Check(obj)): + * raise TypeError( + * 'list or tuple expected (got type {})'.format(type(obj))) # <<<<<<<<<<<<<< + * + * if len(obj) != 3: + */ + __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_kp_u_list_or_tuple_expected_got_type, __pyx_n_s_format); if (unlikely(!__pyx_t_4)) __PYX_ERR(17, 18, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_5 = NULL; + if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_4))) { + __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_4); + if (likely(__pyx_t_5)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4); + __Pyx_INCREF(__pyx_t_5); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_4, function); + } + } + if (!__pyx_t_5) { + __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_t_4, ((PyObject *)Py_TYPE(__pyx_v_obj))); if (unlikely(!__pyx_t_1)) __PYX_ERR(17, 18, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + } else { + #if CYTHON_FAST_PYCALL + if (PyFunction_Check(__pyx_t_4)) { + PyObject *__pyx_temp[2] = {__pyx_t_5, ((PyObject *)Py_TYPE(__pyx_v_obj))}; + __pyx_t_1 = __Pyx_PyFunction_FastCall(__pyx_t_4, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_1)) __PYX_ERR(17, 18, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_GOTREF(__pyx_t_1); + } else + #endif + #if CYTHON_FAST_PYCCALL + if (__Pyx_PyFastCFunction_Check(__pyx_t_4)) { + PyObject *__pyx_temp[2] = {__pyx_t_5, ((PyObject *)Py_TYPE(__pyx_v_obj))}; + __pyx_t_1 = __Pyx_PyCFunction_FastCall(__pyx_t_4, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_1)) __PYX_ERR(17, 18, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_GOTREF(__pyx_t_1); + } else + #endif + { + __pyx_t_6 = PyTuple_New(1+1); if (unlikely(!__pyx_t_6)) __PYX_ERR(17, 18, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_GIVEREF(__pyx_t_5); PyTuple_SET_ITEM(__pyx_t_6, 0, __pyx_t_5); __pyx_t_5 = NULL; + __Pyx_INCREF(((PyObject *)Py_TYPE(__pyx_v_obj))); + __Pyx_GIVEREF(((PyObject *)Py_TYPE(__pyx_v_obj))); + PyTuple_SET_ITEM(__pyx_t_6, 0+1, ((PyObject *)Py_TYPE(__pyx_v_obj))); + __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_4, __pyx_t_6, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(17, 18, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + } + } + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + + /* "asyncpg/protocol/codecs/txid.pyx":17 + * + * if not (cpython.PyTuple_Check(obj) or cpython.PyList_Check(obj)): + * raise TypeError( # <<<<<<<<<<<<<< + * 'list or tuple expected (got type {})'.format(type(obj))) + * + */ + __pyx_t_4 = PyTuple_New(1); if (unlikely(!__pyx_t_4)) __PYX_ERR(17, 17, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_GIVEREF(__pyx_t_1); + PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_1); + __pyx_t_1 = 0; + __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_t_4, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(17, 17, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_Raise(__pyx_t_1, 0, 0, 0); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __PYX_ERR(17, 17, __pyx_L1_error) + + /* "asyncpg/protocol/codecs/txid.pyx":16 + * WriteBuffer xip_buf = WriteBuffer.new() + * + * if not (cpython.PyTuple_Check(obj) or cpython.PyList_Check(obj)): # <<<<<<<<<<<<<< + * raise TypeError( + * 'list or tuple expected (got type {})'.format(type(obj))) + */ + } + + /* "asyncpg/protocol/codecs/txid.pyx":20 + * 'list or tuple expected (got type {})'.format(type(obj))) + * + * if len(obj) != 3: # <<<<<<<<<<<<<< + * raise ValueError( + * 'invalid number of elements in txid_snapshot tuple, expecting 4') + */ + __pyx_t_7 = PyObject_Length(__pyx_v_obj); if (unlikely(__pyx_t_7 == -1)) __PYX_ERR(17, 20, __pyx_L1_error) + __pyx_t_3 = ((__pyx_t_7 != 3) != 0); + if (__pyx_t_3) { + + /* "asyncpg/protocol/codecs/txid.pyx":21 + * + * if len(obj) != 3: + * raise ValueError( # <<<<<<<<<<<<<< + * 'invalid number of elements in txid_snapshot tuple, expecting 4') + * + */ + __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__37, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(17, 21, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_Raise(__pyx_t_1, 0, 0, 0); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __PYX_ERR(17, 21, __pyx_L1_error) + + /* "asyncpg/protocol/codecs/txid.pyx":20 + * 'list or tuple expected (got type {})'.format(type(obj))) + * + * if len(obj) != 3: # <<<<<<<<<<<<<< + * raise ValueError( + * 'invalid number of elements in txid_snapshot tuple, expecting 4') + */ + } + + /* "asyncpg/protocol/codecs/txid.pyx":24 + * 'invalid number of elements in txid_snapshot tuple, expecting 4') + * + * nxip = len(obj[2]) # <<<<<<<<<<<<<< + * if nxip > _MAXINT32: + * raise ValueError('txid_snapshot value is too long') + */ + __pyx_t_1 = __Pyx_GetItemInt(__pyx_v_obj, 2, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_1)) __PYX_ERR(17, 24, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_7 = PyObject_Length(__pyx_t_1); if (unlikely(__pyx_t_7 == -1)) __PYX_ERR(17, 24, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_v_nxip = __pyx_t_7; + + /* "asyncpg/protocol/codecs/txid.pyx":25 + * + * nxip = len(obj[2]) + * if nxip > _MAXINT32: # <<<<<<<<<<<<<< + * raise ValueError('txid_snapshot value is too long') + * + */ + __pyx_t_3 = ((__pyx_v_nxip > 0x7FFFFFFF) != 0); + if (__pyx_t_3) { + + /* "asyncpg/protocol/codecs/txid.pyx":26 + * nxip = len(obj[2]) + * if nxip > _MAXINT32: + * raise ValueError('txid_snapshot value is too long') # <<<<<<<<<<<<<< + * + * xmin = obj[0] + */ + __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__38, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(17, 26, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_Raise(__pyx_t_1, 0, 0, 0); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __PYX_ERR(17, 26, __pyx_L1_error) + + /* "asyncpg/protocol/codecs/txid.pyx":25 + * + * nxip = len(obj[2]) + * if nxip > _MAXINT32: # <<<<<<<<<<<<<< + * raise ValueError('txid_snapshot value is too long') + * + */ + } + + /* "asyncpg/protocol/codecs/txid.pyx":28 + * raise ValueError('txid_snapshot value is too long') + * + * xmin = obj[0] # <<<<<<<<<<<<<< + * xmax = obj[1] + * + */ + __pyx_t_1 = __Pyx_GetItemInt(__pyx_v_obj, 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_1)) __PYX_ERR(17, 28, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_8 = __Pyx_PyInt_As_int64_t(__pyx_t_1); if (unlikely((__pyx_t_8 == ((int64_t)-1)) && PyErr_Occurred())) __PYX_ERR(17, 28, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_v_xmin = __pyx_t_8; + + /* "asyncpg/protocol/codecs/txid.pyx":29 + * + * xmin = obj[0] + * xmax = obj[1] # <<<<<<<<<<<<<< + * + * for i in range(nxip): + */ + __pyx_t_1 = __Pyx_GetItemInt(__pyx_v_obj, 1, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_1)) __PYX_ERR(17, 29, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_8 = __Pyx_PyInt_As_int64_t(__pyx_t_1); if (unlikely((__pyx_t_8 == ((int64_t)-1)) && PyErr_Occurred())) __PYX_ERR(17, 29, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_v_xmax = __pyx_t_8; + + /* "asyncpg/protocol/codecs/txid.pyx":31 + * xmax = obj[1] + * + * for i in range(nxip): # <<<<<<<<<<<<<< + * xip_buf.write_int64(obj[2][i]) + * + */ + __pyx_t_9 = __pyx_v_nxip; + for (__pyx_t_10 = 0; __pyx_t_10 < __pyx_t_9; __pyx_t_10+=1) { + __pyx_v_i = __pyx_t_10; + + /* "asyncpg/protocol/codecs/txid.pyx":32 + * + * for i in range(nxip): + * xip_buf.write_int64(obj[2][i]) # <<<<<<<<<<<<<< + * + * buf.write_int32(20 + xip_buf.len()) + */ + __pyx_t_1 = __Pyx_GetItemInt(__pyx_v_obj, 2, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_1)) __PYX_ERR(17, 32, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_4 = __Pyx_GetItemInt(__pyx_t_1, __pyx_v_i, int, 1, __Pyx_PyInt_From_int, 0, 1, 1); if (unlikely(!__pyx_t_4)) __PYX_ERR(17, 32, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_8 = __Pyx_PyInt_As_int64_t(__pyx_t_4); if (unlikely((__pyx_t_8 == ((int64_t)-1)) && PyErr_Occurred())) __PYX_ERR(17, 32, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_4 = __pyx_f_7asyncpg_8protocol_8protocol_11WriteBuffer_write_int64(__pyx_v_xip_buf, __pyx_t_8); if (unlikely(!__pyx_t_4)) __PYX_ERR(17, 32, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + } + + /* "asyncpg/protocol/codecs/txid.pyx":34 + * xip_buf.write_int64(obj[2][i]) + * + * buf.write_int32(20 + xip_buf.len()) # <<<<<<<<<<<<<< + * + * buf.write_int32(nxip) + */ + __pyx_t_4 = __pyx_f_7asyncpg_8protocol_8protocol_11WriteBuffer_len(__pyx_v_xip_buf); if (unlikely(!__pyx_t_4)) __PYX_ERR(17, 34, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_1 = __Pyx_PyInt_AddCObj(__pyx_int_20, __pyx_t_4, 20, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(17, 34, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_11 = __Pyx_PyInt_As_int32_t(__pyx_t_1); if (unlikely((__pyx_t_11 == ((int32_t)-1)) && PyErr_Occurred())) __PYX_ERR(17, 34, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_1 = __pyx_f_7asyncpg_8protocol_8protocol_11WriteBuffer_write_int32(__pyx_v_buf, __pyx_t_11); if (unlikely(!__pyx_t_1)) __PYX_ERR(17, 34, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "asyncpg/protocol/codecs/txid.pyx":36 + * buf.write_int32(20 + xip_buf.len()) + * + * buf.write_int32(nxip) # <<<<<<<<<<<<<< + * buf.write_int64(obj[0]) + * buf.write_int64(obj[1]) + */ + __pyx_t_1 = __pyx_f_7asyncpg_8protocol_8protocol_11WriteBuffer_write_int32(__pyx_v_buf, ((int32_t)__pyx_v_nxip)); if (unlikely(!__pyx_t_1)) __PYX_ERR(17, 36, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "asyncpg/protocol/codecs/txid.pyx":37 + * + * buf.write_int32(nxip) + * buf.write_int64(obj[0]) # <<<<<<<<<<<<<< + * buf.write_int64(obj[1]) + * buf.write_buffer(xip_buf) + */ + __pyx_t_1 = __Pyx_GetItemInt(__pyx_v_obj, 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_1)) __PYX_ERR(17, 37, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_8 = __Pyx_PyInt_As_int64_t(__pyx_t_1); if (unlikely((__pyx_t_8 == ((int64_t)-1)) && PyErr_Occurred())) __PYX_ERR(17, 37, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_1 = __pyx_f_7asyncpg_8protocol_8protocol_11WriteBuffer_write_int64(__pyx_v_buf, __pyx_t_8); if (unlikely(!__pyx_t_1)) __PYX_ERR(17, 37, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "asyncpg/protocol/codecs/txid.pyx":38 + * buf.write_int32(nxip) + * buf.write_int64(obj[0]) + * buf.write_int64(obj[1]) # <<<<<<<<<<<<<< + * buf.write_buffer(xip_buf) + * + */ + __pyx_t_1 = __Pyx_GetItemInt(__pyx_v_obj, 1, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_1)) __PYX_ERR(17, 38, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_8 = __Pyx_PyInt_As_int64_t(__pyx_t_1); if (unlikely((__pyx_t_8 == ((int64_t)-1)) && PyErr_Occurred())) __PYX_ERR(17, 38, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_1 = __pyx_f_7asyncpg_8protocol_8protocol_11WriteBuffer_write_int64(__pyx_v_buf, __pyx_t_8); if (unlikely(!__pyx_t_1)) __PYX_ERR(17, 38, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "asyncpg/protocol/codecs/txid.pyx":39 + * buf.write_int64(obj[0]) + * buf.write_int64(obj[1]) + * buf.write_buffer(xip_buf) # <<<<<<<<<<<<<< + * + * + */ + __pyx_t_1 = __pyx_f_7asyncpg_8protocol_8protocol_11WriteBuffer_write_buffer(__pyx_v_buf, __pyx_v_xip_buf); if (unlikely(!__pyx_t_1)) __PYX_ERR(17, 39, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "asyncpg/protocol/codecs/txid.pyx":8 + * + * + * cdef txid_snapshot_encode(ConnectionSettings settings, WriteBuffer buf, obj): # <<<<<<<<<<<<<< + * cdef: + * ssize_t nxip + */ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_XDECREF(__pyx_t_6); + __Pyx_AddTraceback("asyncpg.protocol.protocol.txid_snapshot_encode", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XDECREF((PyObject *)__pyx_v_xip_buf); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "asyncpg/protocol/codecs/txid.pyx":42 + * + * + * cdef txid_snapshot_decode(ConnectionSettings settings, FastReadBuffer buf): # <<<<<<<<<<<<<< + * cdef: + * int32_t nxip + */ + +static PyObject *__pyx_f_7asyncpg_8protocol_8protocol_txid_snapshot_decode(CYTHON_UNUSED struct __pyx_obj_7asyncpg_8protocol_8protocol_ConnectionSettings *__pyx_v_settings, struct __pyx_obj_7asyncpg_8protocol_8protocol_FastReadBuffer *__pyx_v_buf) { + int32_t __pyx_v_nxip; + int64_t __pyx_v_xmin; + int64_t __pyx_v_xmax; + PyObject *__pyx_v_xip_tup = 0; + int32_t __pyx_v_i; + PyObject *__pyx_v_xip = 0; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + char const *__pyx_t_1; + PyObject *__pyx_t_2 = NULL; + int32_t __pyx_t_3; + int32_t __pyx_t_4; + PyObject *__pyx_t_5 = NULL; + PyObject *__pyx_t_6 = NULL; + __Pyx_RefNannySetupContext("txid_snapshot_decode", 0); + + /* "asyncpg/protocol/codecs/txid.pyx":51 + * object xip + * + * nxip = hton.unpack_int32(buf.read(4)) # <<<<<<<<<<<<<< + * xmin = hton.unpack_int64(buf.read(8)) + * xmax = hton.unpack_int64(buf.read(8)) + */ + __pyx_t_1 = __pyx_f_7asyncpg_8protocol_8protocol_14FastReadBuffer_read(__pyx_v_buf, 4); if (unlikely(__pyx_t_1 == NULL)) __PYX_ERR(17, 51, __pyx_L1_error) + __pyx_v_nxip = __pyx_f_7asyncpg_8protocol_4hton_unpack_int32(__pyx_t_1); + + /* "asyncpg/protocol/codecs/txid.pyx":52 + * + * nxip = hton.unpack_int32(buf.read(4)) + * xmin = hton.unpack_int64(buf.read(8)) # <<<<<<<<<<<<<< + * xmax = hton.unpack_int64(buf.read(8)) + * + */ + __pyx_t_1 = __pyx_f_7asyncpg_8protocol_8protocol_14FastReadBuffer_read(__pyx_v_buf, 8); if (unlikely(__pyx_t_1 == NULL)) __PYX_ERR(17, 52, __pyx_L1_error) + __pyx_v_xmin = __pyx_f_7asyncpg_8protocol_4hton_unpack_int64(__pyx_t_1); + + /* "asyncpg/protocol/codecs/txid.pyx":53 + * nxip = hton.unpack_int32(buf.read(4)) + * xmin = hton.unpack_int64(buf.read(8)) + * xmax = hton.unpack_int64(buf.read(8)) # <<<<<<<<<<<<<< + * + * xip_tup = cpython.PyTuple_New(nxip) + */ + __pyx_t_1 = __pyx_f_7asyncpg_8protocol_8protocol_14FastReadBuffer_read(__pyx_v_buf, 8); if (unlikely(__pyx_t_1 == NULL)) __PYX_ERR(17, 53, __pyx_L1_error) + __pyx_v_xmax = __pyx_f_7asyncpg_8protocol_4hton_unpack_int64(__pyx_t_1); + + /* "asyncpg/protocol/codecs/txid.pyx":55 + * xmax = hton.unpack_int64(buf.read(8)) + * + * xip_tup = cpython.PyTuple_New(nxip) # <<<<<<<<<<<<<< + * for i in range(nxip): + * xip = cpython.PyLong_FromLongLong(hton.unpack_int64(buf.read(8))) + */ + __pyx_t_2 = PyTuple_New(__pyx_v_nxip); if (unlikely(!__pyx_t_2)) __PYX_ERR(17, 55, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_v_xip_tup = ((PyObject*)__pyx_t_2); + __pyx_t_2 = 0; + + /* "asyncpg/protocol/codecs/txid.pyx":56 + * + * xip_tup = cpython.PyTuple_New(nxip) + * for i in range(nxip): # <<<<<<<<<<<<<< + * xip = cpython.PyLong_FromLongLong(hton.unpack_int64(buf.read(8))) + * cpython.Py_INCREF(xip) + */ + __pyx_t_3 = __pyx_v_nxip; + for (__pyx_t_4 = 0; __pyx_t_4 < __pyx_t_3; __pyx_t_4+=1) { + __pyx_v_i = __pyx_t_4; + + /* "asyncpg/protocol/codecs/txid.pyx":57 + * xip_tup = cpython.PyTuple_New(nxip) + * for i in range(nxip): + * xip = cpython.PyLong_FromLongLong(hton.unpack_int64(buf.read(8))) # <<<<<<<<<<<<<< + * cpython.Py_INCREF(xip) + * cpython.PyTuple_SET_ITEM(xip_tup, i, xip) + */ + __pyx_t_1 = __pyx_f_7asyncpg_8protocol_8protocol_14FastReadBuffer_read(__pyx_v_buf, 8); if (unlikely(__pyx_t_1 == NULL)) __PYX_ERR(17, 57, __pyx_L1_error) + __pyx_t_2 = PyLong_FromLongLong(__pyx_f_7asyncpg_8protocol_4hton_unpack_int64(__pyx_t_1)); if (unlikely(!__pyx_t_2)) __PYX_ERR(17, 57, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_XDECREF_SET(__pyx_v_xip, __pyx_t_2); + __pyx_t_2 = 0; + + /* "asyncpg/protocol/codecs/txid.pyx":58 + * for i in range(nxip): + * xip = cpython.PyLong_FromLongLong(hton.unpack_int64(buf.read(8))) + * cpython.Py_INCREF(xip) # <<<<<<<<<<<<<< + * cpython.PyTuple_SET_ITEM(xip_tup, i, xip) + * + */ + Py_INCREF(__pyx_v_xip); + + /* "asyncpg/protocol/codecs/txid.pyx":59 + * xip = cpython.PyLong_FromLongLong(hton.unpack_int64(buf.read(8))) + * cpython.Py_INCREF(xip) + * cpython.PyTuple_SET_ITEM(xip_tup, i, xip) # <<<<<<<<<<<<<< + * + * return (xmin, xmax, xip_tup) + */ + PyTuple_SET_ITEM(__pyx_v_xip_tup, __pyx_v_i, __pyx_v_xip); + } + + /* "asyncpg/protocol/codecs/txid.pyx":61 + * cpython.PyTuple_SET_ITEM(xip_tup, i, xip) + * + * return (xmin, xmax, xip_tup) # <<<<<<<<<<<<<< + * + * + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_2 = __Pyx_PyInt_From_int64_t(__pyx_v_xmin); if (unlikely(!__pyx_t_2)) __PYX_ERR(17, 61, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_5 = __Pyx_PyInt_From_int64_t(__pyx_v_xmax); if (unlikely(!__pyx_t_5)) __PYX_ERR(17, 61, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_6 = PyTuple_New(3); if (unlikely(!__pyx_t_6)) __PYX_ERR(17, 61, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_GIVEREF(__pyx_t_2); + PyTuple_SET_ITEM(__pyx_t_6, 0, __pyx_t_2); + __Pyx_GIVEREF(__pyx_t_5); + PyTuple_SET_ITEM(__pyx_t_6, 1, __pyx_t_5); + __Pyx_INCREF(__pyx_v_xip_tup); + __Pyx_GIVEREF(__pyx_v_xip_tup); + PyTuple_SET_ITEM(__pyx_t_6, 2, __pyx_v_xip_tup); + __pyx_t_2 = 0; + __pyx_t_5 = 0; + __pyx_r = __pyx_t_6; + __pyx_t_6 = 0; + goto __pyx_L0; + + /* "asyncpg/protocol/codecs/txid.pyx":42 + * + * + * cdef txid_snapshot_decode(ConnectionSettings settings, FastReadBuffer buf): # <<<<<<<<<<<<<< + * cdef: + * int32_t nxip + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_XDECREF(__pyx_t_6); + __Pyx_AddTraceback("asyncpg.protocol.protocol.txid_snapshot_decode", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XDECREF(__pyx_v_xip_tup); + __Pyx_XDECREF(__pyx_v_xip); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "asyncpg/protocol/codecs/txid.pyx":64 + * + * + * cdef init_txid_codecs(): # <<<<<<<<<<<<<< + * register_core_codec(TXID_SNAPSHOTOID, + * &txid_snapshot_encode, + */ + +static PyObject *__pyx_f_7asyncpg_8protocol_8protocol_init_txid_codecs(void) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + __Pyx_RefNannySetupContext("init_txid_codecs", 0); + + /* "asyncpg/protocol/codecs/txid.pyx":65 + * + * cdef init_txid_codecs(): + * register_core_codec(TXID_SNAPSHOTOID, # <<<<<<<<<<<<<< + * &txid_snapshot_encode, + * &txid_snapshot_decode, + */ + __pyx_t_1 = __pyx_f_7asyncpg_8protocol_8protocol_register_core_codec(0xB9A, ((__pyx_t_7asyncpg_8protocol_8protocol_encode_func)(&__pyx_f_7asyncpg_8protocol_8protocol_txid_snapshot_encode)), ((__pyx_t_7asyncpg_8protocol_8protocol_decode_func)(&__pyx_f_7asyncpg_8protocol_8protocol_txid_snapshot_decode)), __pyx_e_7asyncpg_8protocol_8protocol_PG_FORMAT_BINARY); if (unlikely(!__pyx_t_1)) __PYX_ERR(17, 65, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "asyncpg/protocol/codecs/txid.pyx":64 + * + * + * cdef init_txid_codecs(): # <<<<<<<<<<<<<< + * register_core_codec(TXID_SNAPSHOTOID, + * &txid_snapshot_encode, + */ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("asyncpg.protocol.protocol.init_txid_codecs", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "asyncpg/protocol/codecs/uuid.pyx":14 + * + * + * cdef uuid_encode(ConnectionSettings settings, WriteBuffer wbuf, obj): # <<<<<<<<<<<<<< + * if cpython.PyUnicode_Check(obj): + * obj = _UUID(obj) + */ + +static PyObject *__pyx_f_7asyncpg_8protocol_8protocol_uuid_encode(struct __pyx_obj_7asyncpg_8protocol_8protocol_ConnectionSettings *__pyx_v_settings, struct __pyx_obj_7asyncpg_8protocol_8protocol_WriteBuffer *__pyx_v_wbuf, PyObject *__pyx_v_obj) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + PyObject *__pyx_t_5 = NULL; + __Pyx_RefNannySetupContext("uuid_encode", 0); + __Pyx_INCREF(__pyx_v_obj); + + /* "asyncpg/protocol/codecs/uuid.pyx":15 + * + * cdef uuid_encode(ConnectionSettings settings, WriteBuffer wbuf, obj): + * if cpython.PyUnicode_Check(obj): # <<<<<<<<<<<<<< + * obj = _UUID(obj) + * + */ + __pyx_t_1 = (PyUnicode_Check(__pyx_v_obj) != 0); + if (__pyx_t_1) { + + /* "asyncpg/protocol/codecs/uuid.pyx":16 + * cdef uuid_encode(ConnectionSettings settings, WriteBuffer wbuf, obj): + * if cpython.PyUnicode_Check(obj): + * obj = _UUID(obj) # <<<<<<<<<<<<<< + * + * bytea_encode(settings, wbuf, obj.bytes) + */ + __pyx_t_3 = __Pyx_GetModuleGlobalName(__pyx_n_s_UUID); if (unlikely(!__pyx_t_3)) __PYX_ERR(18, 16, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = NULL; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_3))) { + __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_3); + if (likely(__pyx_t_4)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); + __Pyx_INCREF(__pyx_t_4); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_3, function); + } + } + if (!__pyx_t_4) { + __pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_v_obj); if (unlikely(!__pyx_t_2)) __PYX_ERR(18, 16, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + } else { + #if CYTHON_FAST_PYCALL + if (PyFunction_Check(__pyx_t_3)) { + PyObject *__pyx_temp[2] = {__pyx_t_4, __pyx_v_obj}; + __pyx_t_2 = __Pyx_PyFunction_FastCall(__pyx_t_3, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_2)) __PYX_ERR(18, 16, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_GOTREF(__pyx_t_2); + } else + #endif + #if CYTHON_FAST_PYCCALL + if (__Pyx_PyFastCFunction_Check(__pyx_t_3)) { + PyObject *__pyx_temp[2] = {__pyx_t_4, __pyx_v_obj}; + __pyx_t_2 = __Pyx_PyCFunction_FastCall(__pyx_t_3, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_2)) __PYX_ERR(18, 16, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_GOTREF(__pyx_t_2); + } else + #endif + { + __pyx_t_5 = PyTuple_New(1+1); if (unlikely(!__pyx_t_5)) __PYX_ERR(18, 16, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_GIVEREF(__pyx_t_4); PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_t_4); __pyx_t_4 = NULL; + __Pyx_INCREF(__pyx_v_obj); + __Pyx_GIVEREF(__pyx_v_obj); + PyTuple_SET_ITEM(__pyx_t_5, 0+1, __pyx_v_obj); + __pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_t_5, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(18, 16, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + } + } + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_DECREF_SET(__pyx_v_obj, __pyx_t_2); + __pyx_t_2 = 0; + + /* "asyncpg/protocol/codecs/uuid.pyx":15 + * + * cdef uuid_encode(ConnectionSettings settings, WriteBuffer wbuf, obj): + * if cpython.PyUnicode_Check(obj): # <<<<<<<<<<<<<< + * obj = _UUID(obj) + * + */ + } + + /* "asyncpg/protocol/codecs/uuid.pyx":18 + * obj = _UUID(obj) + * + * bytea_encode(settings, wbuf, obj.bytes) # <<<<<<<<<<<<<< + * + * + */ + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_obj, __pyx_n_s_bytes); if (unlikely(!__pyx_t_2)) __PYX_ERR(18, 18, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = __pyx_f_7asyncpg_8protocol_8protocol_bytea_encode(__pyx_v_settings, __pyx_v_wbuf, __pyx_t_2); if (unlikely(!__pyx_t_3)) __PYX_ERR(18, 18, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + + /* "asyncpg/protocol/codecs/uuid.pyx":14 + * + * + * cdef uuid_encode(ConnectionSettings settings, WriteBuffer wbuf, obj): # <<<<<<<<<<<<<< + * if cpython.PyUnicode_Check(obj): + * obj = _UUID(obj) + */ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_AddTraceback("asyncpg.protocol.protocol.uuid_encode", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XDECREF(__pyx_v_obj); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "asyncpg/protocol/codecs/uuid.pyx":21 + * + * + * cdef uuid_decode(ConnectionSettings settings, FastReadBuffer buf): # <<<<<<<<<<<<<< + * return _UUID(bytes=bytea_decode(settings, buf)) + * + */ + +static PyObject *__pyx_f_7asyncpg_8protocol_8protocol_uuid_decode(struct __pyx_obj_7asyncpg_8protocol_8protocol_ConnectionSettings *__pyx_v_settings, struct __pyx_obj_7asyncpg_8protocol_8protocol_FastReadBuffer *__pyx_v_buf) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + __Pyx_RefNannySetupContext("uuid_decode", 0); + + /* "asyncpg/protocol/codecs/uuid.pyx":22 + * + * cdef uuid_decode(ConnectionSettings settings, FastReadBuffer buf): + * return _UUID(bytes=bytea_decode(settings, buf)) # <<<<<<<<<<<<<< + * + * + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_GetModuleGlobalName(__pyx_n_s_UUID); if (unlikely(!__pyx_t_1)) __PYX_ERR(18, 22, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = PyDict_New(); if (unlikely(!__pyx_t_2)) __PYX_ERR(18, 22, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = __pyx_f_7asyncpg_8protocol_8protocol_bytea_decode(__pyx_v_settings, __pyx_v_buf); if (unlikely(!__pyx_t_3)) __PYX_ERR(18, 22, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_bytes, __pyx_t_3) < 0) __PYX_ERR(18, 22, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_empty_tuple, __pyx_t_2); if (unlikely(!__pyx_t_3)) __PYX_ERR(18, 22, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_r = __pyx_t_3; + __pyx_t_3 = 0; + goto __pyx_L0; + + /* "asyncpg/protocol/codecs/uuid.pyx":21 + * + * + * cdef uuid_decode(ConnectionSettings settings, FastReadBuffer buf): # <<<<<<<<<<<<<< + * return _UUID(bytes=bytea_decode(settings, buf)) + * + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_AddTraceback("asyncpg.protocol.protocol.uuid_decode", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "asyncpg/protocol/codecs/uuid.pyx":25 + * + * + * cdef init_uuid_codecs(): # <<<<<<<<<<<<<< + * register_core_codec(UUIDOID, + * &uuid_encode, + */ + +static PyObject *__pyx_f_7asyncpg_8protocol_8protocol_init_uuid_codecs(void) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + __Pyx_RefNannySetupContext("init_uuid_codecs", 0); + + /* "asyncpg/protocol/codecs/uuid.pyx":26 + * + * cdef init_uuid_codecs(): + * register_core_codec(UUIDOID, # <<<<<<<<<<<<<< + * &uuid_encode, + * &uuid_decode, + */ + __pyx_t_1 = __pyx_f_7asyncpg_8protocol_8protocol_register_core_codec(0xB86, ((__pyx_t_7asyncpg_8protocol_8protocol_encode_func)(&__pyx_f_7asyncpg_8protocol_8protocol_uuid_encode)), ((__pyx_t_7asyncpg_8protocol_8protocol_decode_func)(&__pyx_f_7asyncpg_8protocol_8protocol_uuid_decode)), __pyx_e_7asyncpg_8protocol_8protocol_PG_FORMAT_BINARY); if (unlikely(!__pyx_t_1)) __PYX_ERR(18, 26, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "asyncpg/protocol/codecs/uuid.pyx":25 + * + * + * cdef init_uuid_codecs(): # <<<<<<<<<<<<<< + * register_core_codec(UUIDOID, + * &uuid_encode, + */ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("asyncpg.protocol.protocol.init_uuid_codecs", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "asyncpg/protocol/codecs/misc.pyx":8 + * + * + * cdef void_encode(ConnectionSettings settings, WriteBuffer buf, obj): # <<<<<<<<<<<<<< + * # Void is zero bytes + * buf.write_int32(0) + */ + +static PyObject *__pyx_f_7asyncpg_8protocol_8protocol_void_encode(CYTHON_UNUSED struct __pyx_obj_7asyncpg_8protocol_8protocol_ConnectionSettings *__pyx_v_settings, struct __pyx_obj_7asyncpg_8protocol_8protocol_WriteBuffer *__pyx_v_buf, CYTHON_UNUSED PyObject *__pyx_v_obj) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + __Pyx_RefNannySetupContext("void_encode", 0); + + /* "asyncpg/protocol/codecs/misc.pyx":10 + * cdef void_encode(ConnectionSettings settings, WriteBuffer buf, obj): + * # Void is zero bytes + * buf.write_int32(0) # <<<<<<<<<<<<<< + * + * + */ + __pyx_t_1 = __pyx_f_7asyncpg_8protocol_8protocol_11WriteBuffer_write_int32(__pyx_v_buf, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(19, 10, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "asyncpg/protocol/codecs/misc.pyx":8 + * + * + * cdef void_encode(ConnectionSettings settings, WriteBuffer buf, obj): # <<<<<<<<<<<<<< + * # Void is zero bytes + * buf.write_int32(0) + */ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("asyncpg.protocol.protocol.void_encode", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "asyncpg/protocol/codecs/misc.pyx":13 + * + * + * cdef void_decode(ConnectionSettings settings, FastReadBuffer buf): # <<<<<<<<<<<<<< + * # Do nothing; void will be passed as NULL so this function + * # will never be called. + */ + +static PyObject *__pyx_f_7asyncpg_8protocol_8protocol_void_decode(CYTHON_UNUSED struct __pyx_obj_7asyncpg_8protocol_8protocol_ConnectionSettings *__pyx_v_settings, CYTHON_UNUSED struct __pyx_obj_7asyncpg_8protocol_8protocol_FastReadBuffer *__pyx_v_buf) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("void_decode", 0); + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "asyncpg/protocol/codecs/misc.pyx":19 + * + * + * cdef init_pseudo_codecs(): # <<<<<<<<<<<<<< + * # Void type is returned by SELECT void_returning_function() + * register_core_codec(VOIDOID, + */ + +static PyObject *__pyx_f_7asyncpg_8protocol_8protocol_init_pseudo_codecs(void) { + PyObject *__pyx_v_oid_types = NULL; + PyObject *__pyx_v_oid_type = NULL; + PyObject *__pyx_v_reg_types = NULL; + PyObject *__pyx_v_reg_type = NULL; + PyObject *__pyx_v_no_io_types = NULL; + PyObject *__pyx_v_no_io_type = NULL; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + Py_ssize_t __pyx_t_2; + PyObject *__pyx_t_3 = NULL; + uint32_t __pyx_t_4; + __Pyx_RefNannySetupContext("init_pseudo_codecs", 0); + + /* "asyncpg/protocol/codecs/misc.pyx":21 + * cdef init_pseudo_codecs(): + * # Void type is returned by SELECT void_returning_function() + * register_core_codec(VOIDOID, # <<<<<<<<<<<<<< + * &void_encode, + * &void_decode, + */ + __pyx_t_1 = __pyx_f_7asyncpg_8protocol_8protocol_register_core_codec(0x8E6, ((__pyx_t_7asyncpg_8protocol_8protocol_encode_func)(&__pyx_f_7asyncpg_8protocol_8protocol_void_encode)), ((__pyx_t_7asyncpg_8protocol_8protocol_decode_func)(&__pyx_f_7asyncpg_8protocol_8protocol_void_decode)), __pyx_e_7asyncpg_8protocol_8protocol_PG_FORMAT_BINARY); if (unlikely(!__pyx_t_1)) __PYX_ERR(19, 21, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "asyncpg/protocol/codecs/misc.pyx":27 + * + * # Unknown type, always decoded as text + * register_core_codec(UNKNOWNOID, # <<<<<<<<<<<<<< + * &text_encode, + * &text_decode, + */ + __pyx_t_1 = __pyx_f_7asyncpg_8protocol_8protocol_register_core_codec(0x2C1, ((__pyx_t_7asyncpg_8protocol_8protocol_encode_func)(&__pyx_f_7asyncpg_8protocol_8protocol_text_encode)), ((__pyx_t_7asyncpg_8protocol_8protocol_decode_func)(&__pyx_f_7asyncpg_8protocol_8protocol_text_decode)), __pyx_e_7asyncpg_8protocol_8protocol_PG_FORMAT_TEXT); if (unlikely(!__pyx_t_1)) __PYX_ERR(19, 27, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "asyncpg/protocol/codecs/misc.pyx":33 + * + * # OID and friends + * oid_types = [ # <<<<<<<<<<<<<< + * OIDOID, TIDOID, XIDOID, CIDOID + * ] + */ + __pyx_t_1 = PyList_New(4); if (unlikely(!__pyx_t_1)) __PYX_ERR(19, 33, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_INCREF(__pyx_int_26); + __Pyx_GIVEREF(__pyx_int_26); + PyList_SET_ITEM(__pyx_t_1, 0, __pyx_int_26); + __Pyx_INCREF(__pyx_int_27); + __Pyx_GIVEREF(__pyx_int_27); + PyList_SET_ITEM(__pyx_t_1, 1, __pyx_int_27); + __Pyx_INCREF(__pyx_int_28); + __Pyx_GIVEREF(__pyx_int_28); + PyList_SET_ITEM(__pyx_t_1, 2, __pyx_int_28); + __Pyx_INCREF(__pyx_int_29); + __Pyx_GIVEREF(__pyx_int_29); + PyList_SET_ITEM(__pyx_t_1, 3, __pyx_int_29); + __pyx_v_oid_types = ((PyObject*)__pyx_t_1); + __pyx_t_1 = 0; + + /* "asyncpg/protocol/codecs/misc.pyx":37 + * ] + * + * for oid_type in oid_types: # <<<<<<<<<<<<<< + * register_core_codec(oid_type, + * &int4_encode, + */ + __pyx_t_1 = __pyx_v_oid_types; __Pyx_INCREF(__pyx_t_1); __pyx_t_2 = 0; + for (;;) { + if (__pyx_t_2 >= PyList_GET_SIZE(__pyx_t_1)) break; + #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + __pyx_t_3 = PyList_GET_ITEM(__pyx_t_1, __pyx_t_2); __Pyx_INCREF(__pyx_t_3); __pyx_t_2++; if (unlikely(0 < 0)) __PYX_ERR(19, 37, __pyx_L1_error) + #else + __pyx_t_3 = PySequence_ITEM(__pyx_t_1, __pyx_t_2); __pyx_t_2++; if (unlikely(!__pyx_t_3)) __PYX_ERR(19, 37, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + #endif + __Pyx_XDECREF_SET(__pyx_v_oid_type, __pyx_t_3); + __pyx_t_3 = 0; + + /* "asyncpg/protocol/codecs/misc.pyx":38 + * + * for oid_type in oid_types: + * register_core_codec(oid_type, # <<<<<<<<<<<<<< + * &int4_encode, + * &int4_decode, + */ + __pyx_t_4 = __Pyx_PyInt_As_uint32_t(__pyx_v_oid_type); if (unlikely((__pyx_t_4 == ((uint32_t)-1)) && PyErr_Occurred())) __PYX_ERR(19, 38, __pyx_L1_error) + + /* "asyncpg/protocol/codecs/misc.pyx":41 + * &int4_encode, + * &int4_decode, + * PG_FORMAT_BINARY) # <<<<<<<<<<<<<< + * + * # reg* types -- these are really system catalog OIDs, but + */ + __pyx_t_3 = __pyx_f_7asyncpg_8protocol_8protocol_register_core_codec(__pyx_t_4, ((__pyx_t_7asyncpg_8protocol_8protocol_encode_func)(&__pyx_f_7asyncpg_8protocol_8protocol_int4_encode)), ((__pyx_t_7asyncpg_8protocol_8protocol_decode_func)(&__pyx_f_7asyncpg_8protocol_8protocol_int4_decode)), __pyx_e_7asyncpg_8protocol_8protocol_PG_FORMAT_BINARY); if (unlikely(!__pyx_t_3)) __PYX_ERR(19, 38, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + + /* "asyncpg/protocol/codecs/misc.pyx":37 + * ] + * + * for oid_type in oid_types: # <<<<<<<<<<<<<< + * register_core_codec(oid_type, + * &int4_encode, + */ + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "asyncpg/protocol/codecs/misc.pyx":48 + * # useful. + * # + * reg_types = [ # <<<<<<<<<<<<<< + * REGPROCOID, REGPROCEDUREOID, REGOPEROID, REGOPERATOROID, + * REGCLASSOID, REGTYPEOID, REGCONFIGOID, REGDICTIONARYOID, + */ + __pyx_t_1 = PyList_New(11); if (unlikely(!__pyx_t_1)) __PYX_ERR(19, 48, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_INCREF(__pyx_int_24); + __Pyx_GIVEREF(__pyx_int_24); + PyList_SET_ITEM(__pyx_t_1, 0, __pyx_int_24); + __Pyx_INCREF(__pyx_int_2202); + __Pyx_GIVEREF(__pyx_int_2202); + PyList_SET_ITEM(__pyx_t_1, 1, __pyx_int_2202); + __Pyx_INCREF(__pyx_int_2203); + __Pyx_GIVEREF(__pyx_int_2203); + PyList_SET_ITEM(__pyx_t_1, 2, __pyx_int_2203); + __Pyx_INCREF(__pyx_int_2204); + __Pyx_GIVEREF(__pyx_int_2204); + PyList_SET_ITEM(__pyx_t_1, 3, __pyx_int_2204); + __Pyx_INCREF(__pyx_int_2205); + __Pyx_GIVEREF(__pyx_int_2205); + PyList_SET_ITEM(__pyx_t_1, 4, __pyx_int_2205); + __Pyx_INCREF(__pyx_int_2206); + __Pyx_GIVEREF(__pyx_int_2206); + PyList_SET_ITEM(__pyx_t_1, 5, __pyx_int_2206); + __Pyx_INCREF(__pyx_int_3734); + __Pyx_GIVEREF(__pyx_int_3734); + PyList_SET_ITEM(__pyx_t_1, 6, __pyx_int_3734); + __Pyx_INCREF(__pyx_int_3769); + __Pyx_GIVEREF(__pyx_int_3769); + PyList_SET_ITEM(__pyx_t_1, 7, __pyx_int_3769); + __Pyx_INCREF(__pyx_int_4089); + __Pyx_GIVEREF(__pyx_int_4089); + PyList_SET_ITEM(__pyx_t_1, 8, __pyx_int_4089); + __Pyx_INCREF(__pyx_int_4096); + __Pyx_GIVEREF(__pyx_int_4096); + PyList_SET_ITEM(__pyx_t_1, 9, __pyx_int_4096); + __Pyx_INCREF(__pyx_int_1790); + __Pyx_GIVEREF(__pyx_int_1790); + PyList_SET_ITEM(__pyx_t_1, 10, __pyx_int_1790); + __pyx_v_reg_types = ((PyObject*)__pyx_t_1); + __pyx_t_1 = 0; + + /* "asyncpg/protocol/codecs/misc.pyx":54 + * ] + * + * for reg_type in reg_types: # <<<<<<<<<<<<<< + * register_core_codec(reg_type, + * &text_encode, + */ + __pyx_t_1 = __pyx_v_reg_types; __Pyx_INCREF(__pyx_t_1); __pyx_t_2 = 0; + for (;;) { + if (__pyx_t_2 >= PyList_GET_SIZE(__pyx_t_1)) break; + #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + __pyx_t_3 = PyList_GET_ITEM(__pyx_t_1, __pyx_t_2); __Pyx_INCREF(__pyx_t_3); __pyx_t_2++; if (unlikely(0 < 0)) __PYX_ERR(19, 54, __pyx_L1_error) + #else + __pyx_t_3 = PySequence_ITEM(__pyx_t_1, __pyx_t_2); __pyx_t_2++; if (unlikely(!__pyx_t_3)) __PYX_ERR(19, 54, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + #endif + __Pyx_XDECREF_SET(__pyx_v_reg_type, __pyx_t_3); + __pyx_t_3 = 0; + + /* "asyncpg/protocol/codecs/misc.pyx":55 + * + * for reg_type in reg_types: + * register_core_codec(reg_type, # <<<<<<<<<<<<<< + * &text_encode, + * &text_decode, + */ + __pyx_t_4 = __Pyx_PyInt_As_uint32_t(__pyx_v_reg_type); if (unlikely((__pyx_t_4 == ((uint32_t)-1)) && PyErr_Occurred())) __PYX_ERR(19, 55, __pyx_L1_error) + + /* "asyncpg/protocol/codecs/misc.pyx":58 + * &text_encode, + * &text_decode, + * PG_FORMAT_TEXT) # <<<<<<<<<<<<<< + * + * # cstring type is used by Postgres' I/O functions + */ + __pyx_t_3 = __pyx_f_7asyncpg_8protocol_8protocol_register_core_codec(__pyx_t_4, ((__pyx_t_7asyncpg_8protocol_8protocol_encode_func)(&__pyx_f_7asyncpg_8protocol_8protocol_text_encode)), ((__pyx_t_7asyncpg_8protocol_8protocol_decode_func)(&__pyx_f_7asyncpg_8protocol_8protocol_text_decode)), __pyx_e_7asyncpg_8protocol_8protocol_PG_FORMAT_TEXT); if (unlikely(!__pyx_t_3)) __PYX_ERR(19, 55, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + + /* "asyncpg/protocol/codecs/misc.pyx":54 + * ] + * + * for reg_type in reg_types: # <<<<<<<<<<<<<< + * register_core_codec(reg_type, + * &text_encode, + */ + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "asyncpg/protocol/codecs/misc.pyx":61 + * + * # cstring type is used by Postgres' I/O functions + * register_core_codec(CSTRINGOID, # <<<<<<<<<<<<<< + * &text_encode, + * &text_decode, + */ + __pyx_t_1 = __pyx_f_7asyncpg_8protocol_8protocol_register_core_codec(0x8E3, ((__pyx_t_7asyncpg_8protocol_8protocol_encode_func)(&__pyx_f_7asyncpg_8protocol_8protocol_text_encode)), ((__pyx_t_7asyncpg_8protocol_8protocol_decode_func)(&__pyx_f_7asyncpg_8protocol_8protocol_text_decode)), __pyx_e_7asyncpg_8protocol_8protocol_PG_FORMAT_BINARY); if (unlikely(!__pyx_t_1)) __PYX_ERR(19, 61, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "asyncpg/protocol/codecs/misc.pyx":67 + * + * # various system pseudotypes with no I/O + * no_io_types = [ # <<<<<<<<<<<<<< + * ANYOID, TRIGGEROID, EVENT_TRIGGEROID, LANGUAGE_HANDLEROID, + * FDW_HANDLEROID, TSM_HANDLEROID, INTERNALOID, OPAQUEOID, + */ + __pyx_t_1 = PyList_New(11); if (unlikely(!__pyx_t_1)) __PYX_ERR(19, 67, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_INCREF(__pyx_int_2276); + __Pyx_GIVEREF(__pyx_int_2276); + PyList_SET_ITEM(__pyx_t_1, 0, __pyx_int_2276); + __Pyx_INCREF(__pyx_int_2279); + __Pyx_GIVEREF(__pyx_int_2279); + PyList_SET_ITEM(__pyx_t_1, 1, __pyx_int_2279); + __Pyx_INCREF(__pyx_int_3838); + __Pyx_GIVEREF(__pyx_int_3838); + PyList_SET_ITEM(__pyx_t_1, 2, __pyx_int_3838); + __Pyx_INCREF(__pyx_int_2280); + __Pyx_GIVEREF(__pyx_int_2280); + PyList_SET_ITEM(__pyx_t_1, 3, __pyx_int_2280); + __Pyx_INCREF(__pyx_int_3115); + __Pyx_GIVEREF(__pyx_int_3115); + PyList_SET_ITEM(__pyx_t_1, 4, __pyx_int_3115); + __Pyx_INCREF(__pyx_int_3310); + __Pyx_GIVEREF(__pyx_int_3310); + PyList_SET_ITEM(__pyx_t_1, 5, __pyx_int_3310); + __Pyx_INCREF(__pyx_int_2281); + __Pyx_GIVEREF(__pyx_int_2281); + PyList_SET_ITEM(__pyx_t_1, 6, __pyx_int_2281); + __Pyx_INCREF(__pyx_int_2282); + __Pyx_GIVEREF(__pyx_int_2282); + PyList_SET_ITEM(__pyx_t_1, 7, __pyx_int_2282); + __Pyx_INCREF(__pyx_int_2283); + __Pyx_GIVEREF(__pyx_int_2283); + PyList_SET_ITEM(__pyx_t_1, 8, __pyx_int_2283); + __Pyx_INCREF(__pyx_int_2776); + __Pyx_GIVEREF(__pyx_int_2776); + PyList_SET_ITEM(__pyx_t_1, 9, __pyx_int_2776); + __Pyx_INCREF(__pyx_int_32); + __Pyx_GIVEREF(__pyx_int_32); + PyList_SET_ITEM(__pyx_t_1, 10, __pyx_int_32); + __pyx_v_no_io_types = ((PyObject*)__pyx_t_1); + __pyx_t_1 = 0; + + /* "asyncpg/protocol/codecs/misc.pyx":73 + * ] + * + * register_core_codec(ANYENUMOID, # <<<<<<<<<<<<<< + * NULL, + * &text_decode, + */ + __pyx_t_1 = __pyx_f_7asyncpg_8protocol_8protocol_register_core_codec(0xDAC, NULL, ((__pyx_t_7asyncpg_8protocol_8protocol_decode_func)(&__pyx_f_7asyncpg_8protocol_8protocol_text_decode)), __pyx_e_7asyncpg_8protocol_8protocol_PG_FORMAT_TEXT); if (unlikely(!__pyx_t_1)) __PYX_ERR(19, 73, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "asyncpg/protocol/codecs/misc.pyx":78 + * PG_FORMAT_TEXT) + * + * for no_io_type in no_io_types: # <<<<<<<<<<<<<< + * register_core_codec(no_io_type, + * NULL, + */ + __pyx_t_1 = __pyx_v_no_io_types; __Pyx_INCREF(__pyx_t_1); __pyx_t_2 = 0; + for (;;) { + if (__pyx_t_2 >= PyList_GET_SIZE(__pyx_t_1)) break; + #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + __pyx_t_3 = PyList_GET_ITEM(__pyx_t_1, __pyx_t_2); __Pyx_INCREF(__pyx_t_3); __pyx_t_2++; if (unlikely(0 < 0)) __PYX_ERR(19, 78, __pyx_L1_error) + #else + __pyx_t_3 = PySequence_ITEM(__pyx_t_1, __pyx_t_2); __pyx_t_2++; if (unlikely(!__pyx_t_3)) __PYX_ERR(19, 78, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + #endif + __Pyx_XDECREF_SET(__pyx_v_no_io_type, __pyx_t_3); + __pyx_t_3 = 0; + + /* "asyncpg/protocol/codecs/misc.pyx":79 + * + * for no_io_type in no_io_types: + * register_core_codec(no_io_type, # <<<<<<<<<<<<<< + * NULL, + * NULL, + */ + __pyx_t_4 = __Pyx_PyInt_As_uint32_t(__pyx_v_no_io_type); if (unlikely((__pyx_t_4 == ((uint32_t)-1)) && PyErr_Occurred())) __PYX_ERR(19, 79, __pyx_L1_error) + + /* "asyncpg/protocol/codecs/misc.pyx":82 + * NULL, + * NULL, + * PG_FORMAT_BINARY) # <<<<<<<<<<<<<< + * + * # ACL specification string + */ + __pyx_t_3 = __pyx_f_7asyncpg_8protocol_8protocol_register_core_codec(__pyx_t_4, NULL, NULL, __pyx_e_7asyncpg_8protocol_8protocol_PG_FORMAT_BINARY); if (unlikely(!__pyx_t_3)) __PYX_ERR(19, 79, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + + /* "asyncpg/protocol/codecs/misc.pyx":78 + * PG_FORMAT_TEXT) + * + * for no_io_type in no_io_types: # <<<<<<<<<<<<<< + * register_core_codec(no_io_type, + * NULL, + */ + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "asyncpg/protocol/codecs/misc.pyx":85 + * + * # ACL specification string + * register_core_codec(ACLITEMOID, # <<<<<<<<<<<<<< + * &text_encode, + * &text_decode, + */ + __pyx_t_1 = __pyx_f_7asyncpg_8protocol_8protocol_register_core_codec(0x409, ((__pyx_t_7asyncpg_8protocol_8protocol_encode_func)(&__pyx_f_7asyncpg_8protocol_8protocol_text_encode)), ((__pyx_t_7asyncpg_8protocol_8protocol_decode_func)(&__pyx_f_7asyncpg_8protocol_8protocol_text_decode)), __pyx_e_7asyncpg_8protocol_8protocol_PG_FORMAT_TEXT); if (unlikely(!__pyx_t_1)) __PYX_ERR(19, 85, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "asyncpg/protocol/codecs/misc.pyx":91 + * + * # Postgres' serialized expression tree type + * register_core_codec(PG_NODE_TREEOID, # <<<<<<<<<<<<<< + * NULL, + * &text_decode, + */ + __pyx_t_1 = __pyx_f_7asyncpg_8protocol_8protocol_register_core_codec(0xC2, NULL, ((__pyx_t_7asyncpg_8protocol_8protocol_decode_func)(&__pyx_f_7asyncpg_8protocol_8protocol_text_decode)), __pyx_e_7asyncpg_8protocol_8protocol_PG_FORMAT_TEXT); if (unlikely(!__pyx_t_1)) __PYX_ERR(19, 91, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "asyncpg/protocol/codecs/misc.pyx":97 + * + * # pg_lsn type -- a pointer to a location in the XLOG. + * register_core_codec(PG_LSNOID, # <<<<<<<<<<<<<< + * &int8_encode, + * &int8_decode, + */ + __pyx_t_1 = __pyx_f_7asyncpg_8protocol_8protocol_register_core_codec(0xC94, ((__pyx_t_7asyncpg_8protocol_8protocol_encode_func)(&__pyx_f_7asyncpg_8protocol_8protocol_int8_encode)), ((__pyx_t_7asyncpg_8protocol_8protocol_decode_func)(&__pyx_f_7asyncpg_8protocol_8protocol_int8_decode)), __pyx_e_7asyncpg_8protocol_8protocol_PG_FORMAT_BINARY); if (unlikely(!__pyx_t_1)) __PYX_ERR(19, 97, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "asyncpg/protocol/codecs/misc.pyx":102 + * PG_FORMAT_BINARY) + * + * register_core_codec(SMGROID, # <<<<<<<<<<<<<< + * &text_encode, + * &text_decode, + */ + __pyx_t_1 = __pyx_f_7asyncpg_8protocol_8protocol_register_core_codec(0xD2, ((__pyx_t_7asyncpg_8protocol_8protocol_encode_func)(&__pyx_f_7asyncpg_8protocol_8protocol_text_encode)), ((__pyx_t_7asyncpg_8protocol_8protocol_decode_func)(&__pyx_f_7asyncpg_8protocol_8protocol_text_decode)), __pyx_e_7asyncpg_8protocol_8protocol_PG_FORMAT_TEXT); if (unlikely(!__pyx_t_1)) __PYX_ERR(19, 102, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "asyncpg/protocol/codecs/misc.pyx":19 + * + * + * cdef init_pseudo_codecs(): # <<<<<<<<<<<<<< + * # Void type is returned by SELECT void_returning_function() + * register_core_codec(VOIDOID, + */ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_AddTraceback("asyncpg.protocol.protocol.init_pseudo_codecs", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XDECREF(__pyx_v_oid_types); + __Pyx_XDECREF(__pyx_v_oid_type); + __Pyx_XDECREF(__pyx_v_reg_types); + __Pyx_XDECREF(__pyx_v_reg_type); + __Pyx_XDECREF(__pyx_v_no_io_types); + __Pyx_XDECREF(__pyx_v_no_io_type); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "asyncpg/protocol/codecs/array.pyx":28 + * + * + * cdef inline bint _is_trivial_container(object obj): # <<<<<<<<<<<<<< + * return cpython.PyUnicode_Check(obj) or cpython.PyBytes_Check(obj) or \ + * PyByteArray_Check(obj) or PyMemoryView_Check(obj) + */ + +static CYTHON_INLINE int __pyx_f_7asyncpg_8protocol_8protocol__is_trivial_container(PyObject *__pyx_v_obj) { + int __pyx_r; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + int __pyx_t_2; + __Pyx_RefNannySetupContext("_is_trivial_container", 0); + + /* "asyncpg/protocol/codecs/array.pyx":29 + * + * cdef inline bint _is_trivial_container(object obj): + * return cpython.PyUnicode_Check(obj) or cpython.PyBytes_Check(obj) or \ # <<<<<<<<<<<<<< + * PyByteArray_Check(obj) or PyMemoryView_Check(obj) + * + */ + __pyx_t_2 = (PyUnicode_Check(__pyx_v_obj) != 0); + if (!__pyx_t_2) { + } else { + __pyx_t_1 = __pyx_t_2; + goto __pyx_L3_bool_binop_done; + } + __pyx_t_2 = (PyBytes_Check(__pyx_v_obj) != 0); + if (!__pyx_t_2) { + } else { + __pyx_t_1 = __pyx_t_2; + goto __pyx_L3_bool_binop_done; + } + + /* "asyncpg/protocol/codecs/array.pyx":30 + * cdef inline bint _is_trivial_container(object obj): + * return cpython.PyUnicode_Check(obj) or cpython.PyBytes_Check(obj) or \ + * PyByteArray_Check(obj) or PyMemoryView_Check(obj) # <<<<<<<<<<<<<< + * + * + */ + __pyx_t_2 = (PyByteArray_Check(__pyx_v_obj) != 0); + if (!__pyx_t_2) { + } else { + __pyx_t_1 = __pyx_t_2; + goto __pyx_L3_bool_binop_done; + } + __pyx_t_2 = (PyMemoryView_Check(__pyx_v_obj) != 0); + __pyx_t_1 = __pyx_t_2; + __pyx_L3_bool_binop_done:; + __pyx_r = __pyx_t_1; + goto __pyx_L0; + + /* "asyncpg/protocol/codecs/array.pyx":28 + * + * + * cdef inline bint _is_trivial_container(object obj): # <<<<<<<<<<<<<< + * return cpython.PyUnicode_Check(obj) or cpython.PyBytes_Check(obj) or \ + * PyByteArray_Check(obj) or PyMemoryView_Check(obj) + */ + + /* function exit code */ + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "asyncpg/protocol/codecs/array.pyx":33 + * + * + * cdef inline _is_container(object obj): # <<<<<<<<<<<<<< + * return not _is_trivial_container(obj) and isinstance(obj, ContainerABC) + * + */ + +static CYTHON_INLINE PyObject *__pyx_f_7asyncpg_8protocol_8protocol__is_container(PyObject *__pyx_v_obj) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_t_2; + PyObject *__pyx_t_3 = NULL; + __Pyx_RefNannySetupContext("_is_container", 0); + + /* "asyncpg/protocol/codecs/array.pyx":34 + * + * cdef inline _is_container(object obj): + * return not _is_trivial_container(obj) and isinstance(obj, ContainerABC) # <<<<<<<<<<<<<< + * + * + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_2 = (!(__pyx_f_7asyncpg_8protocol_8protocol__is_trivial_container(__pyx_v_obj) != 0)); + if (__pyx_t_2) { + } else { + __pyx_t_3 = __Pyx_PyBool_FromLong(__pyx_t_2); if (unlikely(!__pyx_t_3)) __PYX_ERR(20, 34, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_1 = __pyx_t_3; + __pyx_t_3 = 0; + goto __pyx_L3_bool_binop_done; + } + __pyx_t_3 = __Pyx_GetModuleGlobalName(__pyx_n_s_ContainerABC); if (unlikely(!__pyx_t_3)) __PYX_ERR(20, 34, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_2 = PyObject_IsInstance(__pyx_v_obj, __pyx_t_3); if (unlikely(__pyx_t_2 == -1)) __PYX_ERR(20, 34, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_3 = __Pyx_PyBool_FromLong(__pyx_t_2); if (unlikely(!__pyx_t_3)) __PYX_ERR(20, 34, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_1 = __pyx_t_3; + __pyx_t_3 = 0; + __pyx_L3_bool_binop_done:; + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "asyncpg/protocol/codecs/array.pyx":33 + * + * + * cdef inline _is_container(object obj): # <<<<<<<<<<<<<< + * return not _is_trivial_container(obj) and isinstance(obj, ContainerABC) + * + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_AddTraceback("asyncpg.protocol.protocol._is_container", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "asyncpg/protocol/codecs/array.pyx":37 + * + * + * cdef inline _is_sub_array(object obj): # <<<<<<<<<<<<<< + * return not _is_trivial_container(obj) and isinstance(obj, ContainerABC) \ + * and not cpython.PyTuple_Check(obj) + */ + +static CYTHON_INLINE PyObject *__pyx_f_7asyncpg_8protocol_8protocol__is_sub_array(PyObject *__pyx_v_obj) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_t_2; + PyObject *__pyx_t_3 = NULL; + __Pyx_RefNannySetupContext("_is_sub_array", 0); + + /* "asyncpg/protocol/codecs/array.pyx":38 + * + * cdef inline _is_sub_array(object obj): + * return not _is_trivial_container(obj) and isinstance(obj, ContainerABC) \ # <<<<<<<<<<<<<< + * and not cpython.PyTuple_Check(obj) + * + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_2 = (!(__pyx_f_7asyncpg_8protocol_8protocol__is_trivial_container(__pyx_v_obj) != 0)); + if (__pyx_t_2) { + } else { + __pyx_t_3 = __Pyx_PyBool_FromLong(__pyx_t_2); if (unlikely(!__pyx_t_3)) __PYX_ERR(20, 38, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_1 = __pyx_t_3; + __pyx_t_3 = 0; + goto __pyx_L3_bool_binop_done; + } + + /* "asyncpg/protocol/codecs/array.pyx":39 + * cdef inline _is_sub_array(object obj): + * return not _is_trivial_container(obj) and isinstance(obj, ContainerABC) \ + * and not cpython.PyTuple_Check(obj) # <<<<<<<<<<<<<< + * + * + */ + __pyx_t_3 = __Pyx_GetModuleGlobalName(__pyx_n_s_ContainerABC); if (unlikely(!__pyx_t_3)) __PYX_ERR(20, 38, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + + /* "asyncpg/protocol/codecs/array.pyx":38 + * + * cdef inline _is_sub_array(object obj): + * return not _is_trivial_container(obj) and isinstance(obj, ContainerABC) \ # <<<<<<<<<<<<<< + * and not cpython.PyTuple_Check(obj) + * + */ + __pyx_t_2 = PyObject_IsInstance(__pyx_v_obj, __pyx_t_3); if (unlikely(__pyx_t_2 == -1)) __PYX_ERR(20, 38, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (__pyx_t_2) { + } else { + __pyx_t_3 = __Pyx_PyBool_FromLong(__pyx_t_2); if (unlikely(!__pyx_t_3)) __PYX_ERR(20, 38, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_1 = __pyx_t_3; + __pyx_t_3 = 0; + goto __pyx_L3_bool_binop_done; + } + + /* "asyncpg/protocol/codecs/array.pyx":39 + * cdef inline _is_sub_array(object obj): + * return not _is_trivial_container(obj) and isinstance(obj, ContainerABC) \ + * and not cpython.PyTuple_Check(obj) # <<<<<<<<<<<<<< + * + * + */ + __pyx_t_2 = (!(PyTuple_Check(__pyx_v_obj) != 0)); + __pyx_t_3 = __Pyx_PyBool_FromLong(__pyx_t_2); if (unlikely(!__pyx_t_3)) __PYX_ERR(20, 39, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_1 = __pyx_t_3; + __pyx_t_3 = 0; + __pyx_L3_bool_binop_done:; + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "asyncpg/protocol/codecs/array.pyx":37 + * + * + * cdef inline _is_sub_array(object obj): # <<<<<<<<<<<<<< + * return not _is_trivial_container(obj) and isinstance(obj, ContainerABC) \ + * and not cpython.PyTuple_Check(obj) + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_AddTraceback("asyncpg.protocol.protocol._is_sub_array", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "asyncpg/protocol/codecs/array.pyx":42 + * + * + * cdef _get_array_shape(object obj, int32_t *dims, int32_t *ndims): # <<<<<<<<<<<<<< + * cdef: + * ssize_t mylen = len(obj) + */ + +static PyObject *__pyx_f_7asyncpg_8protocol_8protocol__get_array_shape(PyObject *__pyx_v_obj, int32_t *__pyx_v_dims, int32_t *__pyx_v_ndims) { + Py_ssize_t __pyx_v_mylen; + Py_ssize_t __pyx_v_elemlen; + PyObject *__pyx_v_elem = NULL; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + Py_ssize_t __pyx_t_1; + int __pyx_t_2; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + PyObject *__pyx_t_5 = NULL; + PyObject *__pyx_t_6 = NULL; + int __pyx_t_7; + PyObject *__pyx_t_8 = NULL; + PyObject *(*__pyx_t_9)(PyObject *); + Py_ssize_t __pyx_t_10; + long __pyx_t_11; + __Pyx_RefNannySetupContext("_get_array_shape", 0); + + /* "asyncpg/protocol/codecs/array.pyx":44 + * cdef _get_array_shape(object obj, int32_t *dims, int32_t *ndims): + * cdef: + * ssize_t mylen = len(obj) # <<<<<<<<<<<<<< + * ssize_t elemlen = -2 + * object it + */ + __pyx_t_1 = PyObject_Length(__pyx_v_obj); if (unlikely(__pyx_t_1 == -1)) __PYX_ERR(20, 44, __pyx_L1_error) + __pyx_v_mylen = __pyx_t_1; + + /* "asyncpg/protocol/codecs/array.pyx":45 + * cdef: + * ssize_t mylen = len(obj) + * ssize_t elemlen = -2 # <<<<<<<<<<<<<< + * object it + * + */ + __pyx_v_elemlen = -2L; + + /* "asyncpg/protocol/codecs/array.pyx":48 + * object it + * + * if mylen > _MAXINT32: # <<<<<<<<<<<<<< + * raise ValueError('too many elements in array value') + * + */ + __pyx_t_2 = ((__pyx_v_mylen > 0x7FFFFFFF) != 0); + if (__pyx_t_2) { + + /* "asyncpg/protocol/codecs/array.pyx":49 + * + * if mylen > _MAXINT32: + * raise ValueError('too many elements in array value') # <<<<<<<<<<<<<< + * + * if ndims[0] > ARRAY_MAXDIM: + */ + __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__39, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(20, 49, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_Raise(__pyx_t_3, 0, 0, 0); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __PYX_ERR(20, 49, __pyx_L1_error) + + /* "asyncpg/protocol/codecs/array.pyx":48 + * object it + * + * if mylen > _MAXINT32: # <<<<<<<<<<<<<< + * raise ValueError('too many elements in array value') + * + */ + } + + /* "asyncpg/protocol/codecs/array.pyx":51 + * raise ValueError('too many elements in array value') + * + * if ndims[0] > ARRAY_MAXDIM: # <<<<<<<<<<<<<< + * raise ValueError( + * 'number of array dimensions ({}) exceed the maximum expected ({})'. + */ + __pyx_t_2 = (((__pyx_v_ndims[0]) > 6) != 0); + if (__pyx_t_2) { + + /* "asyncpg/protocol/codecs/array.pyx":53 + * if ndims[0] > ARRAY_MAXDIM: + * raise ValueError( + * 'number of array dimensions ({}) exceed the maximum expected ({})'. # <<<<<<<<<<<<<< + * format(ndims[0], ARRAY_MAXDIM)) + * + */ + __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_kp_u_number_of_array_dimensions_excee, __pyx_n_s_format); if (unlikely(!__pyx_t_4)) __PYX_ERR(20, 53, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + + /* "asyncpg/protocol/codecs/array.pyx":54 + * raise ValueError( + * 'number of array dimensions ({}) exceed the maximum expected ({})'. + * format(ndims[0], ARRAY_MAXDIM)) # <<<<<<<<<<<<<< + * + * dims[ndims[0] - 1] = mylen + */ + __pyx_t_5 = __Pyx_PyInt_From_int32_t((__pyx_v_ndims[0])); if (unlikely(!__pyx_t_5)) __PYX_ERR(20, 54, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_6 = NULL; + __pyx_t_7 = 0; + if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_4))) { + __pyx_t_6 = PyMethod_GET_SELF(__pyx_t_4); + if (likely(__pyx_t_6)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4); + __Pyx_INCREF(__pyx_t_6); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_4, function); + __pyx_t_7 = 1; + } + } + #if CYTHON_FAST_PYCALL + if (PyFunction_Check(__pyx_t_4)) { + PyObject *__pyx_temp[3] = {__pyx_t_6, __pyx_t_5, __pyx_int_6}; + __pyx_t_3 = __Pyx_PyFunction_FastCall(__pyx_t_4, __pyx_temp+1-__pyx_t_7, 2+__pyx_t_7); if (unlikely(!__pyx_t_3)) __PYX_ERR(20, 54, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + } else + #endif + #if CYTHON_FAST_PYCCALL + if (__Pyx_PyFastCFunction_Check(__pyx_t_4)) { + PyObject *__pyx_temp[3] = {__pyx_t_6, __pyx_t_5, __pyx_int_6}; + __pyx_t_3 = __Pyx_PyCFunction_FastCall(__pyx_t_4, __pyx_temp+1-__pyx_t_7, 2+__pyx_t_7); if (unlikely(!__pyx_t_3)) __PYX_ERR(20, 54, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + } else + #endif + { + __pyx_t_8 = PyTuple_New(2+__pyx_t_7); if (unlikely(!__pyx_t_8)) __PYX_ERR(20, 54, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + if (__pyx_t_6) { + __Pyx_GIVEREF(__pyx_t_6); PyTuple_SET_ITEM(__pyx_t_8, 0, __pyx_t_6); __pyx_t_6 = NULL; + } + __Pyx_GIVEREF(__pyx_t_5); + PyTuple_SET_ITEM(__pyx_t_8, 0+__pyx_t_7, __pyx_t_5); + __Pyx_INCREF(__pyx_int_6); + __Pyx_GIVEREF(__pyx_int_6); + PyTuple_SET_ITEM(__pyx_t_8, 1+__pyx_t_7, __pyx_int_6); + __pyx_t_5 = 0; + __pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_4, __pyx_t_8, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(20, 54, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + } + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + + /* "asyncpg/protocol/codecs/array.pyx":52 + * + * if ndims[0] > ARRAY_MAXDIM: + * raise ValueError( # <<<<<<<<<<<<<< + * 'number of array dimensions ({}) exceed the maximum expected ({})'. + * format(ndims[0], ARRAY_MAXDIM)) + */ + __pyx_t_4 = PyTuple_New(1); if (unlikely(!__pyx_t_4)) __PYX_ERR(20, 52, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_GIVEREF(__pyx_t_3); + PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_3); + __pyx_t_3 = 0; + __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_t_4, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(20, 52, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_Raise(__pyx_t_3, 0, 0, 0); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __PYX_ERR(20, 52, __pyx_L1_error) + + /* "asyncpg/protocol/codecs/array.pyx":51 + * raise ValueError('too many elements in array value') + * + * if ndims[0] > ARRAY_MAXDIM: # <<<<<<<<<<<<<< + * raise ValueError( + * 'number of array dimensions ({}) exceed the maximum expected ({})'. + */ + } + + /* "asyncpg/protocol/codecs/array.pyx":56 + * format(ndims[0], ARRAY_MAXDIM)) + * + * dims[ndims[0] - 1] = mylen # <<<<<<<<<<<<<< + * + * for elem in obj: + */ + (__pyx_v_dims[((__pyx_v_ndims[0]) - 1)]) = ((int32_t)__pyx_v_mylen); + + /* "asyncpg/protocol/codecs/array.pyx":58 + * dims[ndims[0] - 1] = mylen + * + * for elem in obj: # <<<<<<<<<<<<<< + * if _is_sub_array(elem): + * if elemlen == -2: + */ + if (likely(PyList_CheckExact(__pyx_v_obj)) || PyTuple_CheckExact(__pyx_v_obj)) { + __pyx_t_3 = __pyx_v_obj; __Pyx_INCREF(__pyx_t_3); __pyx_t_1 = 0; + __pyx_t_9 = NULL; + } else { + __pyx_t_1 = -1; __pyx_t_3 = PyObject_GetIter(__pyx_v_obj); if (unlikely(!__pyx_t_3)) __PYX_ERR(20, 58, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_9 = Py_TYPE(__pyx_t_3)->tp_iternext; if (unlikely(!__pyx_t_9)) __PYX_ERR(20, 58, __pyx_L1_error) + } + for (;;) { + if (likely(!__pyx_t_9)) { + if (likely(PyList_CheckExact(__pyx_t_3))) { + if (__pyx_t_1 >= PyList_GET_SIZE(__pyx_t_3)) break; + #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + __pyx_t_4 = PyList_GET_ITEM(__pyx_t_3, __pyx_t_1); __Pyx_INCREF(__pyx_t_4); __pyx_t_1++; if (unlikely(0 < 0)) __PYX_ERR(20, 58, __pyx_L1_error) + #else + __pyx_t_4 = PySequence_ITEM(__pyx_t_3, __pyx_t_1); __pyx_t_1++; if (unlikely(!__pyx_t_4)) __PYX_ERR(20, 58, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + #endif + } else { + if (__pyx_t_1 >= PyTuple_GET_SIZE(__pyx_t_3)) break; + #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + __pyx_t_4 = PyTuple_GET_ITEM(__pyx_t_3, __pyx_t_1); __Pyx_INCREF(__pyx_t_4); __pyx_t_1++; if (unlikely(0 < 0)) __PYX_ERR(20, 58, __pyx_L1_error) + #else + __pyx_t_4 = PySequence_ITEM(__pyx_t_3, __pyx_t_1); __pyx_t_1++; if (unlikely(!__pyx_t_4)) __PYX_ERR(20, 58, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + #endif + } + } else { + __pyx_t_4 = __pyx_t_9(__pyx_t_3); + if (unlikely(!__pyx_t_4)) { + PyObject* exc_type = PyErr_Occurred(); + if (exc_type) { + if (likely(exc_type == PyExc_StopIteration || PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) PyErr_Clear(); + else __PYX_ERR(20, 58, __pyx_L1_error) + } + break; + } + __Pyx_GOTREF(__pyx_t_4); + } + __Pyx_XDECREF_SET(__pyx_v_elem, __pyx_t_4); + __pyx_t_4 = 0; + + /* "asyncpg/protocol/codecs/array.pyx":59 + * + * for elem in obj: + * if _is_sub_array(elem): # <<<<<<<<<<<<<< + * if elemlen == -2: + * elemlen = len(elem) + */ + __pyx_t_4 = __pyx_f_7asyncpg_8protocol_8protocol__is_sub_array(__pyx_v_elem); if (unlikely(!__pyx_t_4)) __PYX_ERR(20, 59, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_2 < 0)) __PYX_ERR(20, 59, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + if (__pyx_t_2) { + + /* "asyncpg/protocol/codecs/array.pyx":60 + * for elem in obj: + * if _is_sub_array(elem): + * if elemlen == -2: # <<<<<<<<<<<<<< + * elemlen = len(elem) + * if elemlen > _MAXINT32: + */ + __pyx_t_2 = ((__pyx_v_elemlen == -2L) != 0); + if (__pyx_t_2) { + + /* "asyncpg/protocol/codecs/array.pyx":61 + * if _is_sub_array(elem): + * if elemlen == -2: + * elemlen = len(elem) # <<<<<<<<<<<<<< + * if elemlen > _MAXINT32: + * raise ValueError('too many elements in array value') + */ + __pyx_t_10 = PyObject_Length(__pyx_v_elem); if (unlikely(__pyx_t_10 == -1)) __PYX_ERR(20, 61, __pyx_L1_error) + __pyx_v_elemlen = __pyx_t_10; + + /* "asyncpg/protocol/codecs/array.pyx":62 + * if elemlen == -2: + * elemlen = len(elem) + * if elemlen > _MAXINT32: # <<<<<<<<<<<<<< + * raise ValueError('too many elements in array value') + * ndims[0] += 1 + */ + __pyx_t_2 = ((__pyx_v_elemlen > 0x7FFFFFFF) != 0); + if (__pyx_t_2) { + + /* "asyncpg/protocol/codecs/array.pyx":63 + * elemlen = len(elem) + * if elemlen > _MAXINT32: + * raise ValueError('too many elements in array value') # <<<<<<<<<<<<<< + * ndims[0] += 1 + * _get_array_shape(elem, dims, ndims) + */ + __pyx_t_4 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__40, NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(20, 63, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_Raise(__pyx_t_4, 0, 0, 0); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __PYX_ERR(20, 63, __pyx_L1_error) + + /* "asyncpg/protocol/codecs/array.pyx":62 + * if elemlen == -2: + * elemlen = len(elem) + * if elemlen > _MAXINT32: # <<<<<<<<<<<<<< + * raise ValueError('too many elements in array value') + * ndims[0] += 1 + */ + } + + /* "asyncpg/protocol/codecs/array.pyx":64 + * if elemlen > _MAXINT32: + * raise ValueError('too many elements in array value') + * ndims[0] += 1 # <<<<<<<<<<<<<< + * _get_array_shape(elem, dims, ndims) + * else: + */ + __pyx_t_11 = 0; + (__pyx_v_ndims[__pyx_t_11]) = ((__pyx_v_ndims[__pyx_t_11]) + 1); + + /* "asyncpg/protocol/codecs/array.pyx":65 + * raise ValueError('too many elements in array value') + * ndims[0] += 1 + * _get_array_shape(elem, dims, ndims) # <<<<<<<<<<<<<< + * else: + * if len(elem) != elemlen: + */ + __pyx_t_4 = __pyx_f_7asyncpg_8protocol_8protocol__get_array_shape(__pyx_v_elem, __pyx_v_dims, __pyx_v_ndims); if (unlikely(!__pyx_t_4)) __PYX_ERR(20, 65, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + + /* "asyncpg/protocol/codecs/array.pyx":60 + * for elem in obj: + * if _is_sub_array(elem): + * if elemlen == -2: # <<<<<<<<<<<<<< + * elemlen = len(elem) + * if elemlen > _MAXINT32: + */ + goto __pyx_L8; + } + + /* "asyncpg/protocol/codecs/array.pyx":67 + * _get_array_shape(elem, dims, ndims) + * else: + * if len(elem) != elemlen: # <<<<<<<<<<<<<< + * raise ValueError('non-homogeneous array') + * else: + */ + /*else*/ { + __pyx_t_10 = PyObject_Length(__pyx_v_elem); if (unlikely(__pyx_t_10 == -1)) __PYX_ERR(20, 67, __pyx_L1_error) + __pyx_t_2 = ((__pyx_t_10 != __pyx_v_elemlen) != 0); + if (__pyx_t_2) { + + /* "asyncpg/protocol/codecs/array.pyx":68 + * else: + * if len(elem) != elemlen: + * raise ValueError('non-homogeneous array') # <<<<<<<<<<<<<< + * else: + * if elemlen >= 0: + */ + __pyx_t_4 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__41, NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(20, 68, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_Raise(__pyx_t_4, 0, 0, 0); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __PYX_ERR(20, 68, __pyx_L1_error) + + /* "asyncpg/protocol/codecs/array.pyx":67 + * _get_array_shape(elem, dims, ndims) + * else: + * if len(elem) != elemlen: # <<<<<<<<<<<<<< + * raise ValueError('non-homogeneous array') + * else: + */ + } + } + __pyx_L8:; + + /* "asyncpg/protocol/codecs/array.pyx":59 + * + * for elem in obj: + * if _is_sub_array(elem): # <<<<<<<<<<<<<< + * if elemlen == -2: + * elemlen = len(elem) + */ + goto __pyx_L7; + } + + /* "asyncpg/protocol/codecs/array.pyx":70 + * raise ValueError('non-homogeneous array') + * else: + * if elemlen >= 0: # <<<<<<<<<<<<<< + * raise ValueError('non-homogeneous array') + * else: + */ + /*else*/ { + __pyx_t_2 = ((__pyx_v_elemlen >= 0) != 0); + if (__pyx_t_2) { + + /* "asyncpg/protocol/codecs/array.pyx":71 + * else: + * if elemlen >= 0: + * raise ValueError('non-homogeneous array') # <<<<<<<<<<<<<< + * else: + * elemlen = -1 + */ + __pyx_t_4 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__42, NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(20, 71, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_Raise(__pyx_t_4, 0, 0, 0); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __PYX_ERR(20, 71, __pyx_L1_error) + + /* "asyncpg/protocol/codecs/array.pyx":70 + * raise ValueError('non-homogeneous array') + * else: + * if elemlen >= 0: # <<<<<<<<<<<<<< + * raise ValueError('non-homogeneous array') + * else: + */ + } + + /* "asyncpg/protocol/codecs/array.pyx":73 + * raise ValueError('non-homogeneous array') + * else: + * elemlen = -1 # <<<<<<<<<<<<<< + * + * + */ + /*else*/ { + __pyx_v_elemlen = -1L; + } + } + __pyx_L7:; + + /* "asyncpg/protocol/codecs/array.pyx":58 + * dims[ndims[0] - 1] = mylen + * + * for elem in obj: # <<<<<<<<<<<<<< + * if _is_sub_array(elem): + * if elemlen == -2: + */ + } + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + + /* "asyncpg/protocol/codecs/array.pyx":42 + * + * + * cdef _get_array_shape(object obj, int32_t *dims, int32_t *ndims): # <<<<<<<<<<<<<< + * cdef: + * ssize_t mylen = len(obj) + */ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_XDECREF(__pyx_t_6); + __Pyx_XDECREF(__pyx_t_8); + __Pyx_AddTraceback("asyncpg.protocol.protocol._get_array_shape", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XDECREF(__pyx_v_elem); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "asyncpg/protocol/codecs/array.pyx":76 + * + * + * cdef _write_array_data(ConnectionSettings settings, object obj, int32_t ndims, # <<<<<<<<<<<<<< + * int32_t dim, WriteBuffer elem_data, + * encode_func_ex encoder, const void *encoder_arg): + */ + +static PyObject *__pyx_f_7asyncpg_8protocol_8protocol__write_array_data(struct __pyx_obj_7asyncpg_8protocol_8protocol_ConnectionSettings *__pyx_v_settings, PyObject *__pyx_v_obj, int32_t __pyx_v_ndims, int32_t __pyx_v_dim, struct __pyx_obj_7asyncpg_8protocol_8protocol_WriteBuffer *__pyx_v_elem_data, __pyx_t_7asyncpg_8protocol_8protocol_encode_func_ex __pyx_v_encoder, void const *__pyx_v_encoder_arg) { + PyObject *__pyx_v_item = NULL; + PyObject *__pyx_v_e = NULL; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + PyObject *__pyx_t_2 = NULL; + Py_ssize_t __pyx_t_3; + PyObject *(*__pyx_t_4)(PyObject *); + PyObject *__pyx_t_5 = NULL; + int __pyx_t_6; + PyObject *__pyx_t_7 = NULL; + PyObject *__pyx_t_8 = NULL; + PyObject *__pyx_t_9 = NULL; + int __pyx_t_10; + PyObject *__pyx_t_11 = NULL; + PyObject *__pyx_t_12 = NULL; + PyObject *__pyx_t_13 = NULL; + PyObject *__pyx_t_14 = NULL; + PyObject *__pyx_t_15 = NULL; + PyObject *__pyx_t_16 = NULL; + PyObject *__pyx_t_17 = NULL; + int __pyx_t_18; + char const *__pyx_t_19; + PyObject *__pyx_t_20 = NULL; + PyObject *__pyx_t_21 = NULL; + PyObject *__pyx_t_22 = NULL; + PyObject *__pyx_t_23 = NULL; + PyObject *__pyx_t_24 = NULL; + PyObject *__pyx_t_25 = NULL; + __Pyx_RefNannySetupContext("_write_array_data", 0); + + /* "asyncpg/protocol/codecs/array.pyx":79 + * int32_t dim, WriteBuffer elem_data, + * encode_func_ex encoder, const void *encoder_arg): + * if dim < ndims - 1: # <<<<<<<<<<<<<< + * for item in obj: + * _write_array_data(settings, item, ndims, dim + 1, elem_data, + */ + __pyx_t_1 = ((__pyx_v_dim < (__pyx_v_ndims - 1)) != 0); + if (__pyx_t_1) { + + /* "asyncpg/protocol/codecs/array.pyx":80 + * encode_func_ex encoder, const void *encoder_arg): + * if dim < ndims - 1: + * for item in obj: # <<<<<<<<<<<<<< + * _write_array_data(settings, item, ndims, dim + 1, elem_data, + * encoder, encoder_arg) + */ + if (likely(PyList_CheckExact(__pyx_v_obj)) || PyTuple_CheckExact(__pyx_v_obj)) { + __pyx_t_2 = __pyx_v_obj; __Pyx_INCREF(__pyx_t_2); __pyx_t_3 = 0; + __pyx_t_4 = NULL; + } else { + __pyx_t_3 = -1; __pyx_t_2 = PyObject_GetIter(__pyx_v_obj); if (unlikely(!__pyx_t_2)) __PYX_ERR(20, 80, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_4 = Py_TYPE(__pyx_t_2)->tp_iternext; if (unlikely(!__pyx_t_4)) __PYX_ERR(20, 80, __pyx_L1_error) + } + for (;;) { + if (likely(!__pyx_t_4)) { + if (likely(PyList_CheckExact(__pyx_t_2))) { + if (__pyx_t_3 >= PyList_GET_SIZE(__pyx_t_2)) break; + #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + __pyx_t_5 = PyList_GET_ITEM(__pyx_t_2, __pyx_t_3); __Pyx_INCREF(__pyx_t_5); __pyx_t_3++; if (unlikely(0 < 0)) __PYX_ERR(20, 80, __pyx_L1_error) + #else + __pyx_t_5 = PySequence_ITEM(__pyx_t_2, __pyx_t_3); __pyx_t_3++; if (unlikely(!__pyx_t_5)) __PYX_ERR(20, 80, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + #endif + } else { + if (__pyx_t_3 >= PyTuple_GET_SIZE(__pyx_t_2)) break; + #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + __pyx_t_5 = PyTuple_GET_ITEM(__pyx_t_2, __pyx_t_3); __Pyx_INCREF(__pyx_t_5); __pyx_t_3++; if (unlikely(0 < 0)) __PYX_ERR(20, 80, __pyx_L1_error) + #else + __pyx_t_5 = PySequence_ITEM(__pyx_t_2, __pyx_t_3); __pyx_t_3++; if (unlikely(!__pyx_t_5)) __PYX_ERR(20, 80, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + #endif + } + } else { + __pyx_t_5 = __pyx_t_4(__pyx_t_2); + if (unlikely(!__pyx_t_5)) { + PyObject* exc_type = PyErr_Occurred(); + if (exc_type) { + if (likely(exc_type == PyExc_StopIteration || PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) PyErr_Clear(); + else __PYX_ERR(20, 80, __pyx_L1_error) + } + break; + } + __Pyx_GOTREF(__pyx_t_5); + } + __Pyx_XDECREF_SET(__pyx_v_item, __pyx_t_5); + __pyx_t_5 = 0; + + /* "asyncpg/protocol/codecs/array.pyx":81 + * if dim < ndims - 1: + * for item in obj: + * _write_array_data(settings, item, ndims, dim + 1, elem_data, # <<<<<<<<<<<<<< + * encoder, encoder_arg) + * else: + */ + __pyx_t_5 = __pyx_f_7asyncpg_8protocol_8protocol__write_array_data(__pyx_v_settings, __pyx_v_item, __pyx_v_ndims, (__pyx_v_dim + 1), __pyx_v_elem_data, __pyx_v_encoder, __pyx_v_encoder_arg); if (unlikely(!__pyx_t_5)) __PYX_ERR(20, 81, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + + /* "asyncpg/protocol/codecs/array.pyx":80 + * encode_func_ex encoder, const void *encoder_arg): + * if dim < ndims - 1: + * for item in obj: # <<<<<<<<<<<<<< + * _write_array_data(settings, item, ndims, dim + 1, elem_data, + * encoder, encoder_arg) + */ + } + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "asyncpg/protocol/codecs/array.pyx":79 + * int32_t dim, WriteBuffer elem_data, + * encode_func_ex encoder, const void *encoder_arg): + * if dim < ndims - 1: # <<<<<<<<<<<<<< + * for item in obj: + * _write_array_data(settings, item, ndims, dim + 1, elem_data, + */ + goto __pyx_L3; + } + + /* "asyncpg/protocol/codecs/array.pyx":84 + * encoder, encoder_arg) + * else: + * for item in obj: # <<<<<<<<<<<<<< + * if item is None: + * elem_data.write_int32(-1) + */ + /*else*/ { + if (likely(PyList_CheckExact(__pyx_v_obj)) || PyTuple_CheckExact(__pyx_v_obj)) { + __pyx_t_2 = __pyx_v_obj; __Pyx_INCREF(__pyx_t_2); __pyx_t_3 = 0; + __pyx_t_4 = NULL; + } else { + __pyx_t_3 = -1; __pyx_t_2 = PyObject_GetIter(__pyx_v_obj); if (unlikely(!__pyx_t_2)) __PYX_ERR(20, 84, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_4 = Py_TYPE(__pyx_t_2)->tp_iternext; if (unlikely(!__pyx_t_4)) __PYX_ERR(20, 84, __pyx_L1_error) + } + for (;;) { + if (likely(!__pyx_t_4)) { + if (likely(PyList_CheckExact(__pyx_t_2))) { + if (__pyx_t_3 >= PyList_GET_SIZE(__pyx_t_2)) break; + #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + __pyx_t_5 = PyList_GET_ITEM(__pyx_t_2, __pyx_t_3); __Pyx_INCREF(__pyx_t_5); __pyx_t_3++; if (unlikely(0 < 0)) __PYX_ERR(20, 84, __pyx_L1_error) + #else + __pyx_t_5 = PySequence_ITEM(__pyx_t_2, __pyx_t_3); __pyx_t_3++; if (unlikely(!__pyx_t_5)) __PYX_ERR(20, 84, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + #endif + } else { + if (__pyx_t_3 >= PyTuple_GET_SIZE(__pyx_t_2)) break; + #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + __pyx_t_5 = PyTuple_GET_ITEM(__pyx_t_2, __pyx_t_3); __Pyx_INCREF(__pyx_t_5); __pyx_t_3++; if (unlikely(0 < 0)) __PYX_ERR(20, 84, __pyx_L1_error) + #else + __pyx_t_5 = PySequence_ITEM(__pyx_t_2, __pyx_t_3); __pyx_t_3++; if (unlikely(!__pyx_t_5)) __PYX_ERR(20, 84, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + #endif + } + } else { + __pyx_t_5 = __pyx_t_4(__pyx_t_2); + if (unlikely(!__pyx_t_5)) { + PyObject* exc_type = PyErr_Occurred(); + if (exc_type) { + if (likely(exc_type == PyExc_StopIteration || PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) PyErr_Clear(); + else __PYX_ERR(20, 84, __pyx_L1_error) + } + break; + } + __Pyx_GOTREF(__pyx_t_5); + } + __Pyx_XDECREF_SET(__pyx_v_item, __pyx_t_5); + __pyx_t_5 = 0; + + /* "asyncpg/protocol/codecs/array.pyx":85 + * else: + * for item in obj: + * if item is None: # <<<<<<<<<<<<<< + * elem_data.write_int32(-1) + * else: + */ + __pyx_t_1 = (__pyx_v_item == Py_None); + __pyx_t_6 = (__pyx_t_1 != 0); + if (__pyx_t_6) { + + /* "asyncpg/protocol/codecs/array.pyx":86 + * for item in obj: + * if item is None: + * elem_data.write_int32(-1) # <<<<<<<<<<<<<< + * else: + * try: + */ + __pyx_t_5 = __pyx_f_7asyncpg_8protocol_8protocol_11WriteBuffer_write_int32(__pyx_v_elem_data, -1); if (unlikely(!__pyx_t_5)) __PYX_ERR(20, 86, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + + /* "asyncpg/protocol/codecs/array.pyx":85 + * else: + * for item in obj: + * if item is None: # <<<<<<<<<<<<<< + * elem_data.write_int32(-1) + * else: + */ + goto __pyx_L8; + } + + /* "asyncpg/protocol/codecs/array.pyx":88 + * elem_data.write_int32(-1) + * else: + * try: # <<<<<<<<<<<<<< + * encoder(settings, elem_data, item, encoder_arg) + * except TypeError as e: + */ + /*else*/ { + { + __Pyx_PyThreadState_declare + __Pyx_PyThreadState_assign + __Pyx_ExceptionSave(&__pyx_t_7, &__pyx_t_8, &__pyx_t_9); + __Pyx_XGOTREF(__pyx_t_7); + __Pyx_XGOTREF(__pyx_t_8); + __Pyx_XGOTREF(__pyx_t_9); + /*try:*/ { + + /* "asyncpg/protocol/codecs/array.pyx":89 + * else: + * try: + * encoder(settings, elem_data, item, encoder_arg) # <<<<<<<<<<<<<< + * except TypeError as e: + * raise ValueError( + */ + __pyx_t_5 = __pyx_v_encoder(__pyx_v_settings, __pyx_v_elem_data, __pyx_v_item, __pyx_v_encoder_arg); if (unlikely(!__pyx_t_5)) __PYX_ERR(20, 89, __pyx_L9_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + + /* "asyncpg/protocol/codecs/array.pyx":88 + * elem_data.write_int32(-1) + * else: + * try: # <<<<<<<<<<<<<< + * encoder(settings, elem_data, item, encoder_arg) + * except TypeError as e: + */ + } + __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; + __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0; + goto __pyx_L16_try_end; + __pyx_L9_error:; + __Pyx_PyThreadState_assign + __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; + + /* "asyncpg/protocol/codecs/array.pyx":90 + * try: + * encoder(settings, elem_data, item, encoder_arg) + * except TypeError as e: # <<<<<<<<<<<<<< + * raise ValueError( + * 'invalid array element: {}'.format(e.args[0])) from None + */ + __pyx_t_10 = __Pyx_PyErr_ExceptionMatches(__pyx_builtin_TypeError); + if (__pyx_t_10) { + __Pyx_AddTraceback("asyncpg.protocol.protocol._write_array_data", __pyx_clineno, __pyx_lineno, __pyx_filename); + if (__Pyx_GetException(&__pyx_t_5, &__pyx_t_11, &__pyx_t_12) < 0) __PYX_ERR(20, 90, __pyx_L11_except_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_GOTREF(__pyx_t_11); + __Pyx_GOTREF(__pyx_t_12); + __Pyx_INCREF(__pyx_t_11); + __pyx_v_e = __pyx_t_11; + /*try:*/ { + + /* "asyncpg/protocol/codecs/array.pyx":92 + * except TypeError as e: + * raise ValueError( + * 'invalid array element: {}'.format(e.args[0])) from None # <<<<<<<<<<<<<< + * + * + */ + __pyx_t_14 = __Pyx_PyObject_GetAttrStr(__pyx_kp_u_invalid_array_element, __pyx_n_s_format); if (unlikely(!__pyx_t_14)) __PYX_ERR(20, 92, __pyx_L22_error) + __Pyx_GOTREF(__pyx_t_14); + __pyx_t_15 = __Pyx_PyObject_GetAttrStr(__pyx_v_e, __pyx_n_s_args); if (unlikely(!__pyx_t_15)) __PYX_ERR(20, 92, __pyx_L22_error) + __Pyx_GOTREF(__pyx_t_15); + __pyx_t_16 = __Pyx_GetItemInt(__pyx_t_15, 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_16)) __PYX_ERR(20, 92, __pyx_L22_error) + __Pyx_GOTREF(__pyx_t_16); + __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0; + __pyx_t_15 = NULL; + if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_14))) { + __pyx_t_15 = PyMethod_GET_SELF(__pyx_t_14); + if (likely(__pyx_t_15)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_14); + __Pyx_INCREF(__pyx_t_15); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_14, function); + } + } + if (!__pyx_t_15) { + __pyx_t_13 = __Pyx_PyObject_CallOneArg(__pyx_t_14, __pyx_t_16); if (unlikely(!__pyx_t_13)) __PYX_ERR(20, 92, __pyx_L22_error) + __Pyx_DECREF(__pyx_t_16); __pyx_t_16 = 0; + __Pyx_GOTREF(__pyx_t_13); + } else { + #if CYTHON_FAST_PYCALL + if (PyFunction_Check(__pyx_t_14)) { + PyObject *__pyx_temp[2] = {__pyx_t_15, __pyx_t_16}; + __pyx_t_13 = __Pyx_PyFunction_FastCall(__pyx_t_14, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_13)) __PYX_ERR(20, 92, __pyx_L22_error) + __Pyx_XDECREF(__pyx_t_15); __pyx_t_15 = 0; + __Pyx_GOTREF(__pyx_t_13); + __Pyx_DECREF(__pyx_t_16); __pyx_t_16 = 0; + } else + #endif + #if CYTHON_FAST_PYCCALL + if (__Pyx_PyFastCFunction_Check(__pyx_t_14)) { + PyObject *__pyx_temp[2] = {__pyx_t_15, __pyx_t_16}; + __pyx_t_13 = __Pyx_PyCFunction_FastCall(__pyx_t_14, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_13)) __PYX_ERR(20, 92, __pyx_L22_error) + __Pyx_XDECREF(__pyx_t_15); __pyx_t_15 = 0; + __Pyx_GOTREF(__pyx_t_13); + __Pyx_DECREF(__pyx_t_16); __pyx_t_16 = 0; + } else + #endif + { + __pyx_t_17 = PyTuple_New(1+1); if (unlikely(!__pyx_t_17)) __PYX_ERR(20, 92, __pyx_L22_error) + __Pyx_GOTREF(__pyx_t_17); + __Pyx_GIVEREF(__pyx_t_15); PyTuple_SET_ITEM(__pyx_t_17, 0, __pyx_t_15); __pyx_t_15 = NULL; + __Pyx_GIVEREF(__pyx_t_16); + PyTuple_SET_ITEM(__pyx_t_17, 0+1, __pyx_t_16); + __pyx_t_16 = 0; + __pyx_t_13 = __Pyx_PyObject_Call(__pyx_t_14, __pyx_t_17, NULL); if (unlikely(!__pyx_t_13)) __PYX_ERR(20, 92, __pyx_L22_error) + __Pyx_GOTREF(__pyx_t_13); + __Pyx_DECREF(__pyx_t_17); __pyx_t_17 = 0; + } + } + __Pyx_DECREF(__pyx_t_14); __pyx_t_14 = 0; + + /* "asyncpg/protocol/codecs/array.pyx":91 + * encoder(settings, elem_data, item, encoder_arg) + * except TypeError as e: + * raise ValueError( # <<<<<<<<<<<<<< + * 'invalid array element: {}'.format(e.args[0])) from None + * + */ + __pyx_t_14 = PyTuple_New(1); if (unlikely(!__pyx_t_14)) __PYX_ERR(20, 91, __pyx_L22_error) + __Pyx_GOTREF(__pyx_t_14); + __Pyx_GIVEREF(__pyx_t_13); + PyTuple_SET_ITEM(__pyx_t_14, 0, __pyx_t_13); + __pyx_t_13 = 0; + __pyx_t_13 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_t_14, NULL); if (unlikely(!__pyx_t_13)) __PYX_ERR(20, 91, __pyx_L22_error) + __Pyx_GOTREF(__pyx_t_13); + __Pyx_DECREF(__pyx_t_14); __pyx_t_14 = 0; + + /* "asyncpg/protocol/codecs/array.pyx":92 + * except TypeError as e: + * raise ValueError( + * 'invalid array element: {}'.format(e.args[0])) from None # <<<<<<<<<<<<<< + * + * + */ + __Pyx_Raise(__pyx_t_13, 0, 0, Py_None); + __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0; + __PYX_ERR(20, 91, __pyx_L22_error) + } + + /* "asyncpg/protocol/codecs/array.pyx":90 + * try: + * encoder(settings, elem_data, item, encoder_arg) + * except TypeError as e: # <<<<<<<<<<<<<< + * raise ValueError( + * 'invalid array element: {}'.format(e.args[0])) from None + */ + /*finally:*/ { + /*exception exit:*/{ + __Pyx_PyThreadState_declare + __pyx_L22_error:; + __pyx_t_20 = 0; __pyx_t_21 = 0; __pyx_t_22 = 0; __pyx_t_23 = 0; __pyx_t_24 = 0; __pyx_t_25 = 0; + __Pyx_PyThreadState_assign + __Pyx_XDECREF(__pyx_t_15); __pyx_t_15 = 0; + __Pyx_XDECREF(__pyx_t_16); __pyx_t_16 = 0; + __Pyx_XDECREF(__pyx_t_17); __pyx_t_17 = 0; + __Pyx_XDECREF(__pyx_t_14); __pyx_t_14 = 0; + __Pyx_XDECREF(__pyx_t_13); __pyx_t_13 = 0; + if (PY_MAJOR_VERSION >= 3) __Pyx_ExceptionSwap(&__pyx_t_23, &__pyx_t_24, &__pyx_t_25); + if ((PY_MAJOR_VERSION < 3) || unlikely(__Pyx_GetException(&__pyx_t_20, &__pyx_t_21, &__pyx_t_22) < 0)) __Pyx_ErrFetch(&__pyx_t_20, &__pyx_t_21, &__pyx_t_22); + __Pyx_XGOTREF(__pyx_t_20); + __Pyx_XGOTREF(__pyx_t_21); + __Pyx_XGOTREF(__pyx_t_22); + __Pyx_XGOTREF(__pyx_t_23); + __Pyx_XGOTREF(__pyx_t_24); + __Pyx_XGOTREF(__pyx_t_25); + __pyx_t_10 = __pyx_lineno; __pyx_t_18 = __pyx_clineno; __pyx_t_19 = __pyx_filename; + { + __Pyx_DECREF(__pyx_v_e); + __pyx_v_e = NULL; + } + __Pyx_PyThreadState_assign + if (PY_MAJOR_VERSION >= 3) { + __Pyx_XGIVEREF(__pyx_t_23); + __Pyx_XGIVEREF(__pyx_t_24); + __Pyx_XGIVEREF(__pyx_t_25); + __Pyx_ExceptionReset(__pyx_t_23, __pyx_t_24, __pyx_t_25); + } + __Pyx_XGIVEREF(__pyx_t_20); + __Pyx_XGIVEREF(__pyx_t_21); + __Pyx_XGIVEREF(__pyx_t_22); + __Pyx_ErrRestore(__pyx_t_20, __pyx_t_21, __pyx_t_22); + __pyx_t_20 = 0; __pyx_t_21 = 0; __pyx_t_22 = 0; __pyx_t_23 = 0; __pyx_t_24 = 0; __pyx_t_25 = 0; + __pyx_lineno = __pyx_t_10; __pyx_clineno = __pyx_t_18; __pyx_filename = __pyx_t_19; + goto __pyx_L11_except_error; + } + } + } + goto __pyx_L11_except_error; + __pyx_L11_except_error:; + + /* "asyncpg/protocol/codecs/array.pyx":88 + * elem_data.write_int32(-1) + * else: + * try: # <<<<<<<<<<<<<< + * encoder(settings, elem_data, item, encoder_arg) + * except TypeError as e: + */ + __Pyx_PyThreadState_assign + __Pyx_XGIVEREF(__pyx_t_7); + __Pyx_XGIVEREF(__pyx_t_8); + __Pyx_XGIVEREF(__pyx_t_9); + __Pyx_ExceptionReset(__pyx_t_7, __pyx_t_8, __pyx_t_9); + goto __pyx_L1_error; + __pyx_L16_try_end:; + } + } + __pyx_L8:; + + /* "asyncpg/protocol/codecs/array.pyx":84 + * encoder, encoder_arg) + * else: + * for item in obj: # <<<<<<<<<<<<<< + * if item is None: + * elem_data.write_int32(-1) + */ + } + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } + __pyx_L3:; + + /* "asyncpg/protocol/codecs/array.pyx":76 + * + * + * cdef _write_array_data(ConnectionSettings settings, object obj, int32_t ndims, # <<<<<<<<<<<<<< + * int32_t dim, WriteBuffer elem_data, + * encode_func_ex encoder, const void *encoder_arg): + */ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_XDECREF(__pyx_t_11); + __Pyx_XDECREF(__pyx_t_12); + __Pyx_XDECREF(__pyx_t_13); + __Pyx_XDECREF(__pyx_t_14); + __Pyx_XDECREF(__pyx_t_15); + __Pyx_XDECREF(__pyx_t_16); + __Pyx_XDECREF(__pyx_t_17); + __Pyx_AddTraceback("asyncpg.protocol.protocol._write_array_data", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XDECREF(__pyx_v_item); + __Pyx_XDECREF(__pyx_v_e); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "asyncpg/protocol/codecs/array.pyx":95 + * + * + * cdef inline array_encode(ConnectionSettings settings, WriteBuffer buf, # <<<<<<<<<<<<<< + * object obj, uint32_t elem_oid, + * encode_func_ex encoder, const void *encoder_arg): + */ + +static CYTHON_INLINE PyObject *__pyx_f_7asyncpg_8protocol_8protocol_array_encode(struct __pyx_obj_7asyncpg_8protocol_8protocol_ConnectionSettings *__pyx_v_settings, struct __pyx_obj_7asyncpg_8protocol_8protocol_WriteBuffer *__pyx_v_buf, PyObject *__pyx_v_obj, uint32_t __pyx_v_elem_oid, __pyx_t_7asyncpg_8protocol_8protocol_encode_func_ex __pyx_v_encoder, void const *__pyx_v_encoder_arg) { + struct __pyx_obj_7asyncpg_8protocol_8protocol_WriteBuffer *__pyx_v_elem_data = 0; + int32_t __pyx_v_dims[6]; + int32_t __pyx_v_ndims; + int32_t __pyx_v_i; + PyObject *__pyx_v_item = NULL; + PyObject *__pyx_v_e = NULL; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_t_2; + int __pyx_t_3; + PyObject *__pyx_t_4 = NULL; + PyObject *__pyx_t_5 = NULL; + PyObject *__pyx_t_6 = NULL; + PyObject *__pyx_t_7 = NULL; + int32_t __pyx_t_8; + Py_ssize_t __pyx_t_9; + PyObject *(*__pyx_t_10)(PyObject *); + PyObject *__pyx_t_11 = NULL; + PyObject *__pyx_t_12 = NULL; + PyObject *__pyx_t_13 = NULL; + int __pyx_t_14; + PyObject *__pyx_t_15 = NULL; + PyObject *__pyx_t_16 = NULL; + PyObject *__pyx_t_17 = NULL; + PyObject *__pyx_t_18 = NULL; + PyObject *__pyx_t_19 = NULL; + int __pyx_t_20; + char const *__pyx_t_21; + PyObject *__pyx_t_22 = NULL; + PyObject *__pyx_t_23 = NULL; + PyObject *__pyx_t_24 = NULL; + PyObject *__pyx_t_25 = NULL; + PyObject *__pyx_t_26 = NULL; + PyObject *__pyx_t_27 = NULL; + int32_t __pyx_t_28; + __Pyx_RefNannySetupContext("array_encode", 0); + + /* "asyncpg/protocol/codecs/array.pyx":101 + * WriteBuffer elem_data + * int32_t dims[ARRAY_MAXDIM] + * int32_t ndims = 1 # <<<<<<<<<<<<<< + * int32_t i + * + */ + __pyx_v_ndims = 1; + + /* "asyncpg/protocol/codecs/array.pyx":104 + * int32_t i + * + * if not _is_container(obj): # <<<<<<<<<<<<<< + * raise TypeError( + * 'a non-trivial iterable expected (got type {!r})'.format( + */ + __pyx_t_1 = __pyx_f_7asyncpg_8protocol_8protocol__is_container(__pyx_v_obj); if (unlikely(!__pyx_t_1)) __PYX_ERR(20, 104, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_t_1); if (unlikely(__pyx_t_2 < 0)) __PYX_ERR(20, 104, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_3 = ((!__pyx_t_2) != 0); + if (__pyx_t_3) { + + /* "asyncpg/protocol/codecs/array.pyx":106 + * if not _is_container(obj): + * raise TypeError( + * 'a non-trivial iterable expected (got type {!r})'.format( # <<<<<<<<<<<<<< + * type(obj).__name__)) + * + */ + __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_kp_u_a_non_trivial_iterable_expected, __pyx_n_s_format); if (unlikely(!__pyx_t_4)) __PYX_ERR(20, 106, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + + /* "asyncpg/protocol/codecs/array.pyx":107 + * raise TypeError( + * 'a non-trivial iterable expected (got type {!r})'.format( + * type(obj).__name__)) # <<<<<<<<<<<<<< + * + * _get_array_shape(obj, dims, &ndims) + */ + __pyx_t_5 = __Pyx_PyObject_GetAttrStr(((PyObject *)Py_TYPE(__pyx_v_obj)), __pyx_n_s_name_2); if (unlikely(!__pyx_t_5)) __PYX_ERR(20, 107, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_6 = NULL; + if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_4))) { + __pyx_t_6 = PyMethod_GET_SELF(__pyx_t_4); + if (likely(__pyx_t_6)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4); + __Pyx_INCREF(__pyx_t_6); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_4, function); + } + } + if (!__pyx_t_6) { + __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_t_5); if (unlikely(!__pyx_t_1)) __PYX_ERR(20, 106, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_GOTREF(__pyx_t_1); + } else { + #if CYTHON_FAST_PYCALL + if (PyFunction_Check(__pyx_t_4)) { + PyObject *__pyx_temp[2] = {__pyx_t_6, __pyx_t_5}; + __pyx_t_1 = __Pyx_PyFunction_FastCall(__pyx_t_4, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_1)) __PYX_ERR(20, 106, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + } else + #endif + #if CYTHON_FAST_PYCCALL + if (__Pyx_PyFastCFunction_Check(__pyx_t_4)) { + PyObject *__pyx_temp[2] = {__pyx_t_6, __pyx_t_5}; + __pyx_t_1 = __Pyx_PyCFunction_FastCall(__pyx_t_4, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_1)) __PYX_ERR(20, 106, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + } else + #endif + { + __pyx_t_7 = PyTuple_New(1+1); if (unlikely(!__pyx_t_7)) __PYX_ERR(20, 106, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __Pyx_GIVEREF(__pyx_t_6); PyTuple_SET_ITEM(__pyx_t_7, 0, __pyx_t_6); __pyx_t_6 = NULL; + __Pyx_GIVEREF(__pyx_t_5); + PyTuple_SET_ITEM(__pyx_t_7, 0+1, __pyx_t_5); + __pyx_t_5 = 0; + __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_4, __pyx_t_7, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(20, 106, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + } + } + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + + /* "asyncpg/protocol/codecs/array.pyx":105 + * + * if not _is_container(obj): + * raise TypeError( # <<<<<<<<<<<<<< + * 'a non-trivial iterable expected (got type {!r})'.format( + * type(obj).__name__)) + */ + __pyx_t_4 = PyTuple_New(1); if (unlikely(!__pyx_t_4)) __PYX_ERR(20, 105, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_GIVEREF(__pyx_t_1); + PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_1); + __pyx_t_1 = 0; + __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_t_4, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(20, 105, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_Raise(__pyx_t_1, 0, 0, 0); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __PYX_ERR(20, 105, __pyx_L1_error) + + /* "asyncpg/protocol/codecs/array.pyx":104 + * int32_t i + * + * if not _is_container(obj): # <<<<<<<<<<<<<< + * raise TypeError( + * 'a non-trivial iterable expected (got type {!r})'.format( + */ + } + + /* "asyncpg/protocol/codecs/array.pyx":109 + * type(obj).__name__)) + * + * _get_array_shape(obj, dims, &ndims) # <<<<<<<<<<<<<< + * + * elem_data = WriteBuffer.new() + */ + __pyx_t_1 = __pyx_f_7asyncpg_8protocol_8protocol__get_array_shape(__pyx_v_obj, __pyx_v_dims, (&__pyx_v_ndims)); if (unlikely(!__pyx_t_1)) __PYX_ERR(20, 109, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "asyncpg/protocol/codecs/array.pyx":111 + * _get_array_shape(obj, dims, &ndims) + * + * elem_data = WriteBuffer.new() # <<<<<<<<<<<<<< + * + * if ndims > 1: + */ + __pyx_t_1 = ((PyObject *)__pyx_f_7asyncpg_8protocol_8protocol_11WriteBuffer_new()); if (unlikely(!__pyx_t_1)) __PYX_ERR(20, 111, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_v_elem_data = ((struct __pyx_obj_7asyncpg_8protocol_8protocol_WriteBuffer *)__pyx_t_1); + __pyx_t_1 = 0; + + /* "asyncpg/protocol/codecs/array.pyx":113 + * elem_data = WriteBuffer.new() + * + * if ndims > 1: # <<<<<<<<<<<<<< + * _write_array_data(settings, obj, ndims, 0, elem_data, + * encoder, encoder_arg) + */ + __pyx_t_3 = ((__pyx_v_ndims > 1) != 0); + if (__pyx_t_3) { + + /* "asyncpg/protocol/codecs/array.pyx":114 + * + * if ndims > 1: + * _write_array_data(settings, obj, ndims, 0, elem_data, # <<<<<<<<<<<<<< + * encoder, encoder_arg) + * else: + */ + __pyx_t_1 = __pyx_f_7asyncpg_8protocol_8protocol__write_array_data(__pyx_v_settings, __pyx_v_obj, __pyx_v_ndims, 0, __pyx_v_elem_data, __pyx_v_encoder, __pyx_v_encoder_arg); if (unlikely(!__pyx_t_1)) __PYX_ERR(20, 114, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "asyncpg/protocol/codecs/array.pyx":113 + * elem_data = WriteBuffer.new() + * + * if ndims > 1: # <<<<<<<<<<<<<< + * _write_array_data(settings, obj, ndims, 0, elem_data, + * encoder, encoder_arg) + */ + goto __pyx_L4; + } + + /* "asyncpg/protocol/codecs/array.pyx":117 + * encoder, encoder_arg) + * else: + * for i, item in enumerate(obj): # <<<<<<<<<<<<<< + * if item is None: + * elem_data.write_int32(-1) + */ + /*else*/ { + __pyx_t_8 = 0; + if (likely(PyList_CheckExact(__pyx_v_obj)) || PyTuple_CheckExact(__pyx_v_obj)) { + __pyx_t_1 = __pyx_v_obj; __Pyx_INCREF(__pyx_t_1); __pyx_t_9 = 0; + __pyx_t_10 = NULL; + } else { + __pyx_t_9 = -1; __pyx_t_1 = PyObject_GetIter(__pyx_v_obj); if (unlikely(!__pyx_t_1)) __PYX_ERR(20, 117, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_10 = Py_TYPE(__pyx_t_1)->tp_iternext; if (unlikely(!__pyx_t_10)) __PYX_ERR(20, 117, __pyx_L1_error) + } + for (;;) { + if (likely(!__pyx_t_10)) { + if (likely(PyList_CheckExact(__pyx_t_1))) { + if (__pyx_t_9 >= PyList_GET_SIZE(__pyx_t_1)) break; + #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + __pyx_t_4 = PyList_GET_ITEM(__pyx_t_1, __pyx_t_9); __Pyx_INCREF(__pyx_t_4); __pyx_t_9++; if (unlikely(0 < 0)) __PYX_ERR(20, 117, __pyx_L1_error) + #else + __pyx_t_4 = PySequence_ITEM(__pyx_t_1, __pyx_t_9); __pyx_t_9++; if (unlikely(!__pyx_t_4)) __PYX_ERR(20, 117, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + #endif + } else { + if (__pyx_t_9 >= PyTuple_GET_SIZE(__pyx_t_1)) break; + #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + __pyx_t_4 = PyTuple_GET_ITEM(__pyx_t_1, __pyx_t_9); __Pyx_INCREF(__pyx_t_4); __pyx_t_9++; if (unlikely(0 < 0)) __PYX_ERR(20, 117, __pyx_L1_error) + #else + __pyx_t_4 = PySequence_ITEM(__pyx_t_1, __pyx_t_9); __pyx_t_9++; if (unlikely(!__pyx_t_4)) __PYX_ERR(20, 117, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + #endif + } + } else { + __pyx_t_4 = __pyx_t_10(__pyx_t_1); + if (unlikely(!__pyx_t_4)) { + PyObject* exc_type = PyErr_Occurred(); + if (exc_type) { + if (likely(exc_type == PyExc_StopIteration || PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) PyErr_Clear(); + else __PYX_ERR(20, 117, __pyx_L1_error) + } + break; + } + __Pyx_GOTREF(__pyx_t_4); + } + __Pyx_XDECREF_SET(__pyx_v_item, __pyx_t_4); + __pyx_t_4 = 0; + __pyx_v_i = __pyx_t_8; + __pyx_t_8 = (__pyx_t_8 + 1); + + /* "asyncpg/protocol/codecs/array.pyx":118 + * else: + * for i, item in enumerate(obj): + * if item is None: # <<<<<<<<<<<<<< + * elem_data.write_int32(-1) + * else: + */ + __pyx_t_3 = (__pyx_v_item == Py_None); + __pyx_t_2 = (__pyx_t_3 != 0); + if (__pyx_t_2) { + + /* "asyncpg/protocol/codecs/array.pyx":119 + * for i, item in enumerate(obj): + * if item is None: + * elem_data.write_int32(-1) # <<<<<<<<<<<<<< + * else: + * try: + */ + __pyx_t_4 = __pyx_f_7asyncpg_8protocol_8protocol_11WriteBuffer_write_int32(__pyx_v_elem_data, -1); if (unlikely(!__pyx_t_4)) __PYX_ERR(20, 119, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + + /* "asyncpg/protocol/codecs/array.pyx":118 + * else: + * for i, item in enumerate(obj): + * if item is None: # <<<<<<<<<<<<<< + * elem_data.write_int32(-1) + * else: + */ + goto __pyx_L7; + } + + /* "asyncpg/protocol/codecs/array.pyx":121 + * elem_data.write_int32(-1) + * else: + * try: # <<<<<<<<<<<<<< + * encoder(settings, elem_data, item, encoder_arg) + * except TypeError as e: + */ + /*else*/ { + { + __Pyx_PyThreadState_declare + __Pyx_PyThreadState_assign + __Pyx_ExceptionSave(&__pyx_t_11, &__pyx_t_12, &__pyx_t_13); + __Pyx_XGOTREF(__pyx_t_11); + __Pyx_XGOTREF(__pyx_t_12); + __Pyx_XGOTREF(__pyx_t_13); + /*try:*/ { + + /* "asyncpg/protocol/codecs/array.pyx":122 + * else: + * try: + * encoder(settings, elem_data, item, encoder_arg) # <<<<<<<<<<<<<< + * except TypeError as e: + * raise ValueError( + */ + __pyx_t_4 = __pyx_v_encoder(__pyx_v_settings, __pyx_v_elem_data, __pyx_v_item, __pyx_v_encoder_arg); if (unlikely(!__pyx_t_4)) __PYX_ERR(20, 122, __pyx_L8_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + + /* "asyncpg/protocol/codecs/array.pyx":121 + * elem_data.write_int32(-1) + * else: + * try: # <<<<<<<<<<<<<< + * encoder(settings, elem_data, item, encoder_arg) + * except TypeError as e: + */ + } + __Pyx_XDECREF(__pyx_t_11); __pyx_t_11 = 0; + __Pyx_XDECREF(__pyx_t_12); __pyx_t_12 = 0; + __Pyx_XDECREF(__pyx_t_13); __pyx_t_13 = 0; + goto __pyx_L15_try_end; + __pyx_L8_error:; + __Pyx_PyThreadState_assign + __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + + /* "asyncpg/protocol/codecs/array.pyx":123 + * try: + * encoder(settings, elem_data, item, encoder_arg) + * except TypeError as e: # <<<<<<<<<<<<<< + * raise ValueError( + * 'invalid array element at index {}: {}'.format( + */ + __pyx_t_14 = __Pyx_PyErr_ExceptionMatches(__pyx_builtin_TypeError); + if (__pyx_t_14) { + __Pyx_AddTraceback("asyncpg.protocol.protocol.array_encode", __pyx_clineno, __pyx_lineno, __pyx_filename); + if (__Pyx_GetException(&__pyx_t_4, &__pyx_t_7, &__pyx_t_5) < 0) __PYX_ERR(20, 123, __pyx_L10_except_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_GOTREF(__pyx_t_7); + __Pyx_GOTREF(__pyx_t_5); + __Pyx_INCREF(__pyx_t_7); + __pyx_v_e = __pyx_t_7; + /*try:*/ { + + /* "asyncpg/protocol/codecs/array.pyx":125 + * except TypeError as e: + * raise ValueError( + * 'invalid array element at index {}: {}'.format( # <<<<<<<<<<<<<< + * i, e.args[0])) from None + * + */ + __pyx_t_15 = __Pyx_PyObject_GetAttrStr(__pyx_kp_u_invalid_array_element_at_index, __pyx_n_s_format); if (unlikely(!__pyx_t_15)) __PYX_ERR(20, 125, __pyx_L21_error) + __Pyx_GOTREF(__pyx_t_15); + + /* "asyncpg/protocol/codecs/array.pyx":126 + * raise ValueError( + * 'invalid array element at index {}: {}'.format( + * i, e.args[0])) from None # <<<<<<<<<<<<<< + * + * buf.write_int32(12 + 8 * ndims + elem_data.len()) + */ + __pyx_t_16 = __Pyx_PyInt_From_int32_t(__pyx_v_i); if (unlikely(!__pyx_t_16)) __PYX_ERR(20, 126, __pyx_L21_error) + __Pyx_GOTREF(__pyx_t_16); + __pyx_t_17 = __Pyx_PyObject_GetAttrStr(__pyx_v_e, __pyx_n_s_args); if (unlikely(!__pyx_t_17)) __PYX_ERR(20, 126, __pyx_L21_error) + __Pyx_GOTREF(__pyx_t_17); + __pyx_t_18 = __Pyx_GetItemInt(__pyx_t_17, 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_18)) __PYX_ERR(20, 126, __pyx_L21_error) + __Pyx_GOTREF(__pyx_t_18); + __Pyx_DECREF(__pyx_t_17); __pyx_t_17 = 0; + __pyx_t_17 = NULL; + __pyx_t_14 = 0; + if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_15))) { + __pyx_t_17 = PyMethod_GET_SELF(__pyx_t_15); + if (likely(__pyx_t_17)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_15); + __Pyx_INCREF(__pyx_t_17); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_15, function); + __pyx_t_14 = 1; + } + } + #if CYTHON_FAST_PYCALL + if (PyFunction_Check(__pyx_t_15)) { + PyObject *__pyx_temp[3] = {__pyx_t_17, __pyx_t_16, __pyx_t_18}; + __pyx_t_6 = __Pyx_PyFunction_FastCall(__pyx_t_15, __pyx_temp+1-__pyx_t_14, 2+__pyx_t_14); if (unlikely(!__pyx_t_6)) __PYX_ERR(20, 125, __pyx_L21_error) + __Pyx_XDECREF(__pyx_t_17); __pyx_t_17 = 0; + __Pyx_GOTREF(__pyx_t_6); + __Pyx_DECREF(__pyx_t_16); __pyx_t_16 = 0; + __Pyx_DECREF(__pyx_t_18); __pyx_t_18 = 0; + } else + #endif + #if CYTHON_FAST_PYCCALL + if (__Pyx_PyFastCFunction_Check(__pyx_t_15)) { + PyObject *__pyx_temp[3] = {__pyx_t_17, __pyx_t_16, __pyx_t_18}; + __pyx_t_6 = __Pyx_PyCFunction_FastCall(__pyx_t_15, __pyx_temp+1-__pyx_t_14, 2+__pyx_t_14); if (unlikely(!__pyx_t_6)) __PYX_ERR(20, 125, __pyx_L21_error) + __Pyx_XDECREF(__pyx_t_17); __pyx_t_17 = 0; + __Pyx_GOTREF(__pyx_t_6); + __Pyx_DECREF(__pyx_t_16); __pyx_t_16 = 0; + __Pyx_DECREF(__pyx_t_18); __pyx_t_18 = 0; + } else + #endif + { + __pyx_t_19 = PyTuple_New(2+__pyx_t_14); if (unlikely(!__pyx_t_19)) __PYX_ERR(20, 125, __pyx_L21_error) + __Pyx_GOTREF(__pyx_t_19); + if (__pyx_t_17) { + __Pyx_GIVEREF(__pyx_t_17); PyTuple_SET_ITEM(__pyx_t_19, 0, __pyx_t_17); __pyx_t_17 = NULL; + } + __Pyx_GIVEREF(__pyx_t_16); + PyTuple_SET_ITEM(__pyx_t_19, 0+__pyx_t_14, __pyx_t_16); + __Pyx_GIVEREF(__pyx_t_18); + PyTuple_SET_ITEM(__pyx_t_19, 1+__pyx_t_14, __pyx_t_18); + __pyx_t_16 = 0; + __pyx_t_18 = 0; + __pyx_t_6 = __Pyx_PyObject_Call(__pyx_t_15, __pyx_t_19, NULL); if (unlikely(!__pyx_t_6)) __PYX_ERR(20, 125, __pyx_L21_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_DECREF(__pyx_t_19); __pyx_t_19 = 0; + } + __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0; + + /* "asyncpg/protocol/codecs/array.pyx":124 + * encoder(settings, elem_data, item, encoder_arg) + * except TypeError as e: + * raise ValueError( # <<<<<<<<<<<<<< + * 'invalid array element at index {}: {}'.format( + * i, e.args[0])) from None + */ + __pyx_t_15 = PyTuple_New(1); if (unlikely(!__pyx_t_15)) __PYX_ERR(20, 124, __pyx_L21_error) + __Pyx_GOTREF(__pyx_t_15); + __Pyx_GIVEREF(__pyx_t_6); + PyTuple_SET_ITEM(__pyx_t_15, 0, __pyx_t_6); + __pyx_t_6 = 0; + __pyx_t_6 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_t_15, NULL); if (unlikely(!__pyx_t_6)) __PYX_ERR(20, 124, __pyx_L21_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0; + + /* "asyncpg/protocol/codecs/array.pyx":126 + * raise ValueError( + * 'invalid array element at index {}: {}'.format( + * i, e.args[0])) from None # <<<<<<<<<<<<<< + * + * buf.write_int32(12 + 8 * ndims + elem_data.len()) + */ + __Pyx_Raise(__pyx_t_6, 0, 0, Py_None); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __PYX_ERR(20, 124, __pyx_L21_error) + } + + /* "asyncpg/protocol/codecs/array.pyx":123 + * try: + * encoder(settings, elem_data, item, encoder_arg) + * except TypeError as e: # <<<<<<<<<<<<<< + * raise ValueError( + * 'invalid array element at index {}: {}'.format( + */ + /*finally:*/ { + /*exception exit:*/{ + __Pyx_PyThreadState_declare + __pyx_L21_error:; + __pyx_t_22 = 0; __pyx_t_23 = 0; __pyx_t_24 = 0; __pyx_t_25 = 0; __pyx_t_26 = 0; __pyx_t_27 = 0; + __Pyx_PyThreadState_assign + __Pyx_XDECREF(__pyx_t_17); __pyx_t_17 = 0; + __Pyx_XDECREF(__pyx_t_16); __pyx_t_16 = 0; + __Pyx_XDECREF(__pyx_t_18); __pyx_t_18 = 0; + __Pyx_XDECREF(__pyx_t_19); __pyx_t_19 = 0; + __Pyx_XDECREF(__pyx_t_15); __pyx_t_15 = 0; + __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; + if (PY_MAJOR_VERSION >= 3) __Pyx_ExceptionSwap(&__pyx_t_25, &__pyx_t_26, &__pyx_t_27); + if ((PY_MAJOR_VERSION < 3) || unlikely(__Pyx_GetException(&__pyx_t_22, &__pyx_t_23, &__pyx_t_24) < 0)) __Pyx_ErrFetch(&__pyx_t_22, &__pyx_t_23, &__pyx_t_24); + __Pyx_XGOTREF(__pyx_t_22); + __Pyx_XGOTREF(__pyx_t_23); + __Pyx_XGOTREF(__pyx_t_24); + __Pyx_XGOTREF(__pyx_t_25); + __Pyx_XGOTREF(__pyx_t_26); + __Pyx_XGOTREF(__pyx_t_27); + __pyx_t_14 = __pyx_lineno; __pyx_t_20 = __pyx_clineno; __pyx_t_21 = __pyx_filename; + { + __Pyx_DECREF(__pyx_v_e); + __pyx_v_e = NULL; + } + __Pyx_PyThreadState_assign + if (PY_MAJOR_VERSION >= 3) { + __Pyx_XGIVEREF(__pyx_t_25); + __Pyx_XGIVEREF(__pyx_t_26); + __Pyx_XGIVEREF(__pyx_t_27); + __Pyx_ExceptionReset(__pyx_t_25, __pyx_t_26, __pyx_t_27); + } + __Pyx_XGIVEREF(__pyx_t_22); + __Pyx_XGIVEREF(__pyx_t_23); + __Pyx_XGIVEREF(__pyx_t_24); + __Pyx_ErrRestore(__pyx_t_22, __pyx_t_23, __pyx_t_24); + __pyx_t_22 = 0; __pyx_t_23 = 0; __pyx_t_24 = 0; __pyx_t_25 = 0; __pyx_t_26 = 0; __pyx_t_27 = 0; + __pyx_lineno = __pyx_t_14; __pyx_clineno = __pyx_t_20; __pyx_filename = __pyx_t_21; + goto __pyx_L10_except_error; + } + } + } + goto __pyx_L10_except_error; + __pyx_L10_except_error:; + + /* "asyncpg/protocol/codecs/array.pyx":121 + * elem_data.write_int32(-1) + * else: + * try: # <<<<<<<<<<<<<< + * encoder(settings, elem_data, item, encoder_arg) + * except TypeError as e: + */ + __Pyx_PyThreadState_assign + __Pyx_XGIVEREF(__pyx_t_11); + __Pyx_XGIVEREF(__pyx_t_12); + __Pyx_XGIVEREF(__pyx_t_13); + __Pyx_ExceptionReset(__pyx_t_11, __pyx_t_12, __pyx_t_13); + goto __pyx_L1_error; + __pyx_L15_try_end:; + } + } + __pyx_L7:; + + /* "asyncpg/protocol/codecs/array.pyx":117 + * encoder, encoder_arg) + * else: + * for i, item in enumerate(obj): # <<<<<<<<<<<<<< + * if item is None: + * elem_data.write_int32(-1) + */ + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + } + __pyx_L4:; + + /* "asyncpg/protocol/codecs/array.pyx":128 + * i, e.args[0])) from None + * + * buf.write_int32(12 + 8 * ndims + elem_data.len()) # <<<<<<<<<<<<<< + * # Number of dimensions + * buf.write_int32(ndims) + */ + __pyx_t_1 = __Pyx_PyInt_From_long((12 + (8 * __pyx_v_ndims))); if (unlikely(!__pyx_t_1)) __PYX_ERR(20, 128, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_5 = __pyx_f_7asyncpg_8protocol_8protocol_11WriteBuffer_len(__pyx_v_elem_data); if (unlikely(!__pyx_t_5)) __PYX_ERR(20, 128, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_7 = PyNumber_Add(__pyx_t_1, __pyx_t_5); if (unlikely(!__pyx_t_7)) __PYX_ERR(20, 128, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __pyx_t_8 = __Pyx_PyInt_As_int32_t(__pyx_t_7); if (unlikely((__pyx_t_8 == ((int32_t)-1)) && PyErr_Occurred())) __PYX_ERR(20, 128, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __pyx_t_7 = __pyx_f_7asyncpg_8protocol_8protocol_11WriteBuffer_write_int32(__pyx_v_buf, __pyx_t_8); if (unlikely(!__pyx_t_7)) __PYX_ERR(20, 128, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + + /* "asyncpg/protocol/codecs/array.pyx":130 + * buf.write_int32(12 + 8 * ndims + elem_data.len()) + * # Number of dimensions + * buf.write_int32(ndims) # <<<<<<<<<<<<<< + * # flags + * buf.write_int32(0) + */ + __pyx_t_7 = __pyx_f_7asyncpg_8protocol_8protocol_11WriteBuffer_write_int32(__pyx_v_buf, __pyx_v_ndims); if (unlikely(!__pyx_t_7)) __PYX_ERR(20, 130, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + + /* "asyncpg/protocol/codecs/array.pyx":132 + * buf.write_int32(ndims) + * # flags + * buf.write_int32(0) # <<<<<<<<<<<<<< + * # element type + * buf.write_int32(elem_oid) + */ + __pyx_t_7 = __pyx_f_7asyncpg_8protocol_8protocol_11WriteBuffer_write_int32(__pyx_v_buf, 0); if (unlikely(!__pyx_t_7)) __PYX_ERR(20, 132, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + + /* "asyncpg/protocol/codecs/array.pyx":134 + * buf.write_int32(0) + * # element type + * buf.write_int32(elem_oid) # <<<<<<<<<<<<<< + * # upper / lower bounds + * for i in range(ndims): + */ + __pyx_t_7 = __pyx_f_7asyncpg_8protocol_8protocol_11WriteBuffer_write_int32(__pyx_v_buf, ((int32_t)__pyx_v_elem_oid)); if (unlikely(!__pyx_t_7)) __PYX_ERR(20, 134, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + + /* "asyncpg/protocol/codecs/array.pyx":136 + * buf.write_int32(elem_oid) + * # upper / lower bounds + * for i in range(ndims): # <<<<<<<<<<<<<< + * buf.write_int32(dims[i]) + * buf.write_int32(1) + */ + __pyx_t_8 = __pyx_v_ndims; + for (__pyx_t_28 = 0; __pyx_t_28 < __pyx_t_8; __pyx_t_28+=1) { + __pyx_v_i = __pyx_t_28; + + /* "asyncpg/protocol/codecs/array.pyx":137 + * # upper / lower bounds + * for i in range(ndims): + * buf.write_int32(dims[i]) # <<<<<<<<<<<<<< + * buf.write_int32(1) + * # element data + */ + __pyx_t_7 = __pyx_f_7asyncpg_8protocol_8protocol_11WriteBuffer_write_int32(__pyx_v_buf, (__pyx_v_dims[__pyx_v_i])); if (unlikely(!__pyx_t_7)) __PYX_ERR(20, 137, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + + /* "asyncpg/protocol/codecs/array.pyx":138 + * for i in range(ndims): + * buf.write_int32(dims[i]) + * buf.write_int32(1) # <<<<<<<<<<<<<< + * # element data + * buf.write_buffer(elem_data) + */ + __pyx_t_7 = __pyx_f_7asyncpg_8protocol_8protocol_11WriteBuffer_write_int32(__pyx_v_buf, 1); if (unlikely(!__pyx_t_7)) __PYX_ERR(20, 138, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + } + + /* "asyncpg/protocol/codecs/array.pyx":140 + * buf.write_int32(1) + * # element data + * buf.write_buffer(elem_data) # <<<<<<<<<<<<<< + * + * + */ + __pyx_t_7 = __pyx_f_7asyncpg_8protocol_8protocol_11WriteBuffer_write_buffer(__pyx_v_buf, __pyx_v_elem_data); if (unlikely(!__pyx_t_7)) __PYX_ERR(20, 140, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + + /* "asyncpg/protocol/codecs/array.pyx":95 + * + * + * cdef inline array_encode(ConnectionSettings settings, WriteBuffer buf, # <<<<<<<<<<<<<< + * object obj, uint32_t elem_oid, + * encode_func_ex encoder, const void *encoder_arg): + */ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_XDECREF(__pyx_t_6); + __Pyx_XDECREF(__pyx_t_7); + __Pyx_XDECREF(__pyx_t_15); + __Pyx_XDECREF(__pyx_t_16); + __Pyx_XDECREF(__pyx_t_17); + __Pyx_XDECREF(__pyx_t_18); + __Pyx_XDECREF(__pyx_t_19); + __Pyx_AddTraceback("asyncpg.protocol.protocol.array_encode", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XDECREF((PyObject *)__pyx_v_elem_data); + __Pyx_XDECREF(__pyx_v_item); + __Pyx_XDECREF(__pyx_v_e); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "asyncpg/protocol/codecs/array.pyx":143 + * + * + * cdef inline array_decode(ConnectionSettings settings, FastReadBuffer buf, # <<<<<<<<<<<<<< + * decode_func_ex decoder, const void *decoder_arg): + * cdef: + */ + +static CYTHON_INLINE PyObject *__pyx_f_7asyncpg_8protocol_8protocol_array_decode(struct __pyx_obj_7asyncpg_8protocol_8protocol_ConnectionSettings *__pyx_v_settings, struct __pyx_obj_7asyncpg_8protocol_8protocol_FastReadBuffer *__pyx_v_buf, __pyx_t_7asyncpg_8protocol_8protocol_decode_func_ex __pyx_v_decoder, void const *__pyx_v_decoder_arg) { + int32_t __pyx_v_ndims; + CYTHON_UNUSED int32_t __pyx_v_flags; + uint32_t __pyx_v_elem_oid; + PyObject *__pyx_v_result = 0; + int __pyx_v_i; + int32_t __pyx_v_elem_len; + int32_t __pyx_v_elem_count; + struct __pyx_obj_7asyncpg_8protocol_8protocol_FastReadBuffer *__pyx_v_elem_buf = 0; + int32_t __pyx_v_dims[6]; + struct __pyx_obj_7asyncpg_8protocol_8protocol_Codec *__pyx_v_elem_codec = 0; + PyObject *__pyx_v_elem = NULL; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + char const *__pyx_t_1; + PyObject *__pyx_t_2 = NULL; + int __pyx_t_3; + PyObject *__pyx_t_4 = NULL; + PyObject *__pyx_t_5 = NULL; + PyObject *__pyx_t_6 = NULL; + int __pyx_t_7; + PyObject *__pyx_t_8 = NULL; + int __pyx_t_9; + int __pyx_t_10; + int32_t __pyx_t_11; + __Pyx_RefNannySetupContext("array_decode", 0); + + /* "asyncpg/protocol/codecs/array.pyx":146 + * decode_func_ex decoder, const void *decoder_arg): + * cdef: + * int32_t ndims = hton.unpack_int32(buf.read(4)) # <<<<<<<<<<<<<< + * int32_t flags = hton.unpack_int32(buf.read(4)) + * uint32_t elem_oid = hton.unpack_int32(buf.read(4)) + */ + __pyx_t_1 = __pyx_f_7asyncpg_8protocol_8protocol_14FastReadBuffer_read(__pyx_v_buf, 4); if (unlikely(__pyx_t_1 == NULL)) __PYX_ERR(20, 146, __pyx_L1_error) + __pyx_v_ndims = __pyx_f_7asyncpg_8protocol_4hton_unpack_int32(__pyx_t_1); + + /* "asyncpg/protocol/codecs/array.pyx":147 + * cdef: + * int32_t ndims = hton.unpack_int32(buf.read(4)) + * int32_t flags = hton.unpack_int32(buf.read(4)) # <<<<<<<<<<<<<< + * uint32_t elem_oid = hton.unpack_int32(buf.read(4)) + * list result + */ + __pyx_t_1 = __pyx_f_7asyncpg_8protocol_8protocol_14FastReadBuffer_read(__pyx_v_buf, 4); if (unlikely(__pyx_t_1 == NULL)) __PYX_ERR(20, 147, __pyx_L1_error) + __pyx_v_flags = __pyx_f_7asyncpg_8protocol_4hton_unpack_int32(__pyx_t_1); + + /* "asyncpg/protocol/codecs/array.pyx":148 + * int32_t ndims = hton.unpack_int32(buf.read(4)) + * int32_t flags = hton.unpack_int32(buf.read(4)) + * uint32_t elem_oid = hton.unpack_int32(buf.read(4)) # <<<<<<<<<<<<<< + * list result + * int i + */ + __pyx_t_1 = __pyx_f_7asyncpg_8protocol_8protocol_14FastReadBuffer_read(__pyx_v_buf, 4); if (unlikely(__pyx_t_1 == NULL)) __PYX_ERR(20, 148, __pyx_L1_error) + __pyx_v_elem_oid = ((uint32_t)__pyx_f_7asyncpg_8protocol_4hton_unpack_int32(__pyx_t_1)); + + /* "asyncpg/protocol/codecs/array.pyx":152 + * int i + * int32_t elem_len + * int32_t elem_count = 1 # <<<<<<<<<<<<<< + * FastReadBuffer elem_buf = FastReadBuffer.new() + * int32_t dims[ARRAY_MAXDIM] + */ + __pyx_v_elem_count = 1; + + /* "asyncpg/protocol/codecs/array.pyx":153 + * int32_t elem_len + * int32_t elem_count = 1 + * FastReadBuffer elem_buf = FastReadBuffer.new() # <<<<<<<<<<<<<< + * int32_t dims[ARRAY_MAXDIM] + * Codec elem_codec + */ + __pyx_t_2 = ((PyObject *)__pyx_f_7asyncpg_8protocol_8protocol_14FastReadBuffer_new()); if (unlikely(!__pyx_t_2)) __PYX_ERR(20, 153, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_v_elem_buf = ((struct __pyx_obj_7asyncpg_8protocol_8protocol_FastReadBuffer *)__pyx_t_2); + __pyx_t_2 = 0; + + /* "asyncpg/protocol/codecs/array.pyx":157 + * Codec elem_codec + * + * if ndims == 0: # <<<<<<<<<<<<<< + * result = cpython.PyList_New(0) + * return result + */ + __pyx_t_3 = ((__pyx_v_ndims == 0) != 0); + if (__pyx_t_3) { + + /* "asyncpg/protocol/codecs/array.pyx":158 + * + * if ndims == 0: + * result = cpython.PyList_New(0) # <<<<<<<<<<<<<< + * return result + * + */ + __pyx_t_2 = PyList_New(0); if (unlikely(!__pyx_t_2)) __PYX_ERR(20, 158, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_v_result = ((PyObject*)__pyx_t_2); + __pyx_t_2 = 0; + + /* "asyncpg/protocol/codecs/array.pyx":159 + * if ndims == 0: + * result = cpython.PyList_New(0) + * return result # <<<<<<<<<<<<<< + * + * if ndims > ARRAY_MAXDIM: + */ + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(__pyx_v_result); + __pyx_r = __pyx_v_result; + goto __pyx_L0; + + /* "asyncpg/protocol/codecs/array.pyx":157 + * Codec elem_codec + * + * if ndims == 0: # <<<<<<<<<<<<<< + * result = cpython.PyList_New(0) + * return result + */ + } + + /* "asyncpg/protocol/codecs/array.pyx":161 + * return result + * + * if ndims > ARRAY_MAXDIM: # <<<<<<<<<<<<<< + * raise RuntimeError( + * 'number of array dimensions ({}) exceed the maximum expected ({})'. + */ + __pyx_t_3 = ((__pyx_v_ndims > 6) != 0); + if (__pyx_t_3) { + + /* "asyncpg/protocol/codecs/array.pyx":163 + * if ndims > ARRAY_MAXDIM: + * raise RuntimeError( + * 'number of array dimensions ({}) exceed the maximum expected ({})'. # <<<<<<<<<<<<<< + * format(ndims, ARRAY_MAXDIM)) + * + */ + __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_kp_u_number_of_array_dimensions_excee, __pyx_n_s_format); if (unlikely(!__pyx_t_4)) __PYX_ERR(20, 163, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + + /* "asyncpg/protocol/codecs/array.pyx":164 + * raise RuntimeError( + * 'number of array dimensions ({}) exceed the maximum expected ({})'. + * format(ndims, ARRAY_MAXDIM)) # <<<<<<<<<<<<<< + * + * if decoder == NULL: + */ + __pyx_t_5 = __Pyx_PyInt_From_int32_t(__pyx_v_ndims); if (unlikely(!__pyx_t_5)) __PYX_ERR(20, 164, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_6 = NULL; + __pyx_t_7 = 0; + if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_4))) { + __pyx_t_6 = PyMethod_GET_SELF(__pyx_t_4); + if (likely(__pyx_t_6)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4); + __Pyx_INCREF(__pyx_t_6); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_4, function); + __pyx_t_7 = 1; + } + } + #if CYTHON_FAST_PYCALL + if (PyFunction_Check(__pyx_t_4)) { + PyObject *__pyx_temp[3] = {__pyx_t_6, __pyx_t_5, __pyx_int_6}; + __pyx_t_2 = __Pyx_PyFunction_FastCall(__pyx_t_4, __pyx_temp+1-__pyx_t_7, 2+__pyx_t_7); if (unlikely(!__pyx_t_2)) __PYX_ERR(20, 164, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + } else + #endif + #if CYTHON_FAST_PYCCALL + if (__Pyx_PyFastCFunction_Check(__pyx_t_4)) { + PyObject *__pyx_temp[3] = {__pyx_t_6, __pyx_t_5, __pyx_int_6}; + __pyx_t_2 = __Pyx_PyCFunction_FastCall(__pyx_t_4, __pyx_temp+1-__pyx_t_7, 2+__pyx_t_7); if (unlikely(!__pyx_t_2)) __PYX_ERR(20, 164, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + } else + #endif + { + __pyx_t_8 = PyTuple_New(2+__pyx_t_7); if (unlikely(!__pyx_t_8)) __PYX_ERR(20, 164, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + if (__pyx_t_6) { + __Pyx_GIVEREF(__pyx_t_6); PyTuple_SET_ITEM(__pyx_t_8, 0, __pyx_t_6); __pyx_t_6 = NULL; + } + __Pyx_GIVEREF(__pyx_t_5); + PyTuple_SET_ITEM(__pyx_t_8, 0+__pyx_t_7, __pyx_t_5); + __Pyx_INCREF(__pyx_int_6); + __Pyx_GIVEREF(__pyx_int_6); + PyTuple_SET_ITEM(__pyx_t_8, 1+__pyx_t_7, __pyx_int_6); + __pyx_t_5 = 0; + __pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_4, __pyx_t_8, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(20, 164, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + } + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + + /* "asyncpg/protocol/codecs/array.pyx":162 + * + * if ndims > ARRAY_MAXDIM: + * raise RuntimeError( # <<<<<<<<<<<<<< + * 'number of array dimensions ({}) exceed the maximum expected ({})'. + * format(ndims, ARRAY_MAXDIM)) + */ + __pyx_t_4 = PyTuple_New(1); if (unlikely(!__pyx_t_4)) __PYX_ERR(20, 162, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_GIVEREF(__pyx_t_2); + PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_2); + __pyx_t_2 = 0; + __pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_RuntimeError, __pyx_t_4, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(20, 162, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_Raise(__pyx_t_2, 0, 0, 0); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __PYX_ERR(20, 162, __pyx_L1_error) + + /* "asyncpg/protocol/codecs/array.pyx":161 + * return result + * + * if ndims > ARRAY_MAXDIM: # <<<<<<<<<<<<<< + * raise RuntimeError( + * 'number of array dimensions ({}) exceed the maximum expected ({})'. + */ + } + + /* "asyncpg/protocol/codecs/array.pyx":166 + * format(ndims, ARRAY_MAXDIM)) + * + * if decoder == NULL: # <<<<<<<<<<<<<< + * # No decoder is known beforehand, look it up + * + */ + __pyx_t_3 = ((__pyx_v_decoder == NULL) != 0); + if (__pyx_t_3) { + + /* "asyncpg/protocol/codecs/array.pyx":169 + * # No decoder is known beforehand, look it up + * + * elem_codec = settings.get_data_codec(elem_oid) # <<<<<<<<<<<<<< + * if elem_codec is None or not elem_codec.has_decoder(): + * raise RuntimeError( + */ + __pyx_t_2 = ((PyObject *)__pyx_f_7asyncpg_8protocol_8protocol_18ConnectionSettings_get_data_codec(__pyx_v_settings, __pyx_v_elem_oid, 0, NULL)); if (unlikely(!__pyx_t_2)) __PYX_ERR(20, 169, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_v_elem_codec = ((struct __pyx_obj_7asyncpg_8protocol_8protocol_Codec *)__pyx_t_2); + __pyx_t_2 = 0; + + /* "asyncpg/protocol/codecs/array.pyx":170 + * + * elem_codec = settings.get_data_codec(elem_oid) + * if elem_codec is None or not elem_codec.has_decoder(): # <<<<<<<<<<<<<< + * raise RuntimeError( + * 'no decoder for type OID {}'.format(elem_oid)) + */ + __pyx_t_9 = (((PyObject *)__pyx_v_elem_codec) == Py_None); + __pyx_t_10 = (__pyx_t_9 != 0); + if (!__pyx_t_10) { + } else { + __pyx_t_3 = __pyx_t_10; + goto __pyx_L7_bool_binop_done; + } + __pyx_t_2 = __pyx_f_7asyncpg_8protocol_8protocol_5Codec_has_decoder(__pyx_v_elem_codec); if (unlikely(!__pyx_t_2)) __PYX_ERR(20, 170, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_10 = __Pyx_PyObject_IsTrue(__pyx_t_2); if (unlikely(__pyx_t_10 < 0)) __PYX_ERR(20, 170, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_9 = ((!__pyx_t_10) != 0); + __pyx_t_3 = __pyx_t_9; + __pyx_L7_bool_binop_done:; + if (__pyx_t_3) { + + /* "asyncpg/protocol/codecs/array.pyx":172 + * if elem_codec is None or not elem_codec.has_decoder(): + * raise RuntimeError( + * 'no decoder for type OID {}'.format(elem_oid)) # <<<<<<<<<<<<<< + * + * decoder = codec_decode_func_ex + */ + __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_kp_u_no_decoder_for_type_OID, __pyx_n_s_format); if (unlikely(!__pyx_t_4)) __PYX_ERR(20, 172, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_8 = __Pyx_PyInt_From_uint32_t(__pyx_v_elem_oid); if (unlikely(!__pyx_t_8)) __PYX_ERR(20, 172, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __pyx_t_5 = NULL; + if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_4))) { + __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_4); + if (likely(__pyx_t_5)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4); + __Pyx_INCREF(__pyx_t_5); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_4, function); + } + } + if (!__pyx_t_5) { + __pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_t_8); if (unlikely(!__pyx_t_2)) __PYX_ERR(20, 172, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + __Pyx_GOTREF(__pyx_t_2); + } else { + #if CYTHON_FAST_PYCALL + if (PyFunction_Check(__pyx_t_4)) { + PyObject *__pyx_temp[2] = {__pyx_t_5, __pyx_t_8}; + __pyx_t_2 = __Pyx_PyFunction_FastCall(__pyx_t_4, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_2)) __PYX_ERR(20, 172, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + } else + #endif + #if CYTHON_FAST_PYCCALL + if (__Pyx_PyFastCFunction_Check(__pyx_t_4)) { + PyObject *__pyx_temp[2] = {__pyx_t_5, __pyx_t_8}; + __pyx_t_2 = __Pyx_PyCFunction_FastCall(__pyx_t_4, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_2)) __PYX_ERR(20, 172, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + } else + #endif + { + __pyx_t_6 = PyTuple_New(1+1); if (unlikely(!__pyx_t_6)) __PYX_ERR(20, 172, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_GIVEREF(__pyx_t_5); PyTuple_SET_ITEM(__pyx_t_6, 0, __pyx_t_5); __pyx_t_5 = NULL; + __Pyx_GIVEREF(__pyx_t_8); + PyTuple_SET_ITEM(__pyx_t_6, 0+1, __pyx_t_8); + __pyx_t_8 = 0; + __pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_4, __pyx_t_6, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(20, 172, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + } + } + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + + /* "asyncpg/protocol/codecs/array.pyx":171 + * elem_codec = settings.get_data_codec(elem_oid) + * if elem_codec is None or not elem_codec.has_decoder(): + * raise RuntimeError( # <<<<<<<<<<<<<< + * 'no decoder for type OID {}'.format(elem_oid)) + * + */ + __pyx_t_4 = PyTuple_New(1); if (unlikely(!__pyx_t_4)) __PYX_ERR(20, 171, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_GIVEREF(__pyx_t_2); + PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_2); + __pyx_t_2 = 0; + __pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_RuntimeError, __pyx_t_4, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(20, 171, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_Raise(__pyx_t_2, 0, 0, 0); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __PYX_ERR(20, 171, __pyx_L1_error) + + /* "asyncpg/protocol/codecs/array.pyx":170 + * + * elem_codec = settings.get_data_codec(elem_oid) + * if elem_codec is None or not elem_codec.has_decoder(): # <<<<<<<<<<<<<< + * raise RuntimeError( + * 'no decoder for type OID {}'.format(elem_oid)) + */ + } + + /* "asyncpg/protocol/codecs/array.pyx":174 + * 'no decoder for type OID {}'.format(elem_oid)) + * + * decoder = codec_decode_func_ex # <<<<<<<<<<<<<< + * decoder_arg = (elem_codec) + * + */ + __pyx_v_decoder = __pyx_f_7asyncpg_8protocol_8protocol_codec_decode_func_ex; + + /* "asyncpg/protocol/codecs/array.pyx":175 + * + * decoder = codec_decode_func_ex + * decoder_arg = (elem_codec) # <<<<<<<<<<<<<< + * + * for i in range(ndims): + */ + __pyx_v_decoder_arg = ((void *)__pyx_v_elem_codec); + + /* "asyncpg/protocol/codecs/array.pyx":166 + * format(ndims, ARRAY_MAXDIM)) + * + * if decoder == NULL: # <<<<<<<<<<<<<< + * # No decoder is known beforehand, look it up + * + */ + } + + /* "asyncpg/protocol/codecs/array.pyx":177 + * decoder_arg = (elem_codec) + * + * for i in range(ndims): # <<<<<<<<<<<<<< + * dims[i] = hton.unpack_int32(buf.read(4)) + * # Ignore the lower bound information + */ + __pyx_t_11 = __pyx_v_ndims; + for (__pyx_t_7 = 0; __pyx_t_7 < __pyx_t_11; __pyx_t_7+=1) { + __pyx_v_i = __pyx_t_7; + + /* "asyncpg/protocol/codecs/array.pyx":178 + * + * for i in range(ndims): + * dims[i] = hton.unpack_int32(buf.read(4)) # <<<<<<<<<<<<<< + * # Ignore the lower bound information + * buf.read(4) + */ + __pyx_t_1 = __pyx_f_7asyncpg_8protocol_8protocol_14FastReadBuffer_read(__pyx_v_buf, 4); if (unlikely(__pyx_t_1 == NULL)) __PYX_ERR(20, 178, __pyx_L1_error) + (__pyx_v_dims[__pyx_v_i]) = __pyx_f_7asyncpg_8protocol_4hton_unpack_int32(__pyx_t_1); + + /* "asyncpg/protocol/codecs/array.pyx":180 + * dims[i] = hton.unpack_int32(buf.read(4)) + * # Ignore the lower bound information + * buf.read(4) # <<<<<<<<<<<<<< + * + * if ndims == 1: + */ + __pyx_t_1 = __pyx_f_7asyncpg_8protocol_8protocol_14FastReadBuffer_read(__pyx_v_buf, 4); if (unlikely(__pyx_t_1 == NULL)) __PYX_ERR(20, 180, __pyx_L1_error) + } + + /* "asyncpg/protocol/codecs/array.pyx":182 + * buf.read(4) + * + * if ndims == 1: # <<<<<<<<<<<<<< + * # Fast path for flat arrays + * elem_count = dims[0] + */ + __pyx_t_3 = ((__pyx_v_ndims == 1) != 0); + if (__pyx_t_3) { + + /* "asyncpg/protocol/codecs/array.pyx":184 + * if ndims == 1: + * # Fast path for flat arrays + * elem_count = dims[0] # <<<<<<<<<<<<<< + * result = cpython.PyList_New(elem_count) + * + */ + __pyx_v_elem_count = (__pyx_v_dims[0]); + + /* "asyncpg/protocol/codecs/array.pyx":185 + * # Fast path for flat arrays + * elem_count = dims[0] + * result = cpython.PyList_New(elem_count) # <<<<<<<<<<<<<< + * + * for i in range(elem_count): + */ + __pyx_t_2 = PyList_New(__pyx_v_elem_count); if (unlikely(!__pyx_t_2)) __PYX_ERR(20, 185, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_v_result = ((PyObject*)__pyx_t_2); + __pyx_t_2 = 0; + + /* "asyncpg/protocol/codecs/array.pyx":187 + * result = cpython.PyList_New(elem_count) + * + * for i in range(elem_count): # <<<<<<<<<<<<<< + * elem_len = hton.unpack_int32(buf.read(4)) + * if elem_len == -1: + */ + __pyx_t_11 = __pyx_v_elem_count; + for (__pyx_t_7 = 0; __pyx_t_7 < __pyx_t_11; __pyx_t_7+=1) { + __pyx_v_i = __pyx_t_7; + + /* "asyncpg/protocol/codecs/array.pyx":188 + * + * for i in range(elem_count): + * elem_len = hton.unpack_int32(buf.read(4)) # <<<<<<<<<<<<<< + * if elem_len == -1: + * elem = None + */ + __pyx_t_1 = __pyx_f_7asyncpg_8protocol_8protocol_14FastReadBuffer_read(__pyx_v_buf, 4); if (unlikely(__pyx_t_1 == NULL)) __PYX_ERR(20, 188, __pyx_L1_error) + __pyx_v_elem_len = __pyx_f_7asyncpg_8protocol_4hton_unpack_int32(__pyx_t_1); + + /* "asyncpg/protocol/codecs/array.pyx":189 + * for i in range(elem_count): + * elem_len = hton.unpack_int32(buf.read(4)) + * if elem_len == -1: # <<<<<<<<<<<<<< + * elem = None + * else: + */ + __pyx_t_3 = ((__pyx_v_elem_len == -1L) != 0); + if (__pyx_t_3) { + + /* "asyncpg/protocol/codecs/array.pyx":190 + * elem_len = hton.unpack_int32(buf.read(4)) + * if elem_len == -1: + * elem = None # <<<<<<<<<<<<<< + * else: + * elem_buf.slice_from(buf, elem_len) + */ + __Pyx_INCREF(Py_None); + __Pyx_XDECREF_SET(__pyx_v_elem, Py_None); + + /* "asyncpg/protocol/codecs/array.pyx":189 + * for i in range(elem_count): + * elem_len = hton.unpack_int32(buf.read(4)) + * if elem_len == -1: # <<<<<<<<<<<<<< + * elem = None + * else: + */ + goto __pyx_L14; + } + + /* "asyncpg/protocol/codecs/array.pyx":192 + * elem = None + * else: + * elem_buf.slice_from(buf, elem_len) # <<<<<<<<<<<<<< + * elem = decoder(settings, elem_buf, decoder_arg) + * + */ + /*else*/ { + __pyx_t_2 = ((PyObject *)__pyx_f_7asyncpg_8protocol_8protocol_14FastReadBuffer_slice_from(__pyx_v_elem_buf, __pyx_v_buf, __pyx_v_elem_len)); if (unlikely(!__pyx_t_2)) __PYX_ERR(20, 192, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "asyncpg/protocol/codecs/array.pyx":193 + * else: + * elem_buf.slice_from(buf, elem_len) + * elem = decoder(settings, elem_buf, decoder_arg) # <<<<<<<<<<<<<< + * + * cpython.Py_INCREF(elem) + */ + __pyx_t_2 = __pyx_v_decoder(__pyx_v_settings, __pyx_v_elem_buf, __pyx_v_decoder_arg); if (unlikely(!__pyx_t_2)) __PYX_ERR(20, 193, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_XDECREF_SET(__pyx_v_elem, __pyx_t_2); + __pyx_t_2 = 0; + } + __pyx_L14:; + + /* "asyncpg/protocol/codecs/array.pyx":195 + * elem = decoder(settings, elem_buf, decoder_arg) + * + * cpython.Py_INCREF(elem) # <<<<<<<<<<<<<< + * cpython.PyList_SET_ITEM(result, i, elem) + * + */ + Py_INCREF(__pyx_v_elem); + + /* "asyncpg/protocol/codecs/array.pyx":196 + * + * cpython.Py_INCREF(elem) + * cpython.PyList_SET_ITEM(result, i, elem) # <<<<<<<<<<<<<< + * + * else: + */ + PyList_SET_ITEM(__pyx_v_result, __pyx_v_i, __pyx_v_elem); + } + + /* "asyncpg/protocol/codecs/array.pyx":182 + * buf.read(4) + * + * if ndims == 1: # <<<<<<<<<<<<<< + * # Fast path for flat arrays + * elem_count = dims[0] + */ + goto __pyx_L11; + } + + /* "asyncpg/protocol/codecs/array.pyx":199 + * + * else: + * result = _nested_array_decode(settings, buf, # <<<<<<<<<<<<<< + * decoder, decoder_arg, ndims, dims, + * elem_buf) + */ + /*else*/ { + + /* "asyncpg/protocol/codecs/array.pyx":201 + * result = _nested_array_decode(settings, buf, + * decoder, decoder_arg, ndims, dims, + * elem_buf) # <<<<<<<<<<<<<< + * + * return result + */ + __pyx_t_2 = __pyx_f_7asyncpg_8protocol_8protocol__nested_array_decode(__pyx_v_settings, __pyx_v_buf, __pyx_v_decoder, __pyx_v_decoder_arg, __pyx_v_ndims, __pyx_v_dims, __pyx_v_elem_buf); if (unlikely(!__pyx_t_2)) __PYX_ERR(20, 199, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + + /* "asyncpg/protocol/codecs/array.pyx":199 + * + * else: + * result = _nested_array_decode(settings, buf, # <<<<<<<<<<<<<< + * decoder, decoder_arg, ndims, dims, + * elem_buf) + */ + if (!(likely(PyList_CheckExact(__pyx_t_2))||((__pyx_t_2) == Py_None)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "list", Py_TYPE(__pyx_t_2)->tp_name), 0))) __PYX_ERR(20, 199, __pyx_L1_error) + __pyx_v_result = ((PyObject*)__pyx_t_2); + __pyx_t_2 = 0; + } + __pyx_L11:; + + /* "asyncpg/protocol/codecs/array.pyx":203 + * elem_buf) + * + * return result # <<<<<<<<<<<<<< + * + * + */ + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(__pyx_v_result); + __pyx_r = __pyx_v_result; + goto __pyx_L0; + + /* "asyncpg/protocol/codecs/array.pyx":143 + * + * + * cdef inline array_decode(ConnectionSettings settings, FastReadBuffer buf, # <<<<<<<<<<<<<< + * decode_func_ex decoder, const void *decoder_arg): + * cdef: + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_XDECREF(__pyx_t_6); + __Pyx_XDECREF(__pyx_t_8); + __Pyx_AddTraceback("asyncpg.protocol.protocol.array_decode", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XDECREF(__pyx_v_result); + __Pyx_XDECREF((PyObject *)__pyx_v_elem_buf); + __Pyx_XDECREF((PyObject *)__pyx_v_elem_codec); + __Pyx_XDECREF(__pyx_v_elem); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "asyncpg/protocol/codecs/array.pyx":206 + * + * + * cdef inline _nested_array_decode(ConnectionSettings settings, # <<<<<<<<<<<<<< + * FastReadBuffer buf, + * decode_func_ex decoder, + */ + +static CYTHON_INLINE PyObject *__pyx_f_7asyncpg_8protocol_8protocol__nested_array_decode(struct __pyx_obj_7asyncpg_8protocol_8protocol_ConnectionSettings *__pyx_v_settings, struct __pyx_obj_7asyncpg_8protocol_8protocol_FastReadBuffer *__pyx_v_buf, __pyx_t_7asyncpg_8protocol_8protocol_decode_func_ex __pyx_v_decoder, void const *__pyx_v_decoder_arg, int32_t __pyx_v_ndims, int32_t *__pyx_v_dims, struct __pyx_obj_7asyncpg_8protocol_8protocol_FastReadBuffer *__pyx_v_elem_buf) { + int32_t __pyx_v_elem_len; + int32_t __pyx_v_d1; + int32_t __pyx_v_d2; + int32_t __pyx_v_d3; + int32_t __pyx_v_d4; + int32_t __pyx_v_d5; + int32_t __pyx_v_d6; + PyObject *__pyx_v_result = 0; + PyObject *__pyx_v_elem = 0; + PyObject *__pyx_v_stride1 = 0; + PyObject *__pyx_v_stride2 = 0; + PyObject *__pyx_v_stride3 = 0; + PyObject *__pyx_v_stride4 = 0; + PyObject *__pyx_v_stride5 = 0; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int32_t __pyx_t_2; + int32_t __pyx_t_3; + int32_t __pyx_t_4; + int32_t __pyx_t_5; + int __pyx_t_6; + char const *__pyx_t_7; + PyObject *__pyx_t_8 = NULL; + int32_t __pyx_t_9; + int32_t __pyx_t_10; + int32_t __pyx_t_11; + int32_t __pyx_t_12; + int32_t __pyx_t_13; + int32_t __pyx_t_14; + int32_t __pyx_t_15; + int32_t __pyx_t_16; + __Pyx_RefNannySetupContext("_nested_array_decode", 0); + + /* "asyncpg/protocol/codecs/array.pyx":224 + * # Alas, Cython doesn't have preprocessor macros. + * # + * result = cpython.PyList_New(dims[0]) # <<<<<<<<<<<<<< + * + * for d1 in range(dims[0]): + */ + __pyx_t_1 = PyList_New((__pyx_v_dims[0])); if (unlikely(!__pyx_t_1)) __PYX_ERR(20, 224, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_v_result = ((PyObject*)__pyx_t_1); + __pyx_t_1 = 0; + + /* "asyncpg/protocol/codecs/array.pyx":226 + * result = cpython.PyList_New(dims[0]) + * + * for d1 in range(dims[0]): # <<<<<<<<<<<<<< + * stride1 = cpython.PyList_New(dims[1]) + * cpython.Py_INCREF(stride1) + */ + __pyx_t_2 = (__pyx_v_dims[0]); + for (__pyx_t_3 = 0; __pyx_t_3 < __pyx_t_2; __pyx_t_3+=1) { + __pyx_v_d1 = __pyx_t_3; + + /* "asyncpg/protocol/codecs/array.pyx":227 + * + * for d1 in range(dims[0]): + * stride1 = cpython.PyList_New(dims[1]) # <<<<<<<<<<<<<< + * cpython.Py_INCREF(stride1) + * cpython.PyList_SET_ITEM(result, d1, stride1) + */ + __pyx_t_1 = PyList_New((__pyx_v_dims[1])); if (unlikely(!__pyx_t_1)) __PYX_ERR(20, 227, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_XDECREF_SET(__pyx_v_stride1, ((PyObject*)__pyx_t_1)); + __pyx_t_1 = 0; + + /* "asyncpg/protocol/codecs/array.pyx":228 + * for d1 in range(dims[0]): + * stride1 = cpython.PyList_New(dims[1]) + * cpython.Py_INCREF(stride1) # <<<<<<<<<<<<<< + * cpython.PyList_SET_ITEM(result, d1, stride1) + * + */ + Py_INCREF(__pyx_v_stride1); + + /* "asyncpg/protocol/codecs/array.pyx":229 + * stride1 = cpython.PyList_New(dims[1]) + * cpython.Py_INCREF(stride1) + * cpython.PyList_SET_ITEM(result, d1, stride1) # <<<<<<<<<<<<<< + * + * for d2 in range(dims[1]): + */ + PyList_SET_ITEM(__pyx_v_result, __pyx_v_d1, __pyx_v_stride1); + + /* "asyncpg/protocol/codecs/array.pyx":231 + * cpython.PyList_SET_ITEM(result, d1, stride1) + * + * for d2 in range(dims[1]): # <<<<<<<<<<<<<< + * if ndims == 2: + * elem_len = hton.unpack_int32(buf.read(4)) + */ + __pyx_t_4 = (__pyx_v_dims[1]); + for (__pyx_t_5 = 0; __pyx_t_5 < __pyx_t_4; __pyx_t_5+=1) { + __pyx_v_d2 = __pyx_t_5; + + /* "asyncpg/protocol/codecs/array.pyx":232 + * + * for d2 in range(dims[1]): + * if ndims == 2: # <<<<<<<<<<<<<< + * elem_len = hton.unpack_int32(buf.read(4)) + * if elem_len == -1: + */ + __pyx_t_6 = ((__pyx_v_ndims == 2) != 0); + if (__pyx_t_6) { + + /* "asyncpg/protocol/codecs/array.pyx":233 + * for d2 in range(dims[1]): + * if ndims == 2: + * elem_len = hton.unpack_int32(buf.read(4)) # <<<<<<<<<<<<<< + * if elem_len == -1: + * elem = None + */ + __pyx_t_7 = __pyx_f_7asyncpg_8protocol_8protocol_14FastReadBuffer_read(__pyx_v_buf, 4); if (unlikely(__pyx_t_7 == NULL)) __PYX_ERR(20, 233, __pyx_L1_error) + __pyx_v_elem_len = __pyx_f_7asyncpg_8protocol_4hton_unpack_int32(__pyx_t_7); + + /* "asyncpg/protocol/codecs/array.pyx":234 + * if ndims == 2: + * elem_len = hton.unpack_int32(buf.read(4)) + * if elem_len == -1: # <<<<<<<<<<<<<< + * elem = None + * else: + */ + __pyx_t_6 = ((__pyx_v_elem_len == -1L) != 0); + if (__pyx_t_6) { + + /* "asyncpg/protocol/codecs/array.pyx":235 + * elem_len = hton.unpack_int32(buf.read(4)) + * if elem_len == -1: + * elem = None # <<<<<<<<<<<<<< + * else: + * elem = decoder(settings, + */ + __Pyx_INCREF(Py_None); + __Pyx_XDECREF_SET(__pyx_v_elem, Py_None); + + /* "asyncpg/protocol/codecs/array.pyx":234 + * if ndims == 2: + * elem_len = hton.unpack_int32(buf.read(4)) + * if elem_len == -1: # <<<<<<<<<<<<<< + * elem = None + * else: + */ + goto __pyx_L8; + } + + /* "asyncpg/protocol/codecs/array.pyx":237 + * elem = None + * else: + * elem = decoder(settings, # <<<<<<<<<<<<<< + * elem_buf.slice_from(buf, elem_len), + * decoder_arg) + */ + /*else*/ { + + /* "asyncpg/protocol/codecs/array.pyx":238 + * else: + * elem = decoder(settings, + * elem_buf.slice_from(buf, elem_len), # <<<<<<<<<<<<<< + * decoder_arg) + * + */ + __pyx_t_1 = ((PyObject *)__pyx_f_7asyncpg_8protocol_8protocol_14FastReadBuffer_slice_from(__pyx_v_elem_buf, __pyx_v_buf, __pyx_v_elem_len)); if (unlikely(!__pyx_t_1)) __PYX_ERR(20, 238, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + + /* "asyncpg/protocol/codecs/array.pyx":237 + * elem = None + * else: + * elem = decoder(settings, # <<<<<<<<<<<<<< + * elem_buf.slice_from(buf, elem_len), + * decoder_arg) + */ + __pyx_t_8 = __pyx_v_decoder(__pyx_v_settings, ((struct __pyx_obj_7asyncpg_8protocol_8protocol_FastReadBuffer *)__pyx_t_1), __pyx_v_decoder_arg); if (unlikely(!__pyx_t_8)) __PYX_ERR(20, 237, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_XDECREF_SET(__pyx_v_elem, __pyx_t_8); + __pyx_t_8 = 0; + } + __pyx_L8:; + + /* "asyncpg/protocol/codecs/array.pyx":241 + * decoder_arg) + * + * cpython.Py_INCREF(elem) # <<<<<<<<<<<<<< + * cpython.PyList_SET_ITEM(stride1, d2, elem) + * + */ + Py_INCREF(__pyx_v_elem); + + /* "asyncpg/protocol/codecs/array.pyx":242 + * + * cpython.Py_INCREF(elem) + * cpython.PyList_SET_ITEM(stride1, d2, elem) # <<<<<<<<<<<<<< + * + * else: + */ + PyList_SET_ITEM(__pyx_v_stride1, __pyx_v_d2, __pyx_v_elem); + + /* "asyncpg/protocol/codecs/array.pyx":232 + * + * for d2 in range(dims[1]): + * if ndims == 2: # <<<<<<<<<<<<<< + * elem_len = hton.unpack_int32(buf.read(4)) + * if elem_len == -1: + */ + goto __pyx_L7; + } + + /* "asyncpg/protocol/codecs/array.pyx":245 + * + * else: + * stride2 = cpython.PyList_New(dims[2]) # <<<<<<<<<<<<<< + * cpython.Py_INCREF(stride2) + * cpython.PyList_SET_ITEM(stride1, d2, stride2) + */ + /*else*/ { + __pyx_t_8 = PyList_New((__pyx_v_dims[2])); if (unlikely(!__pyx_t_8)) __PYX_ERR(20, 245, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __Pyx_XDECREF_SET(__pyx_v_stride2, ((PyObject*)__pyx_t_8)); + __pyx_t_8 = 0; + + /* "asyncpg/protocol/codecs/array.pyx":246 + * else: + * stride2 = cpython.PyList_New(dims[2]) + * cpython.Py_INCREF(stride2) # <<<<<<<<<<<<<< + * cpython.PyList_SET_ITEM(stride1, d2, stride2) + * + */ + Py_INCREF(__pyx_v_stride2); + + /* "asyncpg/protocol/codecs/array.pyx":247 + * stride2 = cpython.PyList_New(dims[2]) + * cpython.Py_INCREF(stride2) + * cpython.PyList_SET_ITEM(stride1, d2, stride2) # <<<<<<<<<<<<<< + * + * for d3 in range(dims[2]): + */ + PyList_SET_ITEM(__pyx_v_stride1, __pyx_v_d2, __pyx_v_stride2); + + /* "asyncpg/protocol/codecs/array.pyx":249 + * cpython.PyList_SET_ITEM(stride1, d2, stride2) + * + * for d3 in range(dims[2]): # <<<<<<<<<<<<<< + * if ndims == 3: + * elem_len = hton.unpack_int32(buf.read(4)) + */ + __pyx_t_9 = (__pyx_v_dims[2]); + for (__pyx_t_10 = 0; __pyx_t_10 < __pyx_t_9; __pyx_t_10+=1) { + __pyx_v_d3 = __pyx_t_10; + + /* "asyncpg/protocol/codecs/array.pyx":250 + * + * for d3 in range(dims[2]): + * if ndims == 3: # <<<<<<<<<<<<<< + * elem_len = hton.unpack_int32(buf.read(4)) + * if elem_len == -1: + */ + __pyx_t_6 = ((__pyx_v_ndims == 3) != 0); + if (__pyx_t_6) { + + /* "asyncpg/protocol/codecs/array.pyx":251 + * for d3 in range(dims[2]): + * if ndims == 3: + * elem_len = hton.unpack_int32(buf.read(4)) # <<<<<<<<<<<<<< + * if elem_len == -1: + * elem = None + */ + __pyx_t_7 = __pyx_f_7asyncpg_8protocol_8protocol_14FastReadBuffer_read(__pyx_v_buf, 4); if (unlikely(__pyx_t_7 == NULL)) __PYX_ERR(20, 251, __pyx_L1_error) + __pyx_v_elem_len = __pyx_f_7asyncpg_8protocol_4hton_unpack_int32(__pyx_t_7); + + /* "asyncpg/protocol/codecs/array.pyx":252 + * if ndims == 3: + * elem_len = hton.unpack_int32(buf.read(4)) + * if elem_len == -1: # <<<<<<<<<<<<<< + * elem = None + * else: + */ + __pyx_t_6 = ((__pyx_v_elem_len == -1L) != 0); + if (__pyx_t_6) { + + /* "asyncpg/protocol/codecs/array.pyx":253 + * elem_len = hton.unpack_int32(buf.read(4)) + * if elem_len == -1: + * elem = None # <<<<<<<<<<<<<< + * else: + * elem = decoder(settings, + */ + __Pyx_INCREF(Py_None); + __Pyx_XDECREF_SET(__pyx_v_elem, Py_None); + + /* "asyncpg/protocol/codecs/array.pyx":252 + * if ndims == 3: + * elem_len = hton.unpack_int32(buf.read(4)) + * if elem_len == -1: # <<<<<<<<<<<<<< + * elem = None + * else: + */ + goto __pyx_L12; + } + + /* "asyncpg/protocol/codecs/array.pyx":255 + * elem = None + * else: + * elem = decoder(settings, # <<<<<<<<<<<<<< + * elem_buf.slice_from(buf, elem_len), + * decoder_arg) + */ + /*else*/ { + + /* "asyncpg/protocol/codecs/array.pyx":256 + * else: + * elem = decoder(settings, + * elem_buf.slice_from(buf, elem_len), # <<<<<<<<<<<<<< + * decoder_arg) + * + */ + __pyx_t_8 = ((PyObject *)__pyx_f_7asyncpg_8protocol_8protocol_14FastReadBuffer_slice_from(__pyx_v_elem_buf, __pyx_v_buf, __pyx_v_elem_len)); if (unlikely(!__pyx_t_8)) __PYX_ERR(20, 256, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + + /* "asyncpg/protocol/codecs/array.pyx":255 + * elem = None + * else: + * elem = decoder(settings, # <<<<<<<<<<<<<< + * elem_buf.slice_from(buf, elem_len), + * decoder_arg) + */ + __pyx_t_1 = __pyx_v_decoder(__pyx_v_settings, ((struct __pyx_obj_7asyncpg_8protocol_8protocol_FastReadBuffer *)__pyx_t_8), __pyx_v_decoder_arg); if (unlikely(!__pyx_t_1)) __PYX_ERR(20, 255, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + __Pyx_XDECREF_SET(__pyx_v_elem, __pyx_t_1); + __pyx_t_1 = 0; + } + __pyx_L12:; + + /* "asyncpg/protocol/codecs/array.pyx":259 + * decoder_arg) + * + * cpython.Py_INCREF(elem) # <<<<<<<<<<<<<< + * cpython.PyList_SET_ITEM(stride2, d3, elem) + * + */ + Py_INCREF(__pyx_v_elem); + + /* "asyncpg/protocol/codecs/array.pyx":260 + * + * cpython.Py_INCREF(elem) + * cpython.PyList_SET_ITEM(stride2, d3, elem) # <<<<<<<<<<<<<< + * + * else: + */ + PyList_SET_ITEM(__pyx_v_stride2, __pyx_v_d3, __pyx_v_elem); + + /* "asyncpg/protocol/codecs/array.pyx":250 + * + * for d3 in range(dims[2]): + * if ndims == 3: # <<<<<<<<<<<<<< + * elem_len = hton.unpack_int32(buf.read(4)) + * if elem_len == -1: + */ + goto __pyx_L11; + } + + /* "asyncpg/protocol/codecs/array.pyx":263 + * + * else: + * stride3 = cpython.PyList_New(dims[3]) # <<<<<<<<<<<<<< + * cpython.Py_INCREF(stride3) + * cpython.PyList_SET_ITEM(stride2, d3, stride3) + */ + /*else*/ { + __pyx_t_1 = PyList_New((__pyx_v_dims[3])); if (unlikely(!__pyx_t_1)) __PYX_ERR(20, 263, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_XDECREF_SET(__pyx_v_stride3, ((PyObject*)__pyx_t_1)); + __pyx_t_1 = 0; + + /* "asyncpg/protocol/codecs/array.pyx":264 + * else: + * stride3 = cpython.PyList_New(dims[3]) + * cpython.Py_INCREF(stride3) # <<<<<<<<<<<<<< + * cpython.PyList_SET_ITEM(stride2, d3, stride3) + * + */ + Py_INCREF(__pyx_v_stride3); + + /* "asyncpg/protocol/codecs/array.pyx":265 + * stride3 = cpython.PyList_New(dims[3]) + * cpython.Py_INCREF(stride3) + * cpython.PyList_SET_ITEM(stride2, d3, stride3) # <<<<<<<<<<<<<< + * + * for d4 in range(dims[3]): + */ + PyList_SET_ITEM(__pyx_v_stride2, __pyx_v_d3, __pyx_v_stride3); + + /* "asyncpg/protocol/codecs/array.pyx":267 + * cpython.PyList_SET_ITEM(stride2, d3, stride3) + * + * for d4 in range(dims[3]): # <<<<<<<<<<<<<< + * if ndims == 4: + * elem_len = hton.unpack_int32(buf.read(4)) + */ + __pyx_t_11 = (__pyx_v_dims[3]); + for (__pyx_t_12 = 0; __pyx_t_12 < __pyx_t_11; __pyx_t_12+=1) { + __pyx_v_d4 = __pyx_t_12; + + /* "asyncpg/protocol/codecs/array.pyx":268 + * + * for d4 in range(dims[3]): + * if ndims == 4: # <<<<<<<<<<<<<< + * elem_len = hton.unpack_int32(buf.read(4)) + * if elem_len == -1: + */ + __pyx_t_6 = ((__pyx_v_ndims == 4) != 0); + if (__pyx_t_6) { + + /* "asyncpg/protocol/codecs/array.pyx":269 + * for d4 in range(dims[3]): + * if ndims == 4: + * elem_len = hton.unpack_int32(buf.read(4)) # <<<<<<<<<<<<<< + * if elem_len == -1: + * elem = None + */ + __pyx_t_7 = __pyx_f_7asyncpg_8protocol_8protocol_14FastReadBuffer_read(__pyx_v_buf, 4); if (unlikely(__pyx_t_7 == NULL)) __PYX_ERR(20, 269, __pyx_L1_error) + __pyx_v_elem_len = __pyx_f_7asyncpg_8protocol_4hton_unpack_int32(__pyx_t_7); + + /* "asyncpg/protocol/codecs/array.pyx":270 + * if ndims == 4: + * elem_len = hton.unpack_int32(buf.read(4)) + * if elem_len == -1: # <<<<<<<<<<<<<< + * elem = None + * else: + */ + __pyx_t_6 = ((__pyx_v_elem_len == -1L) != 0); + if (__pyx_t_6) { + + /* "asyncpg/protocol/codecs/array.pyx":271 + * elem_len = hton.unpack_int32(buf.read(4)) + * if elem_len == -1: + * elem = None # <<<<<<<<<<<<<< + * else: + * elem = decoder(settings, + */ + __Pyx_INCREF(Py_None); + __Pyx_XDECREF_SET(__pyx_v_elem, Py_None); + + /* "asyncpg/protocol/codecs/array.pyx":270 + * if ndims == 4: + * elem_len = hton.unpack_int32(buf.read(4)) + * if elem_len == -1: # <<<<<<<<<<<<<< + * elem = None + * else: + */ + goto __pyx_L16; + } + + /* "asyncpg/protocol/codecs/array.pyx":273 + * elem = None + * else: + * elem = decoder(settings, # <<<<<<<<<<<<<< + * elem_buf.slice_from(buf, elem_len), + * decoder_arg) + */ + /*else*/ { + + /* "asyncpg/protocol/codecs/array.pyx":274 + * else: + * elem = decoder(settings, + * elem_buf.slice_from(buf, elem_len), # <<<<<<<<<<<<<< + * decoder_arg) + * + */ + __pyx_t_1 = ((PyObject *)__pyx_f_7asyncpg_8protocol_8protocol_14FastReadBuffer_slice_from(__pyx_v_elem_buf, __pyx_v_buf, __pyx_v_elem_len)); if (unlikely(!__pyx_t_1)) __PYX_ERR(20, 274, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + + /* "asyncpg/protocol/codecs/array.pyx":273 + * elem = None + * else: + * elem = decoder(settings, # <<<<<<<<<<<<<< + * elem_buf.slice_from(buf, elem_len), + * decoder_arg) + */ + __pyx_t_8 = __pyx_v_decoder(__pyx_v_settings, ((struct __pyx_obj_7asyncpg_8protocol_8protocol_FastReadBuffer *)__pyx_t_1), __pyx_v_decoder_arg); if (unlikely(!__pyx_t_8)) __PYX_ERR(20, 273, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_XDECREF_SET(__pyx_v_elem, __pyx_t_8); + __pyx_t_8 = 0; + } + __pyx_L16:; + + /* "asyncpg/protocol/codecs/array.pyx":277 + * decoder_arg) + * + * cpython.Py_INCREF(elem) # <<<<<<<<<<<<<< + * cpython.PyList_SET_ITEM(stride3, d4, elem) + * + */ + Py_INCREF(__pyx_v_elem); + + /* "asyncpg/protocol/codecs/array.pyx":278 + * + * cpython.Py_INCREF(elem) + * cpython.PyList_SET_ITEM(stride3, d4, elem) # <<<<<<<<<<<<<< + * + * else: + */ + PyList_SET_ITEM(__pyx_v_stride3, __pyx_v_d4, __pyx_v_elem); + + /* "asyncpg/protocol/codecs/array.pyx":268 + * + * for d4 in range(dims[3]): + * if ndims == 4: # <<<<<<<<<<<<<< + * elem_len = hton.unpack_int32(buf.read(4)) + * if elem_len == -1: + */ + goto __pyx_L15; + } + + /* "asyncpg/protocol/codecs/array.pyx":281 + * + * else: + * stride4 = cpython.PyList_New(dims[4]) # <<<<<<<<<<<<<< + * cpython.Py_INCREF(stride4) + * cpython.PyList_SET_ITEM(stride3, d4, stride4) + */ + /*else*/ { + __pyx_t_8 = PyList_New((__pyx_v_dims[4])); if (unlikely(!__pyx_t_8)) __PYX_ERR(20, 281, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __Pyx_XDECREF_SET(__pyx_v_stride4, ((PyObject*)__pyx_t_8)); + __pyx_t_8 = 0; + + /* "asyncpg/protocol/codecs/array.pyx":282 + * else: + * stride4 = cpython.PyList_New(dims[4]) + * cpython.Py_INCREF(stride4) # <<<<<<<<<<<<<< + * cpython.PyList_SET_ITEM(stride3, d4, stride4) + * + */ + Py_INCREF(__pyx_v_stride4); + + /* "asyncpg/protocol/codecs/array.pyx":283 + * stride4 = cpython.PyList_New(dims[4]) + * cpython.Py_INCREF(stride4) + * cpython.PyList_SET_ITEM(stride3, d4, stride4) # <<<<<<<<<<<<<< + * + * for d5 in range(dims[4]): + */ + PyList_SET_ITEM(__pyx_v_stride3, __pyx_v_d4, __pyx_v_stride4); + + /* "asyncpg/protocol/codecs/array.pyx":285 + * cpython.PyList_SET_ITEM(stride3, d4, stride4) + * + * for d5 in range(dims[4]): # <<<<<<<<<<<<<< + * if ndims == 5: + * elem_len = hton.unpack_int32(buf.read(4)) + */ + __pyx_t_13 = (__pyx_v_dims[4]); + for (__pyx_t_14 = 0; __pyx_t_14 < __pyx_t_13; __pyx_t_14+=1) { + __pyx_v_d5 = __pyx_t_14; + + /* "asyncpg/protocol/codecs/array.pyx":286 + * + * for d5 in range(dims[4]): + * if ndims == 5: # <<<<<<<<<<<<<< + * elem_len = hton.unpack_int32(buf.read(4)) + * if elem_len == -1: + */ + __pyx_t_6 = ((__pyx_v_ndims == 5) != 0); + if (__pyx_t_6) { + + /* "asyncpg/protocol/codecs/array.pyx":287 + * for d5 in range(dims[4]): + * if ndims == 5: + * elem_len = hton.unpack_int32(buf.read(4)) # <<<<<<<<<<<<<< + * if elem_len == -1: + * elem = None + */ + __pyx_t_7 = __pyx_f_7asyncpg_8protocol_8protocol_14FastReadBuffer_read(__pyx_v_buf, 4); if (unlikely(__pyx_t_7 == NULL)) __PYX_ERR(20, 287, __pyx_L1_error) + __pyx_v_elem_len = __pyx_f_7asyncpg_8protocol_4hton_unpack_int32(__pyx_t_7); + + /* "asyncpg/protocol/codecs/array.pyx":288 + * if ndims == 5: + * elem_len = hton.unpack_int32(buf.read(4)) + * if elem_len == -1: # <<<<<<<<<<<<<< + * elem = None + * else: + */ + __pyx_t_6 = ((__pyx_v_elem_len == -1L) != 0); + if (__pyx_t_6) { + + /* "asyncpg/protocol/codecs/array.pyx":289 + * elem_len = hton.unpack_int32(buf.read(4)) + * if elem_len == -1: + * elem = None # <<<<<<<<<<<<<< + * else: + * elem = decoder(settings, + */ + __Pyx_INCREF(Py_None); + __Pyx_XDECREF_SET(__pyx_v_elem, Py_None); + + /* "asyncpg/protocol/codecs/array.pyx":288 + * if ndims == 5: + * elem_len = hton.unpack_int32(buf.read(4)) + * if elem_len == -1: # <<<<<<<<<<<<<< + * elem = None + * else: + */ + goto __pyx_L20; + } + + /* "asyncpg/protocol/codecs/array.pyx":291 + * elem = None + * else: + * elem = decoder(settings, # <<<<<<<<<<<<<< + * elem_buf.slice_from(buf, elem_len), + * decoder_arg) + */ + /*else*/ { + + /* "asyncpg/protocol/codecs/array.pyx":292 + * else: + * elem = decoder(settings, + * elem_buf.slice_from(buf, elem_len), # <<<<<<<<<<<<<< + * decoder_arg) + * + */ + __pyx_t_8 = ((PyObject *)__pyx_f_7asyncpg_8protocol_8protocol_14FastReadBuffer_slice_from(__pyx_v_elem_buf, __pyx_v_buf, __pyx_v_elem_len)); if (unlikely(!__pyx_t_8)) __PYX_ERR(20, 292, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + + /* "asyncpg/protocol/codecs/array.pyx":291 + * elem = None + * else: + * elem = decoder(settings, # <<<<<<<<<<<<<< + * elem_buf.slice_from(buf, elem_len), + * decoder_arg) + */ + __pyx_t_1 = __pyx_v_decoder(__pyx_v_settings, ((struct __pyx_obj_7asyncpg_8protocol_8protocol_FastReadBuffer *)__pyx_t_8), __pyx_v_decoder_arg); if (unlikely(!__pyx_t_1)) __PYX_ERR(20, 291, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + __Pyx_XDECREF_SET(__pyx_v_elem, __pyx_t_1); + __pyx_t_1 = 0; + } + __pyx_L20:; + + /* "asyncpg/protocol/codecs/array.pyx":295 + * decoder_arg) + * + * cpython.Py_INCREF(elem) # <<<<<<<<<<<<<< + * cpython.PyList_SET_ITEM(stride4, d5, elem) + * + */ + Py_INCREF(__pyx_v_elem); + + /* "asyncpg/protocol/codecs/array.pyx":296 + * + * cpython.Py_INCREF(elem) + * cpython.PyList_SET_ITEM(stride4, d5, elem) # <<<<<<<<<<<<<< + * + * else: + */ + PyList_SET_ITEM(__pyx_v_stride4, __pyx_v_d5, __pyx_v_elem); + + /* "asyncpg/protocol/codecs/array.pyx":286 + * + * for d5 in range(dims[4]): + * if ndims == 5: # <<<<<<<<<<<<<< + * elem_len = hton.unpack_int32(buf.read(4)) + * if elem_len == -1: + */ + goto __pyx_L19; + } + + /* "asyncpg/protocol/codecs/array.pyx":299 + * + * else: + * stride5 = cpython.PyList_New(dims[5]) # <<<<<<<<<<<<<< + * cpython.Py_INCREF(stride5) + * cpython.PyList_SET_ITEM(stride4, d5, stride5) + */ + /*else*/ { + __pyx_t_1 = PyList_New((__pyx_v_dims[5])); if (unlikely(!__pyx_t_1)) __PYX_ERR(20, 299, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_XDECREF_SET(__pyx_v_stride5, ((PyObject*)__pyx_t_1)); + __pyx_t_1 = 0; + + /* "asyncpg/protocol/codecs/array.pyx":300 + * else: + * stride5 = cpython.PyList_New(dims[5]) + * cpython.Py_INCREF(stride5) # <<<<<<<<<<<<<< + * cpython.PyList_SET_ITEM(stride4, d5, stride5) + * + */ + Py_INCREF(__pyx_v_stride5); + + /* "asyncpg/protocol/codecs/array.pyx":301 + * stride5 = cpython.PyList_New(dims[5]) + * cpython.Py_INCREF(stride5) + * cpython.PyList_SET_ITEM(stride4, d5, stride5) # <<<<<<<<<<<<<< + * + * for d6 in range(dims[5]): + */ + PyList_SET_ITEM(__pyx_v_stride4, __pyx_v_d5, __pyx_v_stride5); + + /* "asyncpg/protocol/codecs/array.pyx":303 + * cpython.PyList_SET_ITEM(stride4, d5, stride5) + * + * for d6 in range(dims[5]): # <<<<<<<<<<<<<< + * elem_len = hton.unpack_int32(buf.read(4)) + * if elem_len == -1: + */ + __pyx_t_15 = (__pyx_v_dims[5]); + for (__pyx_t_16 = 0; __pyx_t_16 < __pyx_t_15; __pyx_t_16+=1) { + __pyx_v_d6 = __pyx_t_16; + + /* "asyncpg/protocol/codecs/array.pyx":304 + * + * for d6 in range(dims[5]): + * elem_len = hton.unpack_int32(buf.read(4)) # <<<<<<<<<<<<<< + * if elem_len == -1: + * elem = None + */ + __pyx_t_7 = __pyx_f_7asyncpg_8protocol_8protocol_14FastReadBuffer_read(__pyx_v_buf, 4); if (unlikely(__pyx_t_7 == NULL)) __PYX_ERR(20, 304, __pyx_L1_error) + __pyx_v_elem_len = __pyx_f_7asyncpg_8protocol_4hton_unpack_int32(__pyx_t_7); + + /* "asyncpg/protocol/codecs/array.pyx":305 + * for d6 in range(dims[5]): + * elem_len = hton.unpack_int32(buf.read(4)) + * if elem_len == -1: # <<<<<<<<<<<<<< + * elem = None + * else: + */ + __pyx_t_6 = ((__pyx_v_elem_len == -1L) != 0); + if (__pyx_t_6) { + + /* "asyncpg/protocol/codecs/array.pyx":306 + * elem_len = hton.unpack_int32(buf.read(4)) + * if elem_len == -1: + * elem = None # <<<<<<<<<<<<<< + * else: + * elem = decoder(settings, + */ + __Pyx_INCREF(Py_None); + __Pyx_XDECREF_SET(__pyx_v_elem, Py_None); + + /* "asyncpg/protocol/codecs/array.pyx":305 + * for d6 in range(dims[5]): + * elem_len = hton.unpack_int32(buf.read(4)) + * if elem_len == -1: # <<<<<<<<<<<<<< + * elem = None + * else: + */ + goto __pyx_L23; + } + + /* "asyncpg/protocol/codecs/array.pyx":308 + * elem = None + * else: + * elem = decoder(settings, # <<<<<<<<<<<<<< + * elem_buf.slice_from(buf, elem_len), + * decoder_arg) + */ + /*else*/ { + + /* "asyncpg/protocol/codecs/array.pyx":309 + * else: + * elem = decoder(settings, + * elem_buf.slice_from(buf, elem_len), # <<<<<<<<<<<<<< + * decoder_arg) + * + */ + __pyx_t_1 = ((PyObject *)__pyx_f_7asyncpg_8protocol_8protocol_14FastReadBuffer_slice_from(__pyx_v_elem_buf, __pyx_v_buf, __pyx_v_elem_len)); if (unlikely(!__pyx_t_1)) __PYX_ERR(20, 309, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + + /* "asyncpg/protocol/codecs/array.pyx":308 + * elem = None + * else: + * elem = decoder(settings, # <<<<<<<<<<<<<< + * elem_buf.slice_from(buf, elem_len), + * decoder_arg) + */ + __pyx_t_8 = __pyx_v_decoder(__pyx_v_settings, ((struct __pyx_obj_7asyncpg_8protocol_8protocol_FastReadBuffer *)__pyx_t_1), __pyx_v_decoder_arg); if (unlikely(!__pyx_t_8)) __PYX_ERR(20, 308, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_XDECREF_SET(__pyx_v_elem, __pyx_t_8); + __pyx_t_8 = 0; + } + __pyx_L23:; + + /* "asyncpg/protocol/codecs/array.pyx":312 + * decoder_arg) + * + * cpython.Py_INCREF(elem) # <<<<<<<<<<<<<< + * cpython.PyList_SET_ITEM(stride5, d6, elem) + * + */ + Py_INCREF(__pyx_v_elem); + + /* "asyncpg/protocol/codecs/array.pyx":313 + * + * cpython.Py_INCREF(elem) + * cpython.PyList_SET_ITEM(stride5, d6, elem) # <<<<<<<<<<<<<< + * + * return result + */ + PyList_SET_ITEM(__pyx_v_stride5, __pyx_v_d6, __pyx_v_elem); + } + } + __pyx_L19:; + } + } + __pyx_L15:; + } + } + __pyx_L11:; + } + } + __pyx_L7:; + } + } + + /* "asyncpg/protocol/codecs/array.pyx":315 + * cpython.PyList_SET_ITEM(stride5, d6, elem) + * + * return result # <<<<<<<<<<<<<< + * + * + */ + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(__pyx_v_result); + __pyx_r = __pyx_v_result; + goto __pyx_L0; + + /* "asyncpg/protocol/codecs/array.pyx":206 + * + * + * cdef inline _nested_array_decode(ConnectionSettings settings, # <<<<<<<<<<<<<< + * FastReadBuffer buf, + * decode_func_ex decoder, + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_8); + __Pyx_AddTraceback("asyncpg.protocol.protocol._nested_array_decode", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XDECREF(__pyx_v_result); + __Pyx_XDECREF(__pyx_v_elem); + __Pyx_XDECREF(__pyx_v_stride1); + __Pyx_XDECREF(__pyx_v_stride2); + __Pyx_XDECREF(__pyx_v_stride3); + __Pyx_XDECREF(__pyx_v_stride4); + __Pyx_XDECREF(__pyx_v_stride5); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "asyncpg/protocol/codecs/array.pyx":318 + * + * + * cdef textarray_decode(ConnectionSettings settings, FastReadBuffer buf, # <<<<<<<<<<<<<< + * decode_func_ex decoder, const void *decoder_arg, + * Py_UCS4 typdelim): + */ + +static PyObject *__pyx_f_7asyncpg_8protocol_8protocol_textarray_decode(struct __pyx_obj_7asyncpg_8protocol_8protocol_ConnectionSettings *__pyx_v_settings, struct __pyx_obj_7asyncpg_8protocol_8protocol_FastReadBuffer *__pyx_v_buf, __pyx_t_7asyncpg_8protocol_8protocol_decode_func_ex __pyx_v_decoder, void const *__pyx_v_decoder_arg, Py_UCS4 __pyx_v_typdelim) { + Py_UCS4 *__pyx_v_array_text; + PyObject *__pyx_v_s = 0; + PyObject *__pyx_v_e = NULL; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + int __pyx_t_5; + PyObject *__pyx_t_6 = NULL; + PyObject *__pyx_t_7 = NULL; + PyObject *__pyx_t_8 = NULL; + PyObject *__pyx_t_9 = NULL; + PyObject *__pyx_t_10 = NULL; + PyObject *__pyx_t_11 = NULL; + PyObject *__pyx_t_12 = NULL; + int __pyx_t_13; + char const *__pyx_t_14; + PyObject *__pyx_t_15 = NULL; + PyObject *__pyx_t_16 = NULL; + PyObject *__pyx_t_17 = NULL; + PyObject *__pyx_t_18 = NULL; + PyObject *__pyx_t_19 = NULL; + PyObject *__pyx_t_20 = NULL; + char const *__pyx_t_21; + __Pyx_RefNannySetupContext("textarray_decode", 0); + + /* "asyncpg/protocol/codecs/array.pyx":327 + * # Make a copy of array data since we will be mutating it for + * # the purposes of element decoding. + * s = text_decode(settings, buf) # <<<<<<<<<<<<<< + * array_text = PyUnicode_AsUCS4Copy(s) + * + */ + __pyx_t_1 = __pyx_f_7asyncpg_8protocol_8protocol_text_decode(__pyx_v_settings, __pyx_v_buf); if (unlikely(!__pyx_t_1)) __PYX_ERR(20, 327, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (!(likely(PyUnicode_CheckExact(__pyx_t_1))||((__pyx_t_1) == Py_None)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "unicode", Py_TYPE(__pyx_t_1)->tp_name), 0))) __PYX_ERR(20, 327, __pyx_L1_error) + __pyx_v_s = ((PyObject*)__pyx_t_1); + __pyx_t_1 = 0; + + /* "asyncpg/protocol/codecs/array.pyx":328 + * # the purposes of element decoding. + * s = text_decode(settings, buf) + * array_text = PyUnicode_AsUCS4Copy(s) # <<<<<<<<<<<<<< + * + * try: + */ + __pyx_v_array_text = PyUnicode_AsUCS4Copy(__pyx_v_s); + + /* "asyncpg/protocol/codecs/array.pyx":330 + * array_text = PyUnicode_AsUCS4Copy(s) + * + * try: # <<<<<<<<<<<<<< + * return _textarray_decode( + * settings, array_text, decoder, decoder_arg, typdelim) + */ + /*try:*/ { + { + __Pyx_PyThreadState_declare + __Pyx_PyThreadState_assign + __Pyx_ExceptionSave(&__pyx_t_2, &__pyx_t_3, &__pyx_t_4); + __Pyx_XGOTREF(__pyx_t_2); + __Pyx_XGOTREF(__pyx_t_3); + __Pyx_XGOTREF(__pyx_t_4); + /*try:*/ { + + /* "asyncpg/protocol/codecs/array.pyx":331 + * + * try: + * return _textarray_decode( # <<<<<<<<<<<<<< + * settings, array_text, decoder, decoder_arg, typdelim) + * except ValueError as e: + */ + __Pyx_XDECREF(__pyx_r); + + /* "asyncpg/protocol/codecs/array.pyx":332 + * try: + * return _textarray_decode( + * settings, array_text, decoder, decoder_arg, typdelim) # <<<<<<<<<<<<<< + * except ValueError as e: + * raise ValueError( + */ + __pyx_t_1 = __pyx_f_7asyncpg_8protocol_8protocol__textarray_decode(__pyx_v_settings, __pyx_v_array_text, __pyx_v_decoder, __pyx_v_decoder_arg, __pyx_v_typdelim); if (unlikely(!__pyx_t_1)) __PYX_ERR(20, 331, __pyx_L6_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L10_try_return; + + /* "asyncpg/protocol/codecs/array.pyx":330 + * array_text = PyUnicode_AsUCS4Copy(s) + * + * try: # <<<<<<<<<<<<<< + * return _textarray_decode( + * settings, array_text, decoder, decoder_arg, typdelim) + */ + } + __pyx_L6_error:; + __Pyx_PyThreadState_assign + __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "asyncpg/protocol/codecs/array.pyx":333 + * return _textarray_decode( + * settings, array_text, decoder, decoder_arg, typdelim) + * except ValueError as e: # <<<<<<<<<<<<<< + * raise ValueError( + * 'malformed array literal {!r}: {}'.format(s, e.args[0])) + */ + __pyx_t_5 = __Pyx_PyErr_ExceptionMatches(__pyx_builtin_ValueError); + if (__pyx_t_5) { + __Pyx_AddTraceback("asyncpg.protocol.protocol.textarray_decode", __pyx_clineno, __pyx_lineno, __pyx_filename); + if (__Pyx_GetException(&__pyx_t_1, &__pyx_t_6, &__pyx_t_7) < 0) __PYX_ERR(20, 333, __pyx_L8_except_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_GOTREF(__pyx_t_6); + __Pyx_GOTREF(__pyx_t_7); + __Pyx_INCREF(__pyx_t_6); + __pyx_v_e = __pyx_t_6; + /*try:*/ { + + /* "asyncpg/protocol/codecs/array.pyx":335 + * except ValueError as e: + * raise ValueError( + * 'malformed array literal {!r}: {}'.format(s, e.args[0])) # <<<<<<<<<<<<<< + * finally: + * PyMem_Free(array_text) + */ + __pyx_t_9 = __Pyx_PyObject_GetAttrStr(__pyx_kp_u_malformed_array_literal_r, __pyx_n_s_format); if (unlikely(!__pyx_t_9)) __PYX_ERR(20, 335, __pyx_L19_error) + __Pyx_GOTREF(__pyx_t_9); + __pyx_t_10 = __Pyx_PyObject_GetAttrStr(__pyx_v_e, __pyx_n_s_args); if (unlikely(!__pyx_t_10)) __PYX_ERR(20, 335, __pyx_L19_error) + __Pyx_GOTREF(__pyx_t_10); + __pyx_t_11 = __Pyx_GetItemInt(__pyx_t_10, 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_11)) __PYX_ERR(20, 335, __pyx_L19_error) + __Pyx_GOTREF(__pyx_t_11); + __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; + __pyx_t_10 = NULL; + __pyx_t_5 = 0; + if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_9))) { + __pyx_t_10 = PyMethod_GET_SELF(__pyx_t_9); + if (likely(__pyx_t_10)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_9); + __Pyx_INCREF(__pyx_t_10); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_9, function); + __pyx_t_5 = 1; + } + } + #if CYTHON_FAST_PYCALL + if (PyFunction_Check(__pyx_t_9)) { + PyObject *__pyx_temp[3] = {__pyx_t_10, __pyx_v_s, __pyx_t_11}; + __pyx_t_8 = __Pyx_PyFunction_FastCall(__pyx_t_9, __pyx_temp+1-__pyx_t_5, 2+__pyx_t_5); if (unlikely(!__pyx_t_8)) __PYX_ERR(20, 335, __pyx_L19_error) + __Pyx_XDECREF(__pyx_t_10); __pyx_t_10 = 0; + __Pyx_GOTREF(__pyx_t_8); + __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0; + } else + #endif + #if CYTHON_FAST_PYCCALL + if (__Pyx_PyFastCFunction_Check(__pyx_t_9)) { + PyObject *__pyx_temp[3] = {__pyx_t_10, __pyx_v_s, __pyx_t_11}; + __pyx_t_8 = __Pyx_PyCFunction_FastCall(__pyx_t_9, __pyx_temp+1-__pyx_t_5, 2+__pyx_t_5); if (unlikely(!__pyx_t_8)) __PYX_ERR(20, 335, __pyx_L19_error) + __Pyx_XDECREF(__pyx_t_10); __pyx_t_10 = 0; + __Pyx_GOTREF(__pyx_t_8); + __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0; + } else + #endif + { + __pyx_t_12 = PyTuple_New(2+__pyx_t_5); if (unlikely(!__pyx_t_12)) __PYX_ERR(20, 335, __pyx_L19_error) + __Pyx_GOTREF(__pyx_t_12); + if (__pyx_t_10) { + __Pyx_GIVEREF(__pyx_t_10); PyTuple_SET_ITEM(__pyx_t_12, 0, __pyx_t_10); __pyx_t_10 = NULL; + } + __Pyx_INCREF(__pyx_v_s); + __Pyx_GIVEREF(__pyx_v_s); + PyTuple_SET_ITEM(__pyx_t_12, 0+__pyx_t_5, __pyx_v_s); + __Pyx_GIVEREF(__pyx_t_11); + PyTuple_SET_ITEM(__pyx_t_12, 1+__pyx_t_5, __pyx_t_11); + __pyx_t_11 = 0; + __pyx_t_8 = __Pyx_PyObject_Call(__pyx_t_9, __pyx_t_12, NULL); if (unlikely(!__pyx_t_8)) __PYX_ERR(20, 335, __pyx_L19_error) + __Pyx_GOTREF(__pyx_t_8); + __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0; + } + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + + /* "asyncpg/protocol/codecs/array.pyx":334 + * settings, array_text, decoder, decoder_arg, typdelim) + * except ValueError as e: + * raise ValueError( # <<<<<<<<<<<<<< + * 'malformed array literal {!r}: {}'.format(s, e.args[0])) + * finally: + */ + __pyx_t_9 = PyTuple_New(1); if (unlikely(!__pyx_t_9)) __PYX_ERR(20, 334, __pyx_L19_error) + __Pyx_GOTREF(__pyx_t_9); + __Pyx_GIVEREF(__pyx_t_8); + PyTuple_SET_ITEM(__pyx_t_9, 0, __pyx_t_8); + __pyx_t_8 = 0; + __pyx_t_8 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_t_9, NULL); if (unlikely(!__pyx_t_8)) __PYX_ERR(20, 334, __pyx_L19_error) + __Pyx_GOTREF(__pyx_t_8); + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + __Pyx_Raise(__pyx_t_8, 0, 0, 0); + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + __PYX_ERR(20, 334, __pyx_L19_error) + } + + /* "asyncpg/protocol/codecs/array.pyx":333 + * return _textarray_decode( + * settings, array_text, decoder, decoder_arg, typdelim) + * except ValueError as e: # <<<<<<<<<<<<<< + * raise ValueError( + * 'malformed array literal {!r}: {}'.format(s, e.args[0])) + */ + /*finally:*/ { + /*exception exit:*/{ + __Pyx_PyThreadState_declare + __pyx_L19_error:; + __pyx_t_15 = 0; __pyx_t_16 = 0; __pyx_t_17 = 0; __pyx_t_18 = 0; __pyx_t_19 = 0; __pyx_t_20 = 0; + __Pyx_PyThreadState_assign + __Pyx_XDECREF(__pyx_t_10); __pyx_t_10 = 0; + __Pyx_XDECREF(__pyx_t_11); __pyx_t_11 = 0; + __Pyx_XDECREF(__pyx_t_12); __pyx_t_12 = 0; + __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0; + __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; + if (PY_MAJOR_VERSION >= 3) __Pyx_ExceptionSwap(&__pyx_t_18, &__pyx_t_19, &__pyx_t_20); + if ((PY_MAJOR_VERSION < 3) || unlikely(__Pyx_GetException(&__pyx_t_15, &__pyx_t_16, &__pyx_t_17) < 0)) __Pyx_ErrFetch(&__pyx_t_15, &__pyx_t_16, &__pyx_t_17); + __Pyx_XGOTREF(__pyx_t_15); + __Pyx_XGOTREF(__pyx_t_16); + __Pyx_XGOTREF(__pyx_t_17); + __Pyx_XGOTREF(__pyx_t_18); + __Pyx_XGOTREF(__pyx_t_19); + __Pyx_XGOTREF(__pyx_t_20); + __pyx_t_5 = __pyx_lineno; __pyx_t_13 = __pyx_clineno; __pyx_t_14 = __pyx_filename; + { + __Pyx_DECREF(__pyx_v_e); + __pyx_v_e = NULL; + } + __Pyx_PyThreadState_assign + if (PY_MAJOR_VERSION >= 3) { + __Pyx_XGIVEREF(__pyx_t_18); + __Pyx_XGIVEREF(__pyx_t_19); + __Pyx_XGIVEREF(__pyx_t_20); + __Pyx_ExceptionReset(__pyx_t_18, __pyx_t_19, __pyx_t_20); + } + __Pyx_XGIVEREF(__pyx_t_15); + __Pyx_XGIVEREF(__pyx_t_16); + __Pyx_XGIVEREF(__pyx_t_17); + __Pyx_ErrRestore(__pyx_t_15, __pyx_t_16, __pyx_t_17); + __pyx_t_15 = 0; __pyx_t_16 = 0; __pyx_t_17 = 0; __pyx_t_18 = 0; __pyx_t_19 = 0; __pyx_t_20 = 0; + __pyx_lineno = __pyx_t_5; __pyx_clineno = __pyx_t_13; __pyx_filename = __pyx_t_14; + goto __pyx_L8_except_error; + } + } + } + goto __pyx_L8_except_error; + __pyx_L8_except_error:; + + /* "asyncpg/protocol/codecs/array.pyx":330 + * array_text = PyUnicode_AsUCS4Copy(s) + * + * try: # <<<<<<<<<<<<<< + * return _textarray_decode( + * settings, array_text, decoder, decoder_arg, typdelim) + */ + __Pyx_PyThreadState_assign + __Pyx_XGIVEREF(__pyx_t_2); + __Pyx_XGIVEREF(__pyx_t_3); + __Pyx_XGIVEREF(__pyx_t_4); + __Pyx_ExceptionReset(__pyx_t_2, __pyx_t_3, __pyx_t_4); + goto __pyx_L4_error; + __pyx_L10_try_return:; + __Pyx_PyThreadState_assign + __Pyx_XGIVEREF(__pyx_t_2); + __Pyx_XGIVEREF(__pyx_t_3); + __Pyx_XGIVEREF(__pyx_t_4); + __Pyx_ExceptionReset(__pyx_t_2, __pyx_t_3, __pyx_t_4); + goto __pyx_L3_return; + } + } + + /* "asyncpg/protocol/codecs/array.pyx":337 + * 'malformed array literal {!r}: {}'.format(s, e.args[0])) + * finally: + * PyMem_Free(array_text) # <<<<<<<<<<<<<< + * + * + */ + /*finally:*/ { + /*exception exit:*/{ + __Pyx_PyThreadState_declare + __pyx_L4_error:; + __pyx_t_4 = 0; __pyx_t_3 = 0; __pyx_t_2 = 0; __pyx_t_20 = 0; __pyx_t_19 = 0; __pyx_t_18 = 0; + __Pyx_PyThreadState_assign + __Pyx_XDECREF(__pyx_t_10); __pyx_t_10 = 0; + __Pyx_XDECREF(__pyx_t_11); __pyx_t_11 = 0; + __Pyx_XDECREF(__pyx_t_12); __pyx_t_12 = 0; + __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0; + __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; + __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; + if (PY_MAJOR_VERSION >= 3) __Pyx_ExceptionSwap(&__pyx_t_20, &__pyx_t_19, &__pyx_t_18); + if ((PY_MAJOR_VERSION < 3) || unlikely(__Pyx_GetException(&__pyx_t_4, &__pyx_t_3, &__pyx_t_2) < 0)) __Pyx_ErrFetch(&__pyx_t_4, &__pyx_t_3, &__pyx_t_2); + __Pyx_XGOTREF(__pyx_t_4); + __Pyx_XGOTREF(__pyx_t_3); + __Pyx_XGOTREF(__pyx_t_2); + __Pyx_XGOTREF(__pyx_t_20); + __Pyx_XGOTREF(__pyx_t_19); + __Pyx_XGOTREF(__pyx_t_18); + __pyx_t_13 = __pyx_lineno; __pyx_t_5 = __pyx_clineno; __pyx_t_21 = __pyx_filename; + { + PyMem_Free(__pyx_v_array_text); + } + __Pyx_PyThreadState_assign + if (PY_MAJOR_VERSION >= 3) { + __Pyx_XGIVEREF(__pyx_t_20); + __Pyx_XGIVEREF(__pyx_t_19); + __Pyx_XGIVEREF(__pyx_t_18); + __Pyx_ExceptionReset(__pyx_t_20, __pyx_t_19, __pyx_t_18); + } + __Pyx_XGIVEREF(__pyx_t_4); + __Pyx_XGIVEREF(__pyx_t_3); + __Pyx_XGIVEREF(__pyx_t_2); + __Pyx_ErrRestore(__pyx_t_4, __pyx_t_3, __pyx_t_2); + __pyx_t_4 = 0; __pyx_t_3 = 0; __pyx_t_2 = 0; __pyx_t_20 = 0; __pyx_t_19 = 0; __pyx_t_18 = 0; + __pyx_lineno = __pyx_t_13; __pyx_clineno = __pyx_t_5; __pyx_filename = __pyx_t_21; + goto __pyx_L1_error; + } + __pyx_L3_return: { + __pyx_t_18 = __pyx_r; + __pyx_r = 0; + PyMem_Free(__pyx_v_array_text); + __pyx_r = __pyx_t_18; + __pyx_t_18 = 0; + goto __pyx_L0; + } + } + + /* "asyncpg/protocol/codecs/array.pyx":318 + * + * + * cdef textarray_decode(ConnectionSettings settings, FastReadBuffer buf, # <<<<<<<<<<<<<< + * decode_func_ex decoder, const void *decoder_arg, + * Py_UCS4 typdelim): + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_6); + __Pyx_XDECREF(__pyx_t_7); + __Pyx_XDECREF(__pyx_t_8); + __Pyx_XDECREF(__pyx_t_9); + __Pyx_XDECREF(__pyx_t_10); + __Pyx_XDECREF(__pyx_t_11); + __Pyx_XDECREF(__pyx_t_12); + __Pyx_AddTraceback("asyncpg.protocol.protocol.textarray_decode", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XDECREF(__pyx_v_s); + __Pyx_XDECREF(__pyx_v_e); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "asyncpg/protocol/codecs/array.pyx":340 + * + * + * cdef _textarray_decode(ConnectionSettings settings, # <<<<<<<<<<<<<< + * Py_UCS4 *array_text, + * decode_func_ex decoder, + */ + +static PyObject *__pyx_f_7asyncpg_8protocol_8protocol__textarray_decode(struct __pyx_obj_7asyncpg_8protocol_8protocol_ConnectionSettings *__pyx_v_settings, Py_UCS4 *__pyx_v_array_text, __pyx_t_7asyncpg_8protocol_8protocol_decode_func_ex __pyx_v_decoder, void const *__pyx_v_decoder_arg, Py_UCS4 __pyx_v_typdelim) { + PyObject *__pyx_v_result = 0; + PyObject *__pyx_v_new_stride = 0; + Py_UCS4 *__pyx_v_ptr; + int32_t __pyx_v_ndims; + int32_t __pyx_v_ubound; + int32_t __pyx_v_lbound; + int32_t __pyx_v_dims[6]; + int32_t __pyx_v_inferred_dims[6]; + int32_t __pyx_v_inferred_ndims; + void *__pyx_v_strides[6]; + int32_t __pyx_v_indexes[6]; + int32_t __pyx_v_nest_level; + int32_t __pyx_v_item_level; + int __pyx_v_end_of_array; + int __pyx_v_end_of_item; + int __pyx_v_has_quoting; + int __pyx_v_strip_spaces; + int __pyx_v_in_quotes; + Py_UCS4 *__pyx_v_item_start; + Py_UCS4 *__pyx_v_item_ptr; + Py_UCS4 *__pyx_v_item_end; + int __pyx_v_i; + PyObject *__pyx_v_item = 0; + PyObject *__pyx_v_item_text = 0; + struct __pyx_obj_7asyncpg_8protocol_8protocol_FastReadBuffer *__pyx_v_item_buf = 0; + char *__pyx_v_pg_item_str; + Py_ssize_t __pyx_v_pg_item_len; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_t_2; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + PyObject *__pyx_t_5 = NULL; + int __pyx_t_6; + PyObject *__pyx_t_7 = NULL; + int32_t __pyx_t_8; + PyObject *__pyx_t_9; + int __pyx_t_10; + long __pyx_t_11; + __Pyx_RefNannySetupContext("_textarray_decode", 0); + + /* "asyncpg/protocol/codecs/array.pyx":351 + * list new_stride + * Py_UCS4 *ptr + * int32_t ndims = 0 # <<<<<<<<<<<<<< + * int32_t ubound = 0 + * int32_t lbound = 0 + */ + __pyx_v_ndims = 0; + + /* "asyncpg/protocol/codecs/array.pyx":352 + * Py_UCS4 *ptr + * int32_t ndims = 0 + * int32_t ubound = 0 # <<<<<<<<<<<<<< + * int32_t lbound = 0 + * int32_t dims[ARRAY_MAXDIM] + */ + __pyx_v_ubound = 0; + + /* "asyncpg/protocol/codecs/array.pyx":353 + * int32_t ndims = 0 + * int32_t ubound = 0 + * int32_t lbound = 0 # <<<<<<<<<<<<<< + * int32_t dims[ARRAY_MAXDIM] + * int32_t inferred_dims[ARRAY_MAXDIM] + */ + __pyx_v_lbound = 0; + + /* "asyncpg/protocol/codecs/array.pyx":356 + * int32_t dims[ARRAY_MAXDIM] + * int32_t inferred_dims[ARRAY_MAXDIM] + * int32_t inferred_ndims = 0 # <<<<<<<<<<<<<< + * void *strides[ARRAY_MAXDIM] + * int32_t indexes[ARRAY_MAXDIM] + */ + __pyx_v_inferred_ndims = 0; + + /* "asyncpg/protocol/codecs/array.pyx":359 + * void *strides[ARRAY_MAXDIM] + * int32_t indexes[ARRAY_MAXDIM] + * int32_t nest_level = 0 # <<<<<<<<<<<<<< + * int32_t item_level = 0 + * bint end_of_array = False + */ + __pyx_v_nest_level = 0; + + /* "asyncpg/protocol/codecs/array.pyx":360 + * int32_t indexes[ARRAY_MAXDIM] + * int32_t nest_level = 0 + * int32_t item_level = 0 # <<<<<<<<<<<<<< + * bint end_of_array = False + * + */ + __pyx_v_item_level = 0; + + /* "asyncpg/protocol/codecs/array.pyx":361 + * int32_t nest_level = 0 + * int32_t item_level = 0 + * bint end_of_array = False # <<<<<<<<<<<<<< + * + * bint end_of_item = False + */ + __pyx_v_end_of_array = 0; + + /* "asyncpg/protocol/codecs/array.pyx":363 + * bint end_of_array = False + * + * bint end_of_item = False # <<<<<<<<<<<<<< + * bint has_quoting = False + * bint strip_spaces = False + */ + __pyx_v_end_of_item = 0; + + /* "asyncpg/protocol/codecs/array.pyx":364 + * + * bint end_of_item = False + * bint has_quoting = False # <<<<<<<<<<<<<< + * bint strip_spaces = False + * bint in_quotes = False + */ + __pyx_v_has_quoting = 0; + + /* "asyncpg/protocol/codecs/array.pyx":365 + * bint end_of_item = False + * bint has_quoting = False + * bint strip_spaces = False # <<<<<<<<<<<<<< + * bint in_quotes = False + * Py_UCS4 *item_start + */ + __pyx_v_strip_spaces = 0; + + /* "asyncpg/protocol/codecs/array.pyx":366 + * bint has_quoting = False + * bint strip_spaces = False + * bint in_quotes = False # <<<<<<<<<<<<<< + * Py_UCS4 *item_start + * Py_UCS4 *item_ptr + */ + __pyx_v_in_quotes = 0; + + /* "asyncpg/protocol/codecs/array.pyx":374 + * object item + * str item_text + * FastReadBuffer item_buf = FastReadBuffer.new() # <<<<<<<<<<<<<< + * char *pg_item_str + * ssize_t pg_item_len + */ + __pyx_t_1 = ((PyObject *)__pyx_f_7asyncpg_8protocol_8protocol_14FastReadBuffer_new()); if (unlikely(!__pyx_t_1)) __PYX_ERR(20, 374, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_v_item_buf = ((struct __pyx_obj_7asyncpg_8protocol_8protocol_FastReadBuffer *)__pyx_t_1); + __pyx_t_1 = 0; + + /* "asyncpg/protocol/codecs/array.pyx":378 + * ssize_t pg_item_len + * + * ptr = array_text # <<<<<<<<<<<<<< + * + * while True: + */ + __pyx_v_ptr = __pyx_v_array_text; + + /* "asyncpg/protocol/codecs/array.pyx":380 + * ptr = array_text + * + * while True: # <<<<<<<<<<<<<< + * while apg_ascii_isspace(ptr[0]): + * ptr += 1 + */ + while (1) { + + /* "asyncpg/protocol/codecs/array.pyx":381 + * + * while True: + * while apg_ascii_isspace(ptr[0]): # <<<<<<<<<<<<<< + * ptr += 1 + * + */ + while (1) { + __pyx_t_2 = (__pyx_f_7asyncpg_8protocol_8protocol_apg_ascii_isspace((__pyx_v_ptr[0])) != 0); + if (!__pyx_t_2) break; + + /* "asyncpg/protocol/codecs/array.pyx":382 + * while True: + * while apg_ascii_isspace(ptr[0]): + * ptr += 1 # <<<<<<<<<<<<<< + * + * if ptr[0] != '[': + */ + __pyx_v_ptr = (__pyx_v_ptr + 1); + } + + /* "asyncpg/protocol/codecs/array.pyx":384 + * ptr += 1 + * + * if ptr[0] != '[': # <<<<<<<<<<<<<< + * # Finished parsing dimensions spec. + * break + */ + __pyx_t_2 = (((__pyx_v_ptr[0]) != 91) != 0); + if (__pyx_t_2) { + + /* "asyncpg/protocol/codecs/array.pyx":386 + * if ptr[0] != '[': + * # Finished parsing dimensions spec. + * break # <<<<<<<<<<<<<< + * + * ptr += 1 # '[' + */ + goto __pyx_L4_break; + + /* "asyncpg/protocol/codecs/array.pyx":384 + * ptr += 1 + * + * if ptr[0] != '[': # <<<<<<<<<<<<<< + * # Finished parsing dimensions spec. + * break + */ + } + + /* "asyncpg/protocol/codecs/array.pyx":388 + * break + * + * ptr += 1 # '[' # <<<<<<<<<<<<<< + * + * if ndims > ARRAY_MAXDIM: + */ + __pyx_v_ptr = (__pyx_v_ptr + 1); + + /* "asyncpg/protocol/codecs/array.pyx":390 + * ptr += 1 # '[' + * + * if ndims > ARRAY_MAXDIM: # <<<<<<<<<<<<<< + * raise ValueError( + * 'number of array dimensions ({}) exceed the ' + */ + __pyx_t_2 = ((__pyx_v_ndims > 6) != 0); + if (__pyx_t_2) { + + /* "asyncpg/protocol/codecs/array.pyx":393 + * raise ValueError( + * 'number of array dimensions ({}) exceed the ' + * 'maximum expected ({})'.format(ndims, ARRAY_MAXDIM)) # <<<<<<<<<<<<<< + * + * ptr = apg_parse_int32(ptr, &ubound) + */ + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_kp_u_number_of_array_dimensions_excee, __pyx_n_s_format); if (unlikely(!__pyx_t_3)) __PYX_ERR(20, 393, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = __Pyx_PyInt_From_int32_t(__pyx_v_ndims); if (unlikely(!__pyx_t_4)) __PYX_ERR(20, 393, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_5 = NULL; + __pyx_t_6 = 0; + if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_3))) { + __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_3); + if (likely(__pyx_t_5)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); + __Pyx_INCREF(__pyx_t_5); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_3, function); + __pyx_t_6 = 1; + } + } + #if CYTHON_FAST_PYCALL + if (PyFunction_Check(__pyx_t_3)) { + PyObject *__pyx_temp[3] = {__pyx_t_5, __pyx_t_4, __pyx_int_6}; + __pyx_t_1 = __Pyx_PyFunction_FastCall(__pyx_t_3, __pyx_temp+1-__pyx_t_6, 2+__pyx_t_6); if (unlikely(!__pyx_t_1)) __PYX_ERR(20, 393, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + } else + #endif + #if CYTHON_FAST_PYCCALL + if (__Pyx_PyFastCFunction_Check(__pyx_t_3)) { + PyObject *__pyx_temp[3] = {__pyx_t_5, __pyx_t_4, __pyx_int_6}; + __pyx_t_1 = __Pyx_PyCFunction_FastCall(__pyx_t_3, __pyx_temp+1-__pyx_t_6, 2+__pyx_t_6); if (unlikely(!__pyx_t_1)) __PYX_ERR(20, 393, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + } else + #endif + { + __pyx_t_7 = PyTuple_New(2+__pyx_t_6); if (unlikely(!__pyx_t_7)) __PYX_ERR(20, 393, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + if (__pyx_t_5) { + __Pyx_GIVEREF(__pyx_t_5); PyTuple_SET_ITEM(__pyx_t_7, 0, __pyx_t_5); __pyx_t_5 = NULL; + } + __Pyx_GIVEREF(__pyx_t_4); + PyTuple_SET_ITEM(__pyx_t_7, 0+__pyx_t_6, __pyx_t_4); + __Pyx_INCREF(__pyx_int_6); + __Pyx_GIVEREF(__pyx_int_6); + PyTuple_SET_ITEM(__pyx_t_7, 1+__pyx_t_6, __pyx_int_6); + __pyx_t_4 = 0; + __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_t_7, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(20, 393, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + } + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + + /* "asyncpg/protocol/codecs/array.pyx":391 + * + * if ndims > ARRAY_MAXDIM: + * raise ValueError( # <<<<<<<<<<<<<< + * 'number of array dimensions ({}) exceed the ' + * 'maximum expected ({})'.format(ndims, ARRAY_MAXDIM)) + */ + __pyx_t_3 = PyTuple_New(1); if (unlikely(!__pyx_t_3)) __PYX_ERR(20, 391, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_GIVEREF(__pyx_t_1); + PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_t_1); + __pyx_t_1 = 0; + __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_t_3, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(20, 391, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_Raise(__pyx_t_1, 0, 0, 0); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __PYX_ERR(20, 391, __pyx_L1_error) + + /* "asyncpg/protocol/codecs/array.pyx":390 + * ptr += 1 # '[' + * + * if ndims > ARRAY_MAXDIM: # <<<<<<<<<<<<<< + * raise ValueError( + * 'number of array dimensions ({}) exceed the ' + */ + } + + /* "asyncpg/protocol/codecs/array.pyx":395 + * 'maximum expected ({})'.format(ndims, ARRAY_MAXDIM)) + * + * ptr = apg_parse_int32(ptr, &ubound) # <<<<<<<<<<<<<< + * if ptr == NULL: + * raise ValueError('missing array dimension value') + */ + __pyx_v_ptr = __pyx_f_7asyncpg_8protocol_8protocol_apg_parse_int32(__pyx_v_ptr, (&__pyx_v_ubound)); + + /* "asyncpg/protocol/codecs/array.pyx":396 + * + * ptr = apg_parse_int32(ptr, &ubound) + * if ptr == NULL: # <<<<<<<<<<<<<< + * raise ValueError('missing array dimension value') + * + */ + __pyx_t_2 = ((__pyx_v_ptr == NULL) != 0); + if (__pyx_t_2) { + + /* "asyncpg/protocol/codecs/array.pyx":397 + * ptr = apg_parse_int32(ptr, &ubound) + * if ptr == NULL: + * raise ValueError('missing array dimension value') # <<<<<<<<<<<<<< + * + * if ptr[0] == ':': + */ + __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__43, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(20, 397, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_Raise(__pyx_t_1, 0, 0, 0); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __PYX_ERR(20, 397, __pyx_L1_error) + + /* "asyncpg/protocol/codecs/array.pyx":396 + * + * ptr = apg_parse_int32(ptr, &ubound) + * if ptr == NULL: # <<<<<<<<<<<<<< + * raise ValueError('missing array dimension value') + * + */ + } + + /* "asyncpg/protocol/codecs/array.pyx":399 + * raise ValueError('missing array dimension value') + * + * if ptr[0] == ':': # <<<<<<<<<<<<<< + * ptr += 1 + * lbound = ubound + */ + __pyx_t_2 = (((__pyx_v_ptr[0]) == 58) != 0); + if (__pyx_t_2) { + + /* "asyncpg/protocol/codecs/array.pyx":400 + * + * if ptr[0] == ':': + * ptr += 1 # <<<<<<<<<<<<<< + * lbound = ubound + * + */ + __pyx_v_ptr = (__pyx_v_ptr + 1); + + /* "asyncpg/protocol/codecs/array.pyx":401 + * if ptr[0] == ':': + * ptr += 1 + * lbound = ubound # <<<<<<<<<<<<<< + * + * # [lower:upper] spec. We disregard the lbound for decoding. + */ + __pyx_v_lbound = __pyx_v_ubound; + + /* "asyncpg/protocol/codecs/array.pyx":404 + * + * # [lower:upper] spec. We disregard the lbound for decoding. + * ptr = apg_parse_int32(ptr, &ubound) # <<<<<<<<<<<<<< + * if ptr == NULL: + * raise ValueError('missing array dimension value') + */ + __pyx_v_ptr = __pyx_f_7asyncpg_8protocol_8protocol_apg_parse_int32(__pyx_v_ptr, (&__pyx_v_ubound)); + + /* "asyncpg/protocol/codecs/array.pyx":405 + * # [lower:upper] spec. We disregard the lbound for decoding. + * ptr = apg_parse_int32(ptr, &ubound) + * if ptr == NULL: # <<<<<<<<<<<<<< + * raise ValueError('missing array dimension value') + * else: + */ + __pyx_t_2 = ((__pyx_v_ptr == NULL) != 0); + if (__pyx_t_2) { + + /* "asyncpg/protocol/codecs/array.pyx":406 + * ptr = apg_parse_int32(ptr, &ubound) + * if ptr == NULL: + * raise ValueError('missing array dimension value') # <<<<<<<<<<<<<< + * else: + * lbound = 1 + */ + __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__44, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(20, 406, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_Raise(__pyx_t_1, 0, 0, 0); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __PYX_ERR(20, 406, __pyx_L1_error) + + /* "asyncpg/protocol/codecs/array.pyx":405 + * # [lower:upper] spec. We disregard the lbound for decoding. + * ptr = apg_parse_int32(ptr, &ubound) + * if ptr == NULL: # <<<<<<<<<<<<<< + * raise ValueError('missing array dimension value') + * else: + */ + } + + /* "asyncpg/protocol/codecs/array.pyx":399 + * raise ValueError('missing array dimension value') + * + * if ptr[0] == ':': # <<<<<<<<<<<<<< + * ptr += 1 + * lbound = ubound + */ + goto __pyx_L10; + } + + /* "asyncpg/protocol/codecs/array.pyx":408 + * raise ValueError('missing array dimension value') + * else: + * lbound = 1 # <<<<<<<<<<<<<< + * + * if ptr[0] != ']': + */ + /*else*/ { + __pyx_v_lbound = 1; + } + __pyx_L10:; + + /* "asyncpg/protocol/codecs/array.pyx":410 + * lbound = 1 + * + * if ptr[0] != ']': # <<<<<<<<<<<<<< + * raise ValueError('missing \']\' after array dimensions') + * + */ + __pyx_t_2 = (((__pyx_v_ptr[0]) != 93) != 0); + if (__pyx_t_2) { + + /* "asyncpg/protocol/codecs/array.pyx":411 + * + * if ptr[0] != ']': + * raise ValueError('missing \']\' after array dimensions') # <<<<<<<<<<<<<< + * + * ptr += 1 # ']' + */ + __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__45, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(20, 411, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_Raise(__pyx_t_1, 0, 0, 0); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __PYX_ERR(20, 411, __pyx_L1_error) + + /* "asyncpg/protocol/codecs/array.pyx":410 + * lbound = 1 + * + * if ptr[0] != ']': # <<<<<<<<<<<<<< + * raise ValueError('missing \']\' after array dimensions') + * + */ + } + + /* "asyncpg/protocol/codecs/array.pyx":413 + * raise ValueError('missing \']\' after array dimensions') + * + * ptr += 1 # ']' # <<<<<<<<<<<<<< + * + * dims[ndims] = ubound - lbound + 1 + */ + __pyx_v_ptr = (__pyx_v_ptr + 1); + + /* "asyncpg/protocol/codecs/array.pyx":415 + * ptr += 1 # ']' + * + * dims[ndims] = ubound - lbound + 1 # <<<<<<<<<<<<<< + * ndims += 1 + * + */ + (__pyx_v_dims[__pyx_v_ndims]) = ((__pyx_v_ubound - __pyx_v_lbound) + 1); + + /* "asyncpg/protocol/codecs/array.pyx":416 + * + * dims[ndims] = ubound - lbound + 1 + * ndims += 1 # <<<<<<<<<<<<<< + * + * if ndims != 0: + */ + __pyx_v_ndims = (__pyx_v_ndims + 1); + } + __pyx_L4_break:; + + /* "asyncpg/protocol/codecs/array.pyx":418 + * ndims += 1 + * + * if ndims != 0: # <<<<<<<<<<<<<< + * # If dimensions were given, the '=' token is expected. + * if ptr[0] != '=': + */ + __pyx_t_2 = ((__pyx_v_ndims != 0) != 0); + if (__pyx_t_2) { + + /* "asyncpg/protocol/codecs/array.pyx":420 + * if ndims != 0: + * # If dimensions were given, the '=' token is expected. + * if ptr[0] != '=': # <<<<<<<<<<<<<< + * raise ValueError('missing \'=\' after array dimensions') + * + */ + __pyx_t_2 = (((__pyx_v_ptr[0]) != 61) != 0); + if (__pyx_t_2) { + + /* "asyncpg/protocol/codecs/array.pyx":421 + * # If dimensions were given, the '=' token is expected. + * if ptr[0] != '=': + * raise ValueError('missing \'=\' after array dimensions') # <<<<<<<<<<<<<< + * + * ptr += 1 # '=' + */ + __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__46, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(20, 421, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_Raise(__pyx_t_1, 0, 0, 0); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __PYX_ERR(20, 421, __pyx_L1_error) + + /* "asyncpg/protocol/codecs/array.pyx":420 + * if ndims != 0: + * # If dimensions were given, the '=' token is expected. + * if ptr[0] != '=': # <<<<<<<<<<<<<< + * raise ValueError('missing \'=\' after array dimensions') + * + */ + } + + /* "asyncpg/protocol/codecs/array.pyx":423 + * raise ValueError('missing \'=\' after array dimensions') + * + * ptr += 1 # '=' # <<<<<<<<<<<<<< + * + * # Skip any whitespace after the '=', whitespace + */ + __pyx_v_ptr = (__pyx_v_ptr + 1); + + /* "asyncpg/protocol/codecs/array.pyx":427 + * # Skip any whitespace after the '=', whitespace + * # before was consumed in the above loop. + * while apg_ascii_isspace(ptr[0]): # <<<<<<<<<<<<<< + * ptr += 1 + * + */ + while (1) { + __pyx_t_2 = (__pyx_f_7asyncpg_8protocol_8protocol_apg_ascii_isspace((__pyx_v_ptr[0])) != 0); + if (!__pyx_t_2) break; + + /* "asyncpg/protocol/codecs/array.pyx":428 + * # before was consumed in the above loop. + * while apg_ascii_isspace(ptr[0]): + * ptr += 1 # <<<<<<<<<<<<<< + * + * # Infer the dimensions from the brace structure in the + */ + __pyx_v_ptr = (__pyx_v_ptr + 1); + } + + /* "asyncpg/protocol/codecs/array.pyx":433 + * # array literal body, and check that it matches the explicit + * # spec. This also validates that the array literal is sane. + * _infer_array_dims(ptr, typdelim, inferred_dims, &inferred_ndims) # <<<<<<<<<<<<<< + * + * if inferred_ndims != ndims: + */ + __pyx_t_1 = __pyx_f_7asyncpg_8protocol_8protocol__infer_array_dims(__pyx_v_ptr, __pyx_v_typdelim, __pyx_v_inferred_dims, (&__pyx_v_inferred_ndims)); if (unlikely(!__pyx_t_1)) __PYX_ERR(20, 433, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "asyncpg/protocol/codecs/array.pyx":435 + * _infer_array_dims(ptr, typdelim, inferred_dims, &inferred_ndims) + * + * if inferred_ndims != ndims: # <<<<<<<<<<<<<< + * raise ValueError( + * 'specified array dimensions do not match array content') + */ + __pyx_t_2 = ((__pyx_v_inferred_ndims != __pyx_v_ndims) != 0); + if (__pyx_t_2) { + + /* "asyncpg/protocol/codecs/array.pyx":436 + * + * if inferred_ndims != ndims: + * raise ValueError( # <<<<<<<<<<<<<< + * 'specified array dimensions do not match array content') + * + */ + __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__47, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(20, 436, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_Raise(__pyx_t_1, 0, 0, 0); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __PYX_ERR(20, 436, __pyx_L1_error) + + /* "asyncpg/protocol/codecs/array.pyx":435 + * _infer_array_dims(ptr, typdelim, inferred_dims, &inferred_ndims) + * + * if inferred_ndims != ndims: # <<<<<<<<<<<<<< + * raise ValueError( + * 'specified array dimensions do not match array content') + */ + } + + /* "asyncpg/protocol/codecs/array.pyx":439 + * 'specified array dimensions do not match array content') + * + * for i in range(ndims): # <<<<<<<<<<<<<< + * if inferred_dims[i] != dims[i]: + * raise ValueError( + */ + __pyx_t_8 = __pyx_v_ndims; + for (__pyx_t_6 = 0; __pyx_t_6 < __pyx_t_8; __pyx_t_6+=1) { + __pyx_v_i = __pyx_t_6; + + /* "asyncpg/protocol/codecs/array.pyx":440 + * + * for i in range(ndims): + * if inferred_dims[i] != dims[i]: # <<<<<<<<<<<<<< + * raise ValueError( + * 'specified array dimensions do not match array content') + */ + __pyx_t_2 = (((__pyx_v_inferred_dims[__pyx_v_i]) != (__pyx_v_dims[__pyx_v_i])) != 0); + if (__pyx_t_2) { + + /* "asyncpg/protocol/codecs/array.pyx":441 + * for i in range(ndims): + * if inferred_dims[i] != dims[i]: + * raise ValueError( # <<<<<<<<<<<<<< + * 'specified array dimensions do not match array content') + * else: + */ + __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__48, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(20, 441, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_Raise(__pyx_t_1, 0, 0, 0); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __PYX_ERR(20, 441, __pyx_L1_error) + + /* "asyncpg/protocol/codecs/array.pyx":440 + * + * for i in range(ndims): + * if inferred_dims[i] != dims[i]: # <<<<<<<<<<<<<< + * raise ValueError( + * 'specified array dimensions do not match array content') + */ + } + } + + /* "asyncpg/protocol/codecs/array.pyx":418 + * ndims += 1 + * + * if ndims != 0: # <<<<<<<<<<<<<< + * # If dimensions were given, the '=' token is expected. + * if ptr[0] != '=': + */ + goto __pyx_L13; + } + + /* "asyncpg/protocol/codecs/array.pyx":446 + * # Infer the dimensions from the brace structure in the array literal + * # body. This also validates that the array literal is sane. + * _infer_array_dims(ptr, typdelim, dims, &ndims) # <<<<<<<<<<<<<< + * + * while not end_of_array: + */ + /*else*/ { + __pyx_t_1 = __pyx_f_7asyncpg_8protocol_8protocol__infer_array_dims(__pyx_v_ptr, __pyx_v_typdelim, __pyx_v_dims, (&__pyx_v_ndims)); if (unlikely(!__pyx_t_1)) __PYX_ERR(20, 446, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + } + __pyx_L13:; + + /* "asyncpg/protocol/codecs/array.pyx":448 + * _infer_array_dims(ptr, typdelim, dims, &ndims) + * + * while not end_of_array: # <<<<<<<<<<<<<< + * # We iterate over the literal character by character + * # and modify the string in-place removing the array-specific + */ + while (1) { + __pyx_t_2 = ((!(__pyx_v_end_of_array != 0)) != 0); + if (!__pyx_t_2) break; + + /* "asyncpg/protocol/codecs/array.pyx":452 + * # and modify the string in-place removing the array-specific + * # quoting and determining the boundaries of each element. + * end_of_item = has_quoting = in_quotes = False # <<<<<<<<<<<<<< + * strip_spaces = True + * + */ + __pyx_v_end_of_item = 0; + __pyx_v_has_quoting = 0; + __pyx_v_in_quotes = 0; + + /* "asyncpg/protocol/codecs/array.pyx":453 + * # quoting and determining the boundaries of each element. + * end_of_item = has_quoting = in_quotes = False + * strip_spaces = True # <<<<<<<<<<<<<< + * + * # Pointers to array element start, end, and the current pointer + */ + __pyx_v_strip_spaces = 1; + + /* "asyncpg/protocol/codecs/array.pyx":458 + * # tracking the position where characters are written when + * # escaping is folded. + * item_start = item_end = item_ptr = ptr # <<<<<<<<<<<<<< + * item_level = 0 + * + */ + __pyx_v_item_start = __pyx_v_ptr; + __pyx_v_item_end = __pyx_v_ptr; + __pyx_v_item_ptr = __pyx_v_ptr; + + /* "asyncpg/protocol/codecs/array.pyx":459 + * # escaping is folded. + * item_start = item_end = item_ptr = ptr + * item_level = 0 # <<<<<<<<<<<<<< + * + * while not end_of_item: + */ + __pyx_v_item_level = 0; + + /* "asyncpg/protocol/codecs/array.pyx":461 + * item_level = 0 + * + * while not end_of_item: # <<<<<<<<<<<<<< + * if ptr[0] == '"': + * in_quotes = not in_quotes + */ + while (1) { + __pyx_t_2 = ((!(__pyx_v_end_of_item != 0)) != 0); + if (!__pyx_t_2) break; + + /* "asyncpg/protocol/codecs/array.pyx":462 + * + * while not end_of_item: + * if ptr[0] == '"': # <<<<<<<<<<<<<< + * in_quotes = not in_quotes + * if in_quotes: + */ + __pyx_t_2 = (((__pyx_v_ptr[0]) == 34) != 0); + if (__pyx_t_2) { + + /* "asyncpg/protocol/codecs/array.pyx":463 + * while not end_of_item: + * if ptr[0] == '"': + * in_quotes = not in_quotes # <<<<<<<<<<<<<< + * if in_quotes: + * strip_spaces = False + */ + __pyx_v_in_quotes = (!(__pyx_v_in_quotes != 0)); + + /* "asyncpg/protocol/codecs/array.pyx":464 + * if ptr[0] == '"': + * in_quotes = not in_quotes + * if in_quotes: # <<<<<<<<<<<<<< + * strip_spaces = False + * else: + */ + __pyx_t_2 = (__pyx_v_in_quotes != 0); + if (__pyx_t_2) { + + /* "asyncpg/protocol/codecs/array.pyx":465 + * in_quotes = not in_quotes + * if in_quotes: + * strip_spaces = False # <<<<<<<<<<<<<< + * else: + * item_end = item_ptr + */ + __pyx_v_strip_spaces = 0; + + /* "asyncpg/protocol/codecs/array.pyx":464 + * if ptr[0] == '"': + * in_quotes = not in_quotes + * if in_quotes: # <<<<<<<<<<<<<< + * strip_spaces = False + * else: + */ + goto __pyx_L26; + } + + /* "asyncpg/protocol/codecs/array.pyx":467 + * strip_spaces = False + * else: + * item_end = item_ptr # <<<<<<<<<<<<<< + * has_quoting = True + * + */ + /*else*/ { + __pyx_v_item_end = __pyx_v_item_ptr; + } + __pyx_L26:; + + /* "asyncpg/protocol/codecs/array.pyx":468 + * else: + * item_end = item_ptr + * has_quoting = True # <<<<<<<<<<<<<< + * + * elif ptr[0] == '\\': + */ + __pyx_v_has_quoting = 1; + + /* "asyncpg/protocol/codecs/array.pyx":462 + * + * while not end_of_item: + * if ptr[0] == '"': # <<<<<<<<<<<<<< + * in_quotes = not in_quotes + * if in_quotes: + */ + goto __pyx_L25; + } + + /* "asyncpg/protocol/codecs/array.pyx":470 + * has_quoting = True + * + * elif ptr[0] == '\\': # <<<<<<<<<<<<<< + * # Quoted character, collapse the backslash. + * ptr += 1 + */ + __pyx_t_2 = (((__pyx_v_ptr[0]) == 92) != 0); + if (__pyx_t_2) { + + /* "asyncpg/protocol/codecs/array.pyx":472 + * elif ptr[0] == '\\': + * # Quoted character, collapse the backslash. + * ptr += 1 # <<<<<<<<<<<<<< + * has_quoting = True + * item_ptr[0] = ptr[0] + */ + __pyx_v_ptr = (__pyx_v_ptr + 1); + + /* "asyncpg/protocol/codecs/array.pyx":473 + * # Quoted character, collapse the backslash. + * ptr += 1 + * has_quoting = True # <<<<<<<<<<<<<< + * item_ptr[0] = ptr[0] + * item_ptr += 1 + */ + __pyx_v_has_quoting = 1; + + /* "asyncpg/protocol/codecs/array.pyx":474 + * ptr += 1 + * has_quoting = True + * item_ptr[0] = ptr[0] # <<<<<<<<<<<<<< + * item_ptr += 1 + * strip_spaces = False + */ + (__pyx_v_item_ptr[0]) = (__pyx_v_ptr[0]); + + /* "asyncpg/protocol/codecs/array.pyx":475 + * has_quoting = True + * item_ptr[0] = ptr[0] + * item_ptr += 1 # <<<<<<<<<<<<<< + * strip_spaces = False + * item_end = item_ptr + */ + __pyx_v_item_ptr = (__pyx_v_item_ptr + 1); + + /* "asyncpg/protocol/codecs/array.pyx":476 + * item_ptr[0] = ptr[0] + * item_ptr += 1 + * strip_spaces = False # <<<<<<<<<<<<<< + * item_end = item_ptr + * + */ + __pyx_v_strip_spaces = 0; + + /* "asyncpg/protocol/codecs/array.pyx":477 + * item_ptr += 1 + * strip_spaces = False + * item_end = item_ptr # <<<<<<<<<<<<<< + * + * elif in_quotes: + */ + __pyx_v_item_end = __pyx_v_item_ptr; + + /* "asyncpg/protocol/codecs/array.pyx":470 + * has_quoting = True + * + * elif ptr[0] == '\\': # <<<<<<<<<<<<<< + * # Quoted character, collapse the backslash. + * ptr += 1 + */ + goto __pyx_L25; + } + + /* "asyncpg/protocol/codecs/array.pyx":479 + * item_end = item_ptr + * + * elif in_quotes: # <<<<<<<<<<<<<< + * # Consume the string until we see the closing quote. + * item_ptr[0] = ptr[0] + */ + __pyx_t_2 = (__pyx_v_in_quotes != 0); + if (__pyx_t_2) { + + /* "asyncpg/protocol/codecs/array.pyx":481 + * elif in_quotes: + * # Consume the string until we see the closing quote. + * item_ptr[0] = ptr[0] # <<<<<<<<<<<<<< + * item_ptr += 1 + * + */ + (__pyx_v_item_ptr[0]) = (__pyx_v_ptr[0]); + + /* "asyncpg/protocol/codecs/array.pyx":482 + * # Consume the string until we see the closing quote. + * item_ptr[0] = ptr[0] + * item_ptr += 1 # <<<<<<<<<<<<<< + * + * elif ptr[0] == '{': + */ + __pyx_v_item_ptr = (__pyx_v_item_ptr + 1); + + /* "asyncpg/protocol/codecs/array.pyx":479 + * item_end = item_ptr + * + * elif in_quotes: # <<<<<<<<<<<<<< + * # Consume the string until we see the closing quote. + * item_ptr[0] = ptr[0] + */ + goto __pyx_L25; + } + + /* "asyncpg/protocol/codecs/array.pyx":484 + * item_ptr += 1 + * + * elif ptr[0] == '{': # <<<<<<<<<<<<<< + * # Nesting level increase. + * nest_level += 1 + */ + __pyx_t_2 = (((__pyx_v_ptr[0]) == 0x7B) != 0); + if (__pyx_t_2) { + + /* "asyncpg/protocol/codecs/array.pyx":486 + * elif ptr[0] == '{': + * # Nesting level increase. + * nest_level += 1 # <<<<<<<<<<<<<< + * + * indexes[nest_level - 1] = 0 + */ + __pyx_v_nest_level = (__pyx_v_nest_level + 1); + + /* "asyncpg/protocol/codecs/array.pyx":488 + * nest_level += 1 + * + * indexes[nest_level - 1] = 0 # <<<<<<<<<<<<<< + * new_stride = cpython.PyList_New(dims[nest_level - 1]) + * strides[nest_level - 1] = \ + */ + (__pyx_v_indexes[(__pyx_v_nest_level - 1)]) = 0; + + /* "asyncpg/protocol/codecs/array.pyx":489 + * + * indexes[nest_level - 1] = 0 + * new_stride = cpython.PyList_New(dims[nest_level - 1]) # <<<<<<<<<<<<<< + * strides[nest_level - 1] = \ + * (new_stride) + */ + __pyx_t_1 = PyList_New((__pyx_v_dims[(__pyx_v_nest_level - 1)])); if (unlikely(!__pyx_t_1)) __PYX_ERR(20, 489, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_XDECREF_SET(__pyx_v_new_stride, ((PyObject*)__pyx_t_1)); + __pyx_t_1 = 0; + + /* "asyncpg/protocol/codecs/array.pyx":490 + * indexes[nest_level - 1] = 0 + * new_stride = cpython.PyList_New(dims[nest_level - 1]) + * strides[nest_level - 1] = \ # <<<<<<<<<<<<<< + * (new_stride) + * + */ + (__pyx_v_strides[(__pyx_v_nest_level - 1)]) = ((void *)__pyx_v_new_stride); + + /* "asyncpg/protocol/codecs/array.pyx":493 + * (new_stride) + * + * if nest_level > 1: # <<<<<<<<<<<<<< + * cpython.Py_INCREF(new_stride) + * cpython.PyList_SET_ITEM( + */ + __pyx_t_2 = ((__pyx_v_nest_level > 1) != 0); + if (__pyx_t_2) { + + /* "asyncpg/protocol/codecs/array.pyx":494 + * + * if nest_level > 1: + * cpython.Py_INCREF(new_stride) # <<<<<<<<<<<<<< + * cpython.PyList_SET_ITEM( + * strides[nest_level - 2], + */ + Py_INCREF(__pyx_v_new_stride); + + /* "asyncpg/protocol/codecs/array.pyx":496 + * cpython.Py_INCREF(new_stride) + * cpython.PyList_SET_ITEM( + * strides[nest_level - 2], # <<<<<<<<<<<<<< + * indexes[nest_level - 2], + * new_stride) + */ + __pyx_t_9 = ((PyObject *)(__pyx_v_strides[(__pyx_v_nest_level - 2)])); + + /* "asyncpg/protocol/codecs/array.pyx":495 + * if nest_level > 1: + * cpython.Py_INCREF(new_stride) + * cpython.PyList_SET_ITEM( # <<<<<<<<<<<<<< + * strides[nest_level - 2], + * indexes[nest_level - 2], + */ + PyList_SET_ITEM(((PyObject *)__pyx_t_9), (__pyx_v_indexes[(__pyx_v_nest_level - 2)]), __pyx_v_new_stride); + + /* "asyncpg/protocol/codecs/array.pyx":493 + * (new_stride) + * + * if nest_level > 1: # <<<<<<<<<<<<<< + * cpython.Py_INCREF(new_stride) + * cpython.PyList_SET_ITEM( + */ + goto __pyx_L27; + } + + /* "asyncpg/protocol/codecs/array.pyx":500 + * new_stride) + * else: + * result = new_stride # <<<<<<<<<<<<<< + * + * elif ptr[0] == '}': + */ + /*else*/ { + __Pyx_INCREF(__pyx_v_new_stride); + __Pyx_XDECREF_SET(__pyx_v_result, __pyx_v_new_stride); + } + __pyx_L27:; + + /* "asyncpg/protocol/codecs/array.pyx":484 + * item_ptr += 1 + * + * elif ptr[0] == '{': # <<<<<<<<<<<<<< + * # Nesting level increase. + * nest_level += 1 + */ + goto __pyx_L25; + } + + /* "asyncpg/protocol/codecs/array.pyx":502 + * result = new_stride + * + * elif ptr[0] == '}': # <<<<<<<<<<<<<< + * if item_level == 0: + * # Make sure we keep track of which nesting + */ + __pyx_t_2 = (((__pyx_v_ptr[0]) == 0x7D) != 0); + if (__pyx_t_2) { + + /* "asyncpg/protocol/codecs/array.pyx":503 + * + * elif ptr[0] == '}': + * if item_level == 0: # <<<<<<<<<<<<<< + * # Make sure we keep track of which nesting + * # level the item belongs to, as the loop + */ + __pyx_t_2 = ((__pyx_v_item_level == 0) != 0); + if (__pyx_t_2) { + + /* "asyncpg/protocol/codecs/array.pyx":508 + * # will continue to consume closing braces + * # until the delimiter or the end of input. + * item_level = nest_level # <<<<<<<<<<<<<< + * + * nest_level -= 1 + */ + __pyx_v_item_level = __pyx_v_nest_level; + + /* "asyncpg/protocol/codecs/array.pyx":503 + * + * elif ptr[0] == '}': + * if item_level == 0: # <<<<<<<<<<<<<< + * # Make sure we keep track of which nesting + * # level the item belongs to, as the loop + */ + } + + /* "asyncpg/protocol/codecs/array.pyx":510 + * item_level = nest_level + * + * nest_level -= 1 # <<<<<<<<<<<<<< + * + * if nest_level == 0: + */ + __pyx_v_nest_level = (__pyx_v_nest_level - 1); + + /* "asyncpg/protocol/codecs/array.pyx":512 + * nest_level -= 1 + * + * if nest_level == 0: # <<<<<<<<<<<<<< + * end_of_array = end_of_item = True + * + */ + __pyx_t_2 = ((__pyx_v_nest_level == 0) != 0); + if (__pyx_t_2) { + + /* "asyncpg/protocol/codecs/array.pyx":513 + * + * if nest_level == 0: + * end_of_array = end_of_item = True # <<<<<<<<<<<<<< + * + * elif ptr[0] == typdelim: + */ + __pyx_v_end_of_array = 1; + __pyx_v_end_of_item = 1; + + /* "asyncpg/protocol/codecs/array.pyx":512 + * nest_level -= 1 + * + * if nest_level == 0: # <<<<<<<<<<<<<< + * end_of_array = end_of_item = True + * + */ + } + + /* "asyncpg/protocol/codecs/array.pyx":502 + * result = new_stride + * + * elif ptr[0] == '}': # <<<<<<<<<<<<<< + * if item_level == 0: + * # Make sure we keep track of which nesting + */ + goto __pyx_L25; + } + + /* "asyncpg/protocol/codecs/array.pyx":515 + * end_of_array = end_of_item = True + * + * elif ptr[0] == typdelim: # <<<<<<<<<<<<<< + * # Array element delimiter, + * end_of_item = True + */ + __pyx_t_2 = (((__pyx_v_ptr[0]) == __pyx_v_typdelim) != 0); + if (__pyx_t_2) { + + /* "asyncpg/protocol/codecs/array.pyx":517 + * elif ptr[0] == typdelim: + * # Array element delimiter, + * end_of_item = True # <<<<<<<<<<<<<< + * if item_level == 0: + * item_level = nest_level + */ + __pyx_v_end_of_item = 1; + + /* "asyncpg/protocol/codecs/array.pyx":518 + * # Array element delimiter, + * end_of_item = True + * if item_level == 0: # <<<<<<<<<<<<<< + * item_level = nest_level + * + */ + __pyx_t_2 = ((__pyx_v_item_level == 0) != 0); + if (__pyx_t_2) { + + /* "asyncpg/protocol/codecs/array.pyx":519 + * end_of_item = True + * if item_level == 0: + * item_level = nest_level # <<<<<<<<<<<<<< + * + * elif apg_ascii_isspace(ptr[0]): + */ + __pyx_v_item_level = __pyx_v_nest_level; + + /* "asyncpg/protocol/codecs/array.pyx":518 + * # Array element delimiter, + * end_of_item = True + * if item_level == 0: # <<<<<<<<<<<<<< + * item_level = nest_level + * + */ + } + + /* "asyncpg/protocol/codecs/array.pyx":515 + * end_of_array = end_of_item = True + * + * elif ptr[0] == typdelim: # <<<<<<<<<<<<<< + * # Array element delimiter, + * end_of_item = True + */ + goto __pyx_L25; + } + + /* "asyncpg/protocol/codecs/array.pyx":521 + * item_level = nest_level + * + * elif apg_ascii_isspace(ptr[0]): # <<<<<<<<<<<<<< + * if not strip_spaces: + * item_ptr[0] = ptr[0] + */ + __pyx_t_2 = (__pyx_f_7asyncpg_8protocol_8protocol_apg_ascii_isspace((__pyx_v_ptr[0])) != 0); + if (__pyx_t_2) { + + /* "asyncpg/protocol/codecs/array.pyx":522 + * + * elif apg_ascii_isspace(ptr[0]): + * if not strip_spaces: # <<<<<<<<<<<<<< + * item_ptr[0] = ptr[0] + * item_ptr += 1 + */ + __pyx_t_2 = ((!(__pyx_v_strip_spaces != 0)) != 0); + if (__pyx_t_2) { + + /* "asyncpg/protocol/codecs/array.pyx":523 + * elif apg_ascii_isspace(ptr[0]): + * if not strip_spaces: + * item_ptr[0] = ptr[0] # <<<<<<<<<<<<<< + * item_ptr += 1 + * # Ignore the leading literal whitespace. + */ + (__pyx_v_item_ptr[0]) = (__pyx_v_ptr[0]); + + /* "asyncpg/protocol/codecs/array.pyx":524 + * if not strip_spaces: + * item_ptr[0] = ptr[0] + * item_ptr += 1 # <<<<<<<<<<<<<< + * # Ignore the leading literal whitespace. + * + */ + __pyx_v_item_ptr = (__pyx_v_item_ptr + 1); + + /* "asyncpg/protocol/codecs/array.pyx":522 + * + * elif apg_ascii_isspace(ptr[0]): + * if not strip_spaces: # <<<<<<<<<<<<<< + * item_ptr[0] = ptr[0] + * item_ptr += 1 + */ + } + + /* "asyncpg/protocol/codecs/array.pyx":521 + * item_level = nest_level + * + * elif apg_ascii_isspace(ptr[0]): # <<<<<<<<<<<<<< + * if not strip_spaces: + * item_ptr[0] = ptr[0] + */ + goto __pyx_L25; + } + + /* "asyncpg/protocol/codecs/array.pyx":528 + * + * else: + * item_ptr[0] = ptr[0] # <<<<<<<<<<<<<< + * item_ptr += 1 + * strip_spaces = False + */ + /*else*/ { + (__pyx_v_item_ptr[0]) = (__pyx_v_ptr[0]); + + /* "asyncpg/protocol/codecs/array.pyx":529 + * else: + * item_ptr[0] = ptr[0] + * item_ptr += 1 # <<<<<<<<<<<<<< + * strip_spaces = False + * item_end = item_ptr + */ + __pyx_v_item_ptr = (__pyx_v_item_ptr + 1); + + /* "asyncpg/protocol/codecs/array.pyx":530 + * item_ptr[0] = ptr[0] + * item_ptr += 1 + * strip_spaces = False # <<<<<<<<<<<<<< + * item_end = item_ptr + * + */ + __pyx_v_strip_spaces = 0; + + /* "asyncpg/protocol/codecs/array.pyx":531 + * item_ptr += 1 + * strip_spaces = False + * item_end = item_ptr # <<<<<<<<<<<<<< + * + * ptr += 1 + */ + __pyx_v_item_end = __pyx_v_item_ptr; + } + __pyx_L25:; + + /* "asyncpg/protocol/codecs/array.pyx":533 + * item_end = item_ptr + * + * ptr += 1 # <<<<<<<<<<<<<< + * + * # end while not end_of_item + */ + __pyx_v_ptr = (__pyx_v_ptr + 1); + } + + /* "asyncpg/protocol/codecs/array.pyx":537 + * # end while not end_of_item + * + * if item_end == item_start: # <<<<<<<<<<<<<< + * # Empty array + * continue + */ + __pyx_t_2 = ((__pyx_v_item_end == __pyx_v_item_start) != 0); + if (__pyx_t_2) { + + /* "asyncpg/protocol/codecs/array.pyx":539 + * if item_end == item_start: + * # Empty array + * continue # <<<<<<<<<<<<<< + * + * item_end[0] = '\0' + */ + goto __pyx_L21_continue; + + /* "asyncpg/protocol/codecs/array.pyx":537 + * # end while not end_of_item + * + * if item_end == item_start: # <<<<<<<<<<<<<< + * # Empty array + * continue + */ + } + + /* "asyncpg/protocol/codecs/array.pyx":541 + * continue + * + * item_end[0] = '\0' # <<<<<<<<<<<<<< + * + * if not has_quoting and apg_strcasecmp(item_start, APG_NULL) == 0: + */ + (__pyx_v_item_end[0]) = 0; + + /* "asyncpg/protocol/codecs/array.pyx":543 + * item_end[0] = '\0' + * + * if not has_quoting and apg_strcasecmp(item_start, APG_NULL) == 0: # <<<<<<<<<<<<<< + * # NULL element. + * item = None + */ + __pyx_t_10 = ((!(__pyx_v_has_quoting != 0)) != 0); + if (__pyx_t_10) { + } else { + __pyx_t_2 = __pyx_t_10; + goto __pyx_L34_bool_binop_done; + } + __pyx_t_10 = ((__pyx_f_7asyncpg_8protocol_8protocol_apg_strcasecmp(__pyx_v_item_start, __pyx_v_7asyncpg_8protocol_8protocol_APG_NULL) == 0) != 0); + __pyx_t_2 = __pyx_t_10; + __pyx_L34_bool_binop_done:; + if (__pyx_t_2) { + + /* "asyncpg/protocol/codecs/array.pyx":545 + * if not has_quoting and apg_strcasecmp(item_start, APG_NULL) == 0: + * # NULL element. + * item = None # <<<<<<<<<<<<<< + * else: + * # XXX: find a way to avoid the redundant encode/decode + */ + __Pyx_INCREF(Py_None); + __Pyx_XDECREF_SET(__pyx_v_item, Py_None); + + /* "asyncpg/protocol/codecs/array.pyx":543 + * item_end[0] = '\0' + * + * if not has_quoting and apg_strcasecmp(item_start, APG_NULL) == 0: # <<<<<<<<<<<<<< + * # NULL element. + * item = None + */ + goto __pyx_L33; + } + + /* "asyncpg/protocol/codecs/array.pyx":549 + * # XXX: find a way to avoid the redundant encode/decode + * # cycle here. + * item_text = PyUnicode_FromKindAndData( # <<<<<<<<<<<<<< + * PyUnicode_4BYTE_KIND, + * item_start, + */ + /*else*/ { + + /* "asyncpg/protocol/codecs/array.pyx":552 + * PyUnicode_4BYTE_KIND, + * item_start, + * item_end - item_start) # <<<<<<<<<<<<<< + * + * # Prepare the element buffer and call the text decoder + */ + __pyx_t_1 = PyUnicode_FromKindAndData(PyUnicode_4BYTE_KIND, ((void *)__pyx_v_item_start), (__pyx_v_item_end - __pyx_v_item_start)); if (unlikely(!__pyx_t_1)) __PYX_ERR(20, 549, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + + /* "asyncpg/protocol/codecs/array.pyx":549 + * # XXX: find a way to avoid the redundant encode/decode + * # cycle here. + * item_text = PyUnicode_FromKindAndData( # <<<<<<<<<<<<<< + * PyUnicode_4BYTE_KIND, + * item_start, + */ + if (!(likely(PyUnicode_CheckExact(__pyx_t_1))||((__pyx_t_1) == Py_None)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "unicode", Py_TYPE(__pyx_t_1)->tp_name), 0))) __PYX_ERR(20, 549, __pyx_L1_error) + __Pyx_XDECREF_SET(__pyx_v_item_text, ((PyObject*)__pyx_t_1)); + __pyx_t_1 = 0; + + /* "asyncpg/protocol/codecs/array.pyx":556 + * # Prepare the element buffer and call the text decoder + * # for the element type. + * as_pg_string_and_size( # <<<<<<<<<<<<<< + * settings, item_text, &pg_item_str, &pg_item_len) + * item_buf.buf = pg_item_str + */ + __pyx_t_1 = __pyx_f_7asyncpg_8protocol_8protocol_as_pg_string_and_size(__pyx_v_settings, __pyx_v_item_text, (&__pyx_v_pg_item_str), (&__pyx_v_pg_item_len)); if (unlikely(!__pyx_t_1)) __PYX_ERR(20, 556, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "asyncpg/protocol/codecs/array.pyx":558 + * as_pg_string_and_size( + * settings, item_text, &pg_item_str, &pg_item_len) + * item_buf.buf = pg_item_str # <<<<<<<<<<<<<< + * item_buf.len = pg_item_len + * item = decoder(settings, item_buf, decoder_arg) + */ + __pyx_v_item_buf->buf = __pyx_v_pg_item_str; + + /* "asyncpg/protocol/codecs/array.pyx":559 + * settings, item_text, &pg_item_str, &pg_item_len) + * item_buf.buf = pg_item_str + * item_buf.len = pg_item_len # <<<<<<<<<<<<<< + * item = decoder(settings, item_buf, decoder_arg) + * + */ + __pyx_v_item_buf->len = __pyx_v_pg_item_len; + + /* "asyncpg/protocol/codecs/array.pyx":560 + * item_buf.buf = pg_item_str + * item_buf.len = pg_item_len + * item = decoder(settings, item_buf, decoder_arg) # <<<<<<<<<<<<<< + * + * # Place the decoded element in the array. + */ + __pyx_t_1 = __pyx_v_decoder(__pyx_v_settings, __pyx_v_item_buf, __pyx_v_decoder_arg); if (unlikely(!__pyx_t_1)) __PYX_ERR(20, 560, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_XDECREF_SET(__pyx_v_item, __pyx_t_1); + __pyx_t_1 = 0; + } + __pyx_L33:; + + /* "asyncpg/protocol/codecs/array.pyx":563 + * + * # Place the decoded element in the array. + * cpython.Py_INCREF(item) # <<<<<<<<<<<<<< + * cpython.PyList_SET_ITEM( + * strides[item_level - 1], + */ + Py_INCREF(__pyx_v_item); + + /* "asyncpg/protocol/codecs/array.pyx":565 + * cpython.Py_INCREF(item) + * cpython.PyList_SET_ITEM( + * strides[item_level - 1], # <<<<<<<<<<<<<< + * indexes[item_level - 1], + * item) + */ + __pyx_t_9 = ((PyObject *)(__pyx_v_strides[(__pyx_v_item_level - 1)])); + + /* "asyncpg/protocol/codecs/array.pyx":564 + * # Place the decoded element in the array. + * cpython.Py_INCREF(item) + * cpython.PyList_SET_ITEM( # <<<<<<<<<<<<<< + * strides[item_level - 1], + * indexes[item_level - 1], + */ + PyList_SET_ITEM(((PyObject *)__pyx_t_9), (__pyx_v_indexes[(__pyx_v_item_level - 1)]), __pyx_v_item); + + /* "asyncpg/protocol/codecs/array.pyx":569 + * item) + * + * indexes[nest_level - 1] += 1 # <<<<<<<<<<<<<< + * + * return result + */ + __pyx_t_11 = (__pyx_v_nest_level - 1); + (__pyx_v_indexes[__pyx_t_11]) = ((__pyx_v_indexes[__pyx_t_11]) + 1); + __pyx_L21_continue:; + } + + /* "asyncpg/protocol/codecs/array.pyx":571 + * indexes[nest_level - 1] += 1 + * + * return result # <<<<<<<<<<<<<< + * + * + */ + __Pyx_XDECREF(__pyx_r); + if (unlikely(!__pyx_v_result)) { __Pyx_RaiseUnboundLocalError("result"); __PYX_ERR(20, 571, __pyx_L1_error) } + __Pyx_INCREF(__pyx_v_result); + __pyx_r = __pyx_v_result; + goto __pyx_L0; + + /* "asyncpg/protocol/codecs/array.pyx":340 + * + * + * cdef _textarray_decode(ConnectionSettings settings, # <<<<<<<<<<<<<< + * Py_UCS4 *array_text, + * decode_func_ex decoder, + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_XDECREF(__pyx_t_7); + __Pyx_AddTraceback("asyncpg.protocol.protocol._textarray_decode", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XDECREF(__pyx_v_result); + __Pyx_XDECREF(__pyx_v_new_stride); + __Pyx_XDECREF(__pyx_v_item); + __Pyx_XDECREF(__pyx_v_item_text); + __Pyx_XDECREF((PyObject *)__pyx_v_item_buf); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "asyncpg/protocol/codecs/array.pyx":583 + * + * + * cdef _UnexpectedCharacter(const Py_UCS4 *array_text, const Py_UCS4 *ptr): # <<<<<<<<<<<<<< + * return ValueError('unexpected character {!r} at position {}'.format( + * cpython.PyUnicode_FromOrdinal(ptr[0]), ptr - array_text + 1)) + */ + +static PyObject *__pyx_f_7asyncpg_8protocol_8protocol__UnexpectedCharacter(Py_UCS4 const *__pyx_v_array_text, Py_UCS4 const *__pyx_v_ptr) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + PyObject *__pyx_t_5 = NULL; + int __pyx_t_6; + PyObject *__pyx_t_7 = NULL; + __Pyx_RefNannySetupContext("_UnexpectedCharacter", 0); + + /* "asyncpg/protocol/codecs/array.pyx":584 + * + * cdef _UnexpectedCharacter(const Py_UCS4 *array_text, const Py_UCS4 *ptr): + * return ValueError('unexpected character {!r} at position {}'.format( # <<<<<<<<<<<<<< + * cpython.PyUnicode_FromOrdinal(ptr[0]), ptr - array_text + 1)) + * + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_kp_u_unexpected_character_r_at_positi, __pyx_n_s_format); if (unlikely(!__pyx_t_2)) __PYX_ERR(20, 584, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + + /* "asyncpg/protocol/codecs/array.pyx":585 + * cdef _UnexpectedCharacter(const Py_UCS4 *array_text, const Py_UCS4 *ptr): + * return ValueError('unexpected character {!r} at position {}'.format( + * cpython.PyUnicode_FromOrdinal(ptr[0]), ptr - array_text + 1)) # <<<<<<<<<<<<<< + * + * + */ + __pyx_t_3 = PyUnicode_FromOrdinal(((int)(__pyx_v_ptr[0]))); if (unlikely(!__pyx_t_3)) __PYX_ERR(20, 585, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = __Pyx_PyInt_From_ptrdiff_t(((__pyx_v_ptr - __pyx_v_array_text) + 1)); if (unlikely(!__pyx_t_4)) __PYX_ERR(20, 585, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_5 = NULL; + __pyx_t_6 = 0; + if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_5)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_5); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + __pyx_t_6 = 1; + } + } + #if CYTHON_FAST_PYCALL + if (PyFunction_Check(__pyx_t_2)) { + PyObject *__pyx_temp[3] = {__pyx_t_5, __pyx_t_3, __pyx_t_4}; + __pyx_t_1 = __Pyx_PyFunction_FastCall(__pyx_t_2, __pyx_temp+1-__pyx_t_6, 2+__pyx_t_6); if (unlikely(!__pyx_t_1)) __PYX_ERR(20, 584, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + } else + #endif + #if CYTHON_FAST_PYCCALL + if (__Pyx_PyFastCFunction_Check(__pyx_t_2)) { + PyObject *__pyx_temp[3] = {__pyx_t_5, __pyx_t_3, __pyx_t_4}; + __pyx_t_1 = __Pyx_PyCFunction_FastCall(__pyx_t_2, __pyx_temp+1-__pyx_t_6, 2+__pyx_t_6); if (unlikely(!__pyx_t_1)) __PYX_ERR(20, 584, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + } else + #endif + { + __pyx_t_7 = PyTuple_New(2+__pyx_t_6); if (unlikely(!__pyx_t_7)) __PYX_ERR(20, 584, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + if (__pyx_t_5) { + __Pyx_GIVEREF(__pyx_t_5); PyTuple_SET_ITEM(__pyx_t_7, 0, __pyx_t_5); __pyx_t_5 = NULL; + } + __Pyx_GIVEREF(__pyx_t_3); + PyTuple_SET_ITEM(__pyx_t_7, 0+__pyx_t_6, __pyx_t_3); + __Pyx_GIVEREF(__pyx_t_4); + PyTuple_SET_ITEM(__pyx_t_7, 1+__pyx_t_6, __pyx_t_4); + __pyx_t_3 = 0; + __pyx_t_4 = 0; + __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_t_7, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(20, 584, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + } + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "asyncpg/protocol/codecs/array.pyx":584 + * + * cdef _UnexpectedCharacter(const Py_UCS4 *array_text, const Py_UCS4 *ptr): + * return ValueError('unexpected character {!r} at position {}'.format( # <<<<<<<<<<<<<< + * cpython.PyUnicode_FromOrdinal(ptr[0]), ptr - array_text + 1)) + * + */ + __pyx_t_2 = PyTuple_New(1); if (unlikely(!__pyx_t_2)) __PYX_ERR(20, 584, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_GIVEREF(__pyx_t_1); + PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_t_1); + __pyx_t_1 = 0; + __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_t_2, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(20, 584, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "asyncpg/protocol/codecs/array.pyx":583 + * + * + * cdef _UnexpectedCharacter(const Py_UCS4 *array_text, const Py_UCS4 *ptr): # <<<<<<<<<<<<<< + * return ValueError('unexpected character {!r} at position {}'.format( + * cpython.PyUnicode_FromOrdinal(ptr[0]), ptr - array_text + 1)) + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_XDECREF(__pyx_t_7); + __Pyx_AddTraceback("asyncpg.protocol.protocol._UnexpectedCharacter", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "asyncpg/protocol/codecs/array.pyx":588 + * + * + * cdef _infer_array_dims(const Py_UCS4 *array_text, # <<<<<<<<<<<<<< + * Py_UCS4 typdelim, + * int32_t *dims, + */ + +static PyObject *__pyx_f_7asyncpg_8protocol_8protocol__infer_array_dims(Py_UCS4 const *__pyx_v_array_text, Py_UCS4 __pyx_v_typdelim, int32_t *__pyx_v_dims, int32_t *__pyx_v_ndims) { + Py_UCS4 const *__pyx_v_ptr; + int __pyx_v_i; + int __pyx_v_nest_level; + int __pyx_v_end_of_array; + int __pyx_v_end_of_item; + int __pyx_v_in_quotes; + int __pyx_v_array_is_empty; + int __pyx_v_stride_len[6]; + int __pyx_v_prev_stride_len[6]; + enum __pyx_t_7asyncpg_8protocol_8protocol__ArrayParseState __pyx_v_parse_state; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + int __pyx_t_2; + PyObject *__pyx_t_3 = NULL; + int __pyx_t_4; + int __pyx_t_5; + PyObject *__pyx_t_6 = NULL; + PyObject *__pyx_t_7 = NULL; + PyObject *__pyx_t_8 = NULL; + PyObject *__pyx_t_9 = NULL; + long __pyx_t_10; + __Pyx_RefNannySetupContext("_infer_array_dims", 0); + + /* "asyncpg/protocol/codecs/array.pyx":593 + * int32_t *ndims): + * cdef: + * const Py_UCS4 *ptr = array_text # <<<<<<<<<<<<<< + * int i + * int nest_level = 0 + */ + __pyx_v_ptr = __pyx_v_array_text; + + /* "asyncpg/protocol/codecs/array.pyx":595 + * const Py_UCS4 *ptr = array_text + * int i + * int nest_level = 0 # <<<<<<<<<<<<<< + * bint end_of_array = False + * bint end_of_item = False + */ + __pyx_v_nest_level = 0; + + /* "asyncpg/protocol/codecs/array.pyx":596 + * int i + * int nest_level = 0 + * bint end_of_array = False # <<<<<<<<<<<<<< + * bint end_of_item = False + * bint in_quotes = False + */ + __pyx_v_end_of_array = 0; + + /* "asyncpg/protocol/codecs/array.pyx":597 + * int nest_level = 0 + * bint end_of_array = False + * bint end_of_item = False # <<<<<<<<<<<<<< + * bint in_quotes = False + * bint array_is_empty = True + */ + __pyx_v_end_of_item = 0; + + /* "asyncpg/protocol/codecs/array.pyx":598 + * bint end_of_array = False + * bint end_of_item = False + * bint in_quotes = False # <<<<<<<<<<<<<< + * bint array_is_empty = True + * int stride_len[ARRAY_MAXDIM] + */ + __pyx_v_in_quotes = 0; + + /* "asyncpg/protocol/codecs/array.pyx":599 + * bint end_of_item = False + * bint in_quotes = False + * bint array_is_empty = True # <<<<<<<<<<<<<< + * int stride_len[ARRAY_MAXDIM] + * int prev_stride_len[ARRAY_MAXDIM] + */ + __pyx_v_array_is_empty = 1; + + /* "asyncpg/protocol/codecs/array.pyx":602 + * int stride_len[ARRAY_MAXDIM] + * int prev_stride_len[ARRAY_MAXDIM] + * _ArrayParseState parse_state = APS_START # <<<<<<<<<<<<<< + * + * for i in range(ARRAY_MAXDIM): + */ + __pyx_v_parse_state = __pyx_e_7asyncpg_8protocol_8protocol_APS_START; + + /* "asyncpg/protocol/codecs/array.pyx":604 + * _ArrayParseState parse_state = APS_START + * + * for i in range(ARRAY_MAXDIM): # <<<<<<<<<<<<<< + * dims[i] = prev_stride_len[i] = 0 + * stride_len[i] = 1 + */ + for (__pyx_t_1 = 0; __pyx_t_1 < 6; __pyx_t_1+=1) { + __pyx_v_i = __pyx_t_1; + + /* "asyncpg/protocol/codecs/array.pyx":605 + * + * for i in range(ARRAY_MAXDIM): + * dims[i] = prev_stride_len[i] = 0 # <<<<<<<<<<<<<< + * stride_len[i] = 1 + * + */ + (__pyx_v_dims[__pyx_v_i]) = 0; + (__pyx_v_prev_stride_len[__pyx_v_i]) = 0; + + /* "asyncpg/protocol/codecs/array.pyx":606 + * for i in range(ARRAY_MAXDIM): + * dims[i] = prev_stride_len[i] = 0 + * stride_len[i] = 1 # <<<<<<<<<<<<<< + * + * while not end_of_array: + */ + (__pyx_v_stride_len[__pyx_v_i]) = 1; + } + + /* "asyncpg/protocol/codecs/array.pyx":608 + * stride_len[i] = 1 + * + * while not end_of_array: # <<<<<<<<<<<<<< + * end_of_item = False + * + */ + while (1) { + __pyx_t_2 = ((!(__pyx_v_end_of_array != 0)) != 0); + if (!__pyx_t_2) break; + + /* "asyncpg/protocol/codecs/array.pyx":609 + * + * while not end_of_array: + * end_of_item = False # <<<<<<<<<<<<<< + * + * while not end_of_item: + */ + __pyx_v_end_of_item = 0; + + /* "asyncpg/protocol/codecs/array.pyx":611 + * end_of_item = False + * + * while not end_of_item: # <<<<<<<<<<<<<< + * if ptr[0] == '\0': + * raise ValueError('unexpected end of string') + */ + while (1) { + __pyx_t_2 = ((!(__pyx_v_end_of_item != 0)) != 0); + if (!__pyx_t_2) break; + + /* "asyncpg/protocol/codecs/array.pyx":612 + * + * while not end_of_item: + * if ptr[0] == '\0': # <<<<<<<<<<<<<< + * raise ValueError('unexpected end of string') + * + */ + __pyx_t_2 = (((__pyx_v_ptr[0]) == 0) != 0); + if (__pyx_t_2) { + + /* "asyncpg/protocol/codecs/array.pyx":613 + * while not end_of_item: + * if ptr[0] == '\0': + * raise ValueError('unexpected end of string') # <<<<<<<<<<<<<< + * + * elif ptr[0] == '"': + */ + __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__49, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(20, 613, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_Raise(__pyx_t_3, 0, 0, 0); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __PYX_ERR(20, 613, __pyx_L1_error) + + /* "asyncpg/protocol/codecs/array.pyx":612 + * + * while not end_of_item: + * if ptr[0] == '\0': # <<<<<<<<<<<<<< + * raise ValueError('unexpected end of string') + * + */ + } + + /* "asyncpg/protocol/codecs/array.pyx":615 + * raise ValueError('unexpected end of string') + * + * elif ptr[0] == '"': # <<<<<<<<<<<<<< + * if (parse_state not in (APS_STRIDE_STARTED, + * APS_ELEM_DELIMITED) and + */ + __pyx_t_2 = (((__pyx_v_ptr[0]) == 34) != 0); + if (__pyx_t_2) { + + /* "asyncpg/protocol/codecs/array.pyx":616 + * + * elif ptr[0] == '"': + * if (parse_state not in (APS_STRIDE_STARTED, # <<<<<<<<<<<<<< + * APS_ELEM_DELIMITED) and + * not (parse_state == APS_ELEM_STARTED and in_quotes)): + */ + switch (__pyx_v_parse_state) { + case __pyx_e_7asyncpg_8protocol_8protocol_APS_STRIDE_STARTED: + + /* "asyncpg/protocol/codecs/array.pyx":617 + * elif ptr[0] == '"': + * if (parse_state not in (APS_STRIDE_STARTED, + * APS_ELEM_DELIMITED) and # <<<<<<<<<<<<<< + * not (parse_state == APS_ELEM_STARTED and in_quotes)): + * raise _UnexpectedCharacter(array_text, ptr) + */ + case __pyx_e_7asyncpg_8protocol_8protocol_APS_ELEM_DELIMITED: + + /* "asyncpg/protocol/codecs/array.pyx":616 + * + * elif ptr[0] == '"': + * if (parse_state not in (APS_STRIDE_STARTED, # <<<<<<<<<<<<<< + * APS_ELEM_DELIMITED) and + * not (parse_state == APS_ELEM_STARTED and in_quotes)): + */ + __pyx_t_4 = 0; + break; + default: + __pyx_t_4 = 1; + break; + } + __pyx_t_5 = (__pyx_t_4 != 0); + if (__pyx_t_5) { + } else { + __pyx_t_2 = __pyx_t_5; + goto __pyx_L11_bool_binop_done; + } + + /* "asyncpg/protocol/codecs/array.pyx":618 + * if (parse_state not in (APS_STRIDE_STARTED, + * APS_ELEM_DELIMITED) and + * not (parse_state == APS_ELEM_STARTED and in_quotes)): # <<<<<<<<<<<<<< + * raise _UnexpectedCharacter(array_text, ptr) + * + */ + __pyx_t_4 = ((__pyx_v_parse_state == __pyx_e_7asyncpg_8protocol_8protocol_APS_ELEM_STARTED) != 0); + if (__pyx_t_4) { + } else { + __pyx_t_5 = __pyx_t_4; + goto __pyx_L13_bool_binop_done; + } + __pyx_t_4 = (__pyx_v_in_quotes != 0); + __pyx_t_5 = __pyx_t_4; + __pyx_L13_bool_binop_done:; + __pyx_t_4 = ((!__pyx_t_5) != 0); + __pyx_t_2 = __pyx_t_4; + __pyx_L11_bool_binop_done:; + + /* "asyncpg/protocol/codecs/array.pyx":616 + * + * elif ptr[0] == '"': + * if (parse_state not in (APS_STRIDE_STARTED, # <<<<<<<<<<<<<< + * APS_ELEM_DELIMITED) and + * not (parse_state == APS_ELEM_STARTED and in_quotes)): + */ + if (__pyx_t_2) { + + /* "asyncpg/protocol/codecs/array.pyx":619 + * APS_ELEM_DELIMITED) and + * not (parse_state == APS_ELEM_STARTED and in_quotes)): + * raise _UnexpectedCharacter(array_text, ptr) # <<<<<<<<<<<<<< + * + * in_quotes = not in_quotes + */ + __pyx_t_3 = __pyx_f_7asyncpg_8protocol_8protocol__UnexpectedCharacter(__pyx_v_array_text, __pyx_v_ptr); if (unlikely(!__pyx_t_3)) __PYX_ERR(20, 619, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_Raise(__pyx_t_3, 0, 0, 0); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __PYX_ERR(20, 619, __pyx_L1_error) + + /* "asyncpg/protocol/codecs/array.pyx":616 + * + * elif ptr[0] == '"': + * if (parse_state not in (APS_STRIDE_STARTED, # <<<<<<<<<<<<<< + * APS_ELEM_DELIMITED) and + * not (parse_state == APS_ELEM_STARTED and in_quotes)): + */ + } + + /* "asyncpg/protocol/codecs/array.pyx":621 + * raise _UnexpectedCharacter(array_text, ptr) + * + * in_quotes = not in_quotes # <<<<<<<<<<<<<< + * if in_quotes: + * parse_state = APS_ELEM_STARTED + */ + __pyx_v_in_quotes = (!(__pyx_v_in_quotes != 0)); + + /* "asyncpg/protocol/codecs/array.pyx":622 + * + * in_quotes = not in_quotes + * if in_quotes: # <<<<<<<<<<<<<< + * parse_state = APS_ELEM_STARTED + * array_is_empty = False + */ + __pyx_t_2 = (__pyx_v_in_quotes != 0); + if (__pyx_t_2) { + + /* "asyncpg/protocol/codecs/array.pyx":623 + * in_quotes = not in_quotes + * if in_quotes: + * parse_state = APS_ELEM_STARTED # <<<<<<<<<<<<<< + * array_is_empty = False + * + */ + __pyx_v_parse_state = __pyx_e_7asyncpg_8protocol_8protocol_APS_ELEM_STARTED; + + /* "asyncpg/protocol/codecs/array.pyx":624 + * if in_quotes: + * parse_state = APS_ELEM_STARTED + * array_is_empty = False # <<<<<<<<<<<<<< + * + * elif ptr[0] == '\\': + */ + __pyx_v_array_is_empty = 0; + + /* "asyncpg/protocol/codecs/array.pyx":622 + * + * in_quotes = not in_quotes + * if in_quotes: # <<<<<<<<<<<<<< + * parse_state = APS_ELEM_STARTED + * array_is_empty = False + */ + } + + /* "asyncpg/protocol/codecs/array.pyx":615 + * raise ValueError('unexpected end of string') + * + * elif ptr[0] == '"': # <<<<<<<<<<<<<< + * if (parse_state not in (APS_STRIDE_STARTED, + * APS_ELEM_DELIMITED) and + */ + goto __pyx_L9; + } + + /* "asyncpg/protocol/codecs/array.pyx":626 + * array_is_empty = False + * + * elif ptr[0] == '\\': # <<<<<<<<<<<<<< + * if parse_state not in (APS_STRIDE_STARTED, + * APS_ELEM_STARTED, + */ + __pyx_t_2 = (((__pyx_v_ptr[0]) == 92) != 0); + if (__pyx_t_2) { + + /* "asyncpg/protocol/codecs/array.pyx":627 + * + * elif ptr[0] == '\\': + * if parse_state not in (APS_STRIDE_STARTED, # <<<<<<<<<<<<<< + * APS_ELEM_STARTED, + * APS_ELEM_DELIMITED): + */ + switch (__pyx_v_parse_state) { + case __pyx_e_7asyncpg_8protocol_8protocol_APS_STRIDE_STARTED: + + /* "asyncpg/protocol/codecs/array.pyx":628 + * elif ptr[0] == '\\': + * if parse_state not in (APS_STRIDE_STARTED, + * APS_ELEM_STARTED, # <<<<<<<<<<<<<< + * APS_ELEM_DELIMITED): + * raise _UnexpectedCharacter(array_text, ptr) + */ + case __pyx_e_7asyncpg_8protocol_8protocol_APS_ELEM_STARTED: + + /* "asyncpg/protocol/codecs/array.pyx":629 + * if parse_state not in (APS_STRIDE_STARTED, + * APS_ELEM_STARTED, + * APS_ELEM_DELIMITED): # <<<<<<<<<<<<<< + * raise _UnexpectedCharacter(array_text, ptr) + * + */ + case __pyx_e_7asyncpg_8protocol_8protocol_APS_ELEM_DELIMITED: + + /* "asyncpg/protocol/codecs/array.pyx":627 + * + * elif ptr[0] == '\\': + * if parse_state not in (APS_STRIDE_STARTED, # <<<<<<<<<<<<<< + * APS_ELEM_STARTED, + * APS_ELEM_DELIMITED): + */ + __pyx_t_2 = 0; + break; + default: + __pyx_t_2 = 1; + break; + } + __pyx_t_4 = (__pyx_t_2 != 0); + if (__pyx_t_4) { + + /* "asyncpg/protocol/codecs/array.pyx":630 + * APS_ELEM_STARTED, + * APS_ELEM_DELIMITED): + * raise _UnexpectedCharacter(array_text, ptr) # <<<<<<<<<<<<<< + * + * parse_state = APS_ELEM_STARTED + */ + __pyx_t_3 = __pyx_f_7asyncpg_8protocol_8protocol__UnexpectedCharacter(__pyx_v_array_text, __pyx_v_ptr); if (unlikely(!__pyx_t_3)) __PYX_ERR(20, 630, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_Raise(__pyx_t_3, 0, 0, 0); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __PYX_ERR(20, 630, __pyx_L1_error) + + /* "asyncpg/protocol/codecs/array.pyx":627 + * + * elif ptr[0] == '\\': + * if parse_state not in (APS_STRIDE_STARTED, # <<<<<<<<<<<<<< + * APS_ELEM_STARTED, + * APS_ELEM_DELIMITED): + */ + } + + /* "asyncpg/protocol/codecs/array.pyx":632 + * raise _UnexpectedCharacter(array_text, ptr) + * + * parse_state = APS_ELEM_STARTED # <<<<<<<<<<<<<< + * array_is_empty = False + * + */ + __pyx_v_parse_state = __pyx_e_7asyncpg_8protocol_8protocol_APS_ELEM_STARTED; + + /* "asyncpg/protocol/codecs/array.pyx":633 + * + * parse_state = APS_ELEM_STARTED + * array_is_empty = False # <<<<<<<<<<<<<< + * + * if ptr[1] != '\0': + */ + __pyx_v_array_is_empty = 0; + + /* "asyncpg/protocol/codecs/array.pyx":635 + * array_is_empty = False + * + * if ptr[1] != '\0': # <<<<<<<<<<<<<< + * ptr += 1 + * else: + */ + __pyx_t_4 = (((__pyx_v_ptr[1]) != 0) != 0); + if (__pyx_t_4) { + + /* "asyncpg/protocol/codecs/array.pyx":636 + * + * if ptr[1] != '\0': + * ptr += 1 # <<<<<<<<<<<<<< + * else: + * raise ValueError('unexpected end of string') + */ + __pyx_v_ptr = (__pyx_v_ptr + 1); + + /* "asyncpg/protocol/codecs/array.pyx":635 + * array_is_empty = False + * + * if ptr[1] != '\0': # <<<<<<<<<<<<<< + * ptr += 1 + * else: + */ + goto __pyx_L17; + } + + /* "asyncpg/protocol/codecs/array.pyx":638 + * ptr += 1 + * else: + * raise ValueError('unexpected end of string') # <<<<<<<<<<<<<< + * + * elif in_quotes: + */ + /*else*/ { + __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__50, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(20, 638, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_Raise(__pyx_t_3, 0, 0, 0); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __PYX_ERR(20, 638, __pyx_L1_error) + } + __pyx_L17:; + + /* "asyncpg/protocol/codecs/array.pyx":626 + * array_is_empty = False + * + * elif ptr[0] == '\\': # <<<<<<<<<<<<<< + * if parse_state not in (APS_STRIDE_STARTED, + * APS_ELEM_STARTED, + */ + goto __pyx_L9; + } + + /* "asyncpg/protocol/codecs/array.pyx":640 + * raise ValueError('unexpected end of string') + * + * elif in_quotes: # <<<<<<<<<<<<<< + * # Ignore everything inside the quotes. + * pass + */ + __pyx_t_4 = (__pyx_v_in_quotes != 0); + if (__pyx_t_4) { + goto __pyx_L9; + } + + /* "asyncpg/protocol/codecs/array.pyx":644 + * pass + * + * elif ptr[0] == '{': # <<<<<<<<<<<<<< + * if parse_state not in (APS_START, + * APS_STRIDE_STARTED, + */ + __pyx_t_4 = (((__pyx_v_ptr[0]) == 0x7B) != 0); + if (__pyx_t_4) { + + /* "asyncpg/protocol/codecs/array.pyx":645 + * + * elif ptr[0] == '{': + * if parse_state not in (APS_START, # <<<<<<<<<<<<<< + * APS_STRIDE_STARTED, + * APS_STRIDE_DELIMITED): + */ + switch (__pyx_v_parse_state) { + case __pyx_e_7asyncpg_8protocol_8protocol_APS_START: + + /* "asyncpg/protocol/codecs/array.pyx":646 + * elif ptr[0] == '{': + * if parse_state not in (APS_START, + * APS_STRIDE_STARTED, # <<<<<<<<<<<<<< + * APS_STRIDE_DELIMITED): + * raise _UnexpectedCharacter(array_text, ptr) + */ + case __pyx_e_7asyncpg_8protocol_8protocol_APS_STRIDE_STARTED: + + /* "asyncpg/protocol/codecs/array.pyx":647 + * if parse_state not in (APS_START, + * APS_STRIDE_STARTED, + * APS_STRIDE_DELIMITED): # <<<<<<<<<<<<<< + * raise _UnexpectedCharacter(array_text, ptr) + * + */ + case __pyx_e_7asyncpg_8protocol_8protocol_APS_STRIDE_DELIMITED: + + /* "asyncpg/protocol/codecs/array.pyx":645 + * + * elif ptr[0] == '{': + * if parse_state not in (APS_START, # <<<<<<<<<<<<<< + * APS_STRIDE_STARTED, + * APS_STRIDE_DELIMITED): + */ + __pyx_t_4 = 0; + break; + default: + __pyx_t_4 = 1; + break; + } + __pyx_t_2 = (__pyx_t_4 != 0); + if (__pyx_t_2) { + + /* "asyncpg/protocol/codecs/array.pyx":648 + * APS_STRIDE_STARTED, + * APS_STRIDE_DELIMITED): + * raise _UnexpectedCharacter(array_text, ptr) # <<<<<<<<<<<<<< + * + * parse_state = APS_STRIDE_STARTED + */ + __pyx_t_3 = __pyx_f_7asyncpg_8protocol_8protocol__UnexpectedCharacter(__pyx_v_array_text, __pyx_v_ptr); if (unlikely(!__pyx_t_3)) __PYX_ERR(20, 648, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_Raise(__pyx_t_3, 0, 0, 0); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __PYX_ERR(20, 648, __pyx_L1_error) + + /* "asyncpg/protocol/codecs/array.pyx":645 + * + * elif ptr[0] == '{': + * if parse_state not in (APS_START, # <<<<<<<<<<<<<< + * APS_STRIDE_STARTED, + * APS_STRIDE_DELIMITED): + */ + } + + /* "asyncpg/protocol/codecs/array.pyx":650 + * raise _UnexpectedCharacter(array_text, ptr) + * + * parse_state = APS_STRIDE_STARTED # <<<<<<<<<<<<<< + * if nest_level >= ARRAY_MAXDIM: + * raise ValueError( + */ + __pyx_v_parse_state = __pyx_e_7asyncpg_8protocol_8protocol_APS_STRIDE_STARTED; + + /* "asyncpg/protocol/codecs/array.pyx":651 + * + * parse_state = APS_STRIDE_STARTED + * if nest_level >= ARRAY_MAXDIM: # <<<<<<<<<<<<<< + * raise ValueError( + * 'number of array dimensions ({}) exceed the ' + */ + __pyx_t_2 = ((__pyx_v_nest_level >= 6) != 0); + if (__pyx_t_2) { + + /* "asyncpg/protocol/codecs/array.pyx":654 + * raise ValueError( + * 'number of array dimensions ({}) exceed the ' + * 'maximum expected ({})'.format( # <<<<<<<<<<<<<< + * nest_level, ARRAY_MAXDIM)) + * + */ + __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_kp_u_number_of_array_dimensions_excee, __pyx_n_s_format); if (unlikely(!__pyx_t_6)) __PYX_ERR(20, 654, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + + /* "asyncpg/protocol/codecs/array.pyx":655 + * 'number of array dimensions ({}) exceed the ' + * 'maximum expected ({})'.format( + * nest_level, ARRAY_MAXDIM)) # <<<<<<<<<<<<<< + * + * dims[nest_level] = 0 + */ + __pyx_t_7 = __Pyx_PyInt_From_int(__pyx_v_nest_level); if (unlikely(!__pyx_t_7)) __PYX_ERR(20, 655, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __pyx_t_8 = NULL; + __pyx_t_1 = 0; + if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_6))) { + __pyx_t_8 = PyMethod_GET_SELF(__pyx_t_6); + if (likely(__pyx_t_8)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_6); + __Pyx_INCREF(__pyx_t_8); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_6, function); + __pyx_t_1 = 1; + } + } + #if CYTHON_FAST_PYCALL + if (PyFunction_Check(__pyx_t_6)) { + PyObject *__pyx_temp[3] = {__pyx_t_8, __pyx_t_7, __pyx_int_6}; + __pyx_t_3 = __Pyx_PyFunction_FastCall(__pyx_t_6, __pyx_temp+1-__pyx_t_1, 2+__pyx_t_1); if (unlikely(!__pyx_t_3)) __PYX_ERR(20, 654, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + } else + #endif + #if CYTHON_FAST_PYCCALL + if (__Pyx_PyFastCFunction_Check(__pyx_t_6)) { + PyObject *__pyx_temp[3] = {__pyx_t_8, __pyx_t_7, __pyx_int_6}; + __pyx_t_3 = __Pyx_PyCFunction_FastCall(__pyx_t_6, __pyx_temp+1-__pyx_t_1, 2+__pyx_t_1); if (unlikely(!__pyx_t_3)) __PYX_ERR(20, 654, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + } else + #endif + { + __pyx_t_9 = PyTuple_New(2+__pyx_t_1); if (unlikely(!__pyx_t_9)) __PYX_ERR(20, 654, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_9); + if (__pyx_t_8) { + __Pyx_GIVEREF(__pyx_t_8); PyTuple_SET_ITEM(__pyx_t_9, 0, __pyx_t_8); __pyx_t_8 = NULL; + } + __Pyx_GIVEREF(__pyx_t_7); + PyTuple_SET_ITEM(__pyx_t_9, 0+__pyx_t_1, __pyx_t_7); + __Pyx_INCREF(__pyx_int_6); + __Pyx_GIVEREF(__pyx_int_6); + PyTuple_SET_ITEM(__pyx_t_9, 1+__pyx_t_1, __pyx_int_6); + __pyx_t_7 = 0; + __pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_6, __pyx_t_9, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(20, 654, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + } + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + + /* "asyncpg/protocol/codecs/array.pyx":652 + * parse_state = APS_STRIDE_STARTED + * if nest_level >= ARRAY_MAXDIM: + * raise ValueError( # <<<<<<<<<<<<<< + * 'number of array dimensions ({}) exceed the ' + * 'maximum expected ({})'.format( + */ + __pyx_t_6 = PyTuple_New(1); if (unlikely(!__pyx_t_6)) __PYX_ERR(20, 652, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_GIVEREF(__pyx_t_3); + PyTuple_SET_ITEM(__pyx_t_6, 0, __pyx_t_3); + __pyx_t_3 = 0; + __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_t_6, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(20, 652, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_Raise(__pyx_t_3, 0, 0, 0); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __PYX_ERR(20, 652, __pyx_L1_error) + + /* "asyncpg/protocol/codecs/array.pyx":651 + * + * parse_state = APS_STRIDE_STARTED + * if nest_level >= ARRAY_MAXDIM: # <<<<<<<<<<<<<< + * raise ValueError( + * 'number of array dimensions ({}) exceed the ' + */ + } + + /* "asyncpg/protocol/codecs/array.pyx":657 + * nest_level, ARRAY_MAXDIM)) + * + * dims[nest_level] = 0 # <<<<<<<<<<<<<< + * nest_level += 1 + * if ndims[0] < nest_level: + */ + (__pyx_v_dims[__pyx_v_nest_level]) = 0; + + /* "asyncpg/protocol/codecs/array.pyx":658 + * + * dims[nest_level] = 0 + * nest_level += 1 # <<<<<<<<<<<<<< + * if ndims[0] < nest_level: + * ndims[0] = nest_level + */ + __pyx_v_nest_level = (__pyx_v_nest_level + 1); + + /* "asyncpg/protocol/codecs/array.pyx":659 + * dims[nest_level] = 0 + * nest_level += 1 + * if ndims[0] < nest_level: # <<<<<<<<<<<<<< + * ndims[0] = nest_level + * + */ + __pyx_t_2 = (((__pyx_v_ndims[0]) < __pyx_v_nest_level) != 0); + if (__pyx_t_2) { + + /* "asyncpg/protocol/codecs/array.pyx":660 + * nest_level += 1 + * if ndims[0] < nest_level: + * ndims[0] = nest_level # <<<<<<<<<<<<<< + * + * elif ptr[0] == '}': + */ + (__pyx_v_ndims[0]) = __pyx_v_nest_level; + + /* "asyncpg/protocol/codecs/array.pyx":659 + * dims[nest_level] = 0 + * nest_level += 1 + * if ndims[0] < nest_level: # <<<<<<<<<<<<<< + * ndims[0] = nest_level + * + */ + } + + /* "asyncpg/protocol/codecs/array.pyx":644 + * pass + * + * elif ptr[0] == '{': # <<<<<<<<<<<<<< + * if parse_state not in (APS_START, + * APS_STRIDE_STARTED, + */ + goto __pyx_L9; + } + + /* "asyncpg/protocol/codecs/array.pyx":662 + * ndims[0] = nest_level + * + * elif ptr[0] == '}': # <<<<<<<<<<<<<< + * if (parse_state not in (APS_ELEM_STARTED, APS_STRIDE_DONE) and + * not (nest_level == 1 and + */ + __pyx_t_2 = (((__pyx_v_ptr[0]) == 0x7D) != 0); + if (__pyx_t_2) { + + /* "asyncpg/protocol/codecs/array.pyx":663 + * + * elif ptr[0] == '}': + * if (parse_state not in (APS_ELEM_STARTED, APS_STRIDE_DONE) and # <<<<<<<<<<<<<< + * not (nest_level == 1 and + * parse_state == APS_STRIDE_STARTED)): + */ + switch (__pyx_v_parse_state) { + case __pyx_e_7asyncpg_8protocol_8protocol_APS_ELEM_STARTED: + case __pyx_e_7asyncpg_8protocol_8protocol_APS_STRIDE_DONE: + __pyx_t_4 = 0; + break; + default: + __pyx_t_4 = 1; + break; + } + __pyx_t_5 = (__pyx_t_4 != 0); + if (__pyx_t_5) { + } else { + __pyx_t_2 = __pyx_t_5; + goto __pyx_L22_bool_binop_done; + } + + /* "asyncpg/protocol/codecs/array.pyx":664 + * elif ptr[0] == '}': + * if (parse_state not in (APS_ELEM_STARTED, APS_STRIDE_DONE) and + * not (nest_level == 1 and # <<<<<<<<<<<<<< + * parse_state == APS_STRIDE_STARTED)): + * raise _UnexpectedCharacter(array_text, ptr) + */ + __pyx_t_4 = ((__pyx_v_nest_level == 1) != 0); + if (__pyx_t_4) { + } else { + __pyx_t_5 = __pyx_t_4; + goto __pyx_L24_bool_binop_done; + } + + /* "asyncpg/protocol/codecs/array.pyx":665 + * if (parse_state not in (APS_ELEM_STARTED, APS_STRIDE_DONE) and + * not (nest_level == 1 and + * parse_state == APS_STRIDE_STARTED)): # <<<<<<<<<<<<<< + * raise _UnexpectedCharacter(array_text, ptr) + * + */ + __pyx_t_4 = ((__pyx_v_parse_state == __pyx_e_7asyncpg_8protocol_8protocol_APS_STRIDE_STARTED) != 0); + __pyx_t_5 = __pyx_t_4; + __pyx_L24_bool_binop_done:; + + /* "asyncpg/protocol/codecs/array.pyx":664 + * elif ptr[0] == '}': + * if (parse_state not in (APS_ELEM_STARTED, APS_STRIDE_DONE) and + * not (nest_level == 1 and # <<<<<<<<<<<<<< + * parse_state == APS_STRIDE_STARTED)): + * raise _UnexpectedCharacter(array_text, ptr) + */ + __pyx_t_4 = ((!__pyx_t_5) != 0); + __pyx_t_2 = __pyx_t_4; + __pyx_L22_bool_binop_done:; + + /* "asyncpg/protocol/codecs/array.pyx":663 + * + * elif ptr[0] == '}': + * if (parse_state not in (APS_ELEM_STARTED, APS_STRIDE_DONE) and # <<<<<<<<<<<<<< + * not (nest_level == 1 and + * parse_state == APS_STRIDE_STARTED)): + */ + if (__pyx_t_2) { + + /* "asyncpg/protocol/codecs/array.pyx":666 + * not (nest_level == 1 and + * parse_state == APS_STRIDE_STARTED)): + * raise _UnexpectedCharacter(array_text, ptr) # <<<<<<<<<<<<<< + * + * parse_state = APS_STRIDE_DONE + */ + __pyx_t_3 = __pyx_f_7asyncpg_8protocol_8protocol__UnexpectedCharacter(__pyx_v_array_text, __pyx_v_ptr); if (unlikely(!__pyx_t_3)) __PYX_ERR(20, 666, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_Raise(__pyx_t_3, 0, 0, 0); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __PYX_ERR(20, 666, __pyx_L1_error) + + /* "asyncpg/protocol/codecs/array.pyx":663 + * + * elif ptr[0] == '}': + * if (parse_state not in (APS_ELEM_STARTED, APS_STRIDE_DONE) and # <<<<<<<<<<<<<< + * not (nest_level == 1 and + * parse_state == APS_STRIDE_STARTED)): + */ + } + + /* "asyncpg/protocol/codecs/array.pyx":668 + * raise _UnexpectedCharacter(array_text, ptr) + * + * parse_state = APS_STRIDE_DONE # <<<<<<<<<<<<<< + * + * if nest_level == 0: + */ + __pyx_v_parse_state = __pyx_e_7asyncpg_8protocol_8protocol_APS_STRIDE_DONE; + + /* "asyncpg/protocol/codecs/array.pyx":670 + * parse_state = APS_STRIDE_DONE + * + * if nest_level == 0: # <<<<<<<<<<<<<< + * raise _UnexpectedCharacter(array_text, ptr) + * + */ + __pyx_t_2 = ((__pyx_v_nest_level == 0) != 0); + if (__pyx_t_2) { + + /* "asyncpg/protocol/codecs/array.pyx":671 + * + * if nest_level == 0: + * raise _UnexpectedCharacter(array_text, ptr) # <<<<<<<<<<<<<< + * + * nest_level -= 1 + */ + __pyx_t_3 = __pyx_f_7asyncpg_8protocol_8protocol__UnexpectedCharacter(__pyx_v_array_text, __pyx_v_ptr); if (unlikely(!__pyx_t_3)) __PYX_ERR(20, 671, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_Raise(__pyx_t_3, 0, 0, 0); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __PYX_ERR(20, 671, __pyx_L1_error) + + /* "asyncpg/protocol/codecs/array.pyx":670 + * parse_state = APS_STRIDE_DONE + * + * if nest_level == 0: # <<<<<<<<<<<<<< + * raise _UnexpectedCharacter(array_text, ptr) + * + */ + } + + /* "asyncpg/protocol/codecs/array.pyx":673 + * raise _UnexpectedCharacter(array_text, ptr) + * + * nest_level -= 1 # <<<<<<<<<<<<<< + * + * if (prev_stride_len[nest_level] != 0 and + */ + __pyx_v_nest_level = (__pyx_v_nest_level - 1); + + /* "asyncpg/protocol/codecs/array.pyx":675 + * nest_level -= 1 + * + * if (prev_stride_len[nest_level] != 0 and # <<<<<<<<<<<<<< + * stride_len[nest_level] != prev_stride_len[nest_level]): + * raise ValueError( + */ + __pyx_t_4 = (((__pyx_v_prev_stride_len[__pyx_v_nest_level]) != 0) != 0); + if (__pyx_t_4) { + } else { + __pyx_t_2 = __pyx_t_4; + goto __pyx_L28_bool_binop_done; + } + + /* "asyncpg/protocol/codecs/array.pyx":676 + * + * if (prev_stride_len[nest_level] != 0 and + * stride_len[nest_level] != prev_stride_len[nest_level]): # <<<<<<<<<<<<<< + * raise ValueError( + * 'inconsistent sub-array dimensions' + */ + __pyx_t_4 = (((__pyx_v_stride_len[__pyx_v_nest_level]) != (__pyx_v_prev_stride_len[__pyx_v_nest_level])) != 0); + __pyx_t_2 = __pyx_t_4; + __pyx_L28_bool_binop_done:; + + /* "asyncpg/protocol/codecs/array.pyx":675 + * nest_level -= 1 + * + * if (prev_stride_len[nest_level] != 0 and # <<<<<<<<<<<<<< + * stride_len[nest_level] != prev_stride_len[nest_level]): + * raise ValueError( + */ + if (__pyx_t_2) { + + /* "asyncpg/protocol/codecs/array.pyx":679 + * raise ValueError( + * 'inconsistent sub-array dimensions' + * ' at position {}'.format( # <<<<<<<<<<<<<< + * ptr - array_text + 1)) + * + */ + __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_kp_u_inconsistent_sub_array_dimension, __pyx_n_s_format); if (unlikely(!__pyx_t_6)) __PYX_ERR(20, 679, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + + /* "asyncpg/protocol/codecs/array.pyx":680 + * 'inconsistent sub-array dimensions' + * ' at position {}'.format( + * ptr - array_text + 1)) # <<<<<<<<<<<<<< + * + * prev_stride_len[nest_level] = stride_len[nest_level] + */ + __pyx_t_9 = __Pyx_PyInt_From_ptrdiff_t(((__pyx_v_ptr - __pyx_v_array_text) + 1)); if (unlikely(!__pyx_t_9)) __PYX_ERR(20, 680, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_9); + __pyx_t_7 = NULL; + if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_6))) { + __pyx_t_7 = PyMethod_GET_SELF(__pyx_t_6); + if (likely(__pyx_t_7)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_6); + __Pyx_INCREF(__pyx_t_7); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_6, function); + } + } + if (!__pyx_t_7) { + __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_t_6, __pyx_t_9); if (unlikely(!__pyx_t_3)) __PYX_ERR(20, 679, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + __Pyx_GOTREF(__pyx_t_3); + } else { + #if CYTHON_FAST_PYCALL + if (PyFunction_Check(__pyx_t_6)) { + PyObject *__pyx_temp[2] = {__pyx_t_7, __pyx_t_9}; + __pyx_t_3 = __Pyx_PyFunction_FastCall(__pyx_t_6, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_3)) __PYX_ERR(20, 679, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + } else + #endif + #if CYTHON_FAST_PYCCALL + if (__Pyx_PyFastCFunction_Check(__pyx_t_6)) { + PyObject *__pyx_temp[2] = {__pyx_t_7, __pyx_t_9}; + __pyx_t_3 = __Pyx_PyCFunction_FastCall(__pyx_t_6, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_3)) __PYX_ERR(20, 679, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + } else + #endif + { + __pyx_t_8 = PyTuple_New(1+1); if (unlikely(!__pyx_t_8)) __PYX_ERR(20, 679, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __Pyx_GIVEREF(__pyx_t_7); PyTuple_SET_ITEM(__pyx_t_8, 0, __pyx_t_7); __pyx_t_7 = NULL; + __Pyx_GIVEREF(__pyx_t_9); + PyTuple_SET_ITEM(__pyx_t_8, 0+1, __pyx_t_9); + __pyx_t_9 = 0; + __pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_6, __pyx_t_8, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(20, 679, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + } + } + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + + /* "asyncpg/protocol/codecs/array.pyx":677 + * if (prev_stride_len[nest_level] != 0 and + * stride_len[nest_level] != prev_stride_len[nest_level]): + * raise ValueError( # <<<<<<<<<<<<<< + * 'inconsistent sub-array dimensions' + * ' at position {}'.format( + */ + __pyx_t_6 = PyTuple_New(1); if (unlikely(!__pyx_t_6)) __PYX_ERR(20, 677, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_GIVEREF(__pyx_t_3); + PyTuple_SET_ITEM(__pyx_t_6, 0, __pyx_t_3); + __pyx_t_3 = 0; + __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_t_6, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(20, 677, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_Raise(__pyx_t_3, 0, 0, 0); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __PYX_ERR(20, 677, __pyx_L1_error) + + /* "asyncpg/protocol/codecs/array.pyx":675 + * nest_level -= 1 + * + * if (prev_stride_len[nest_level] != 0 and # <<<<<<<<<<<<<< + * stride_len[nest_level] != prev_stride_len[nest_level]): + * raise ValueError( + */ + } + + /* "asyncpg/protocol/codecs/array.pyx":682 + * ptr - array_text + 1)) + * + * prev_stride_len[nest_level] = stride_len[nest_level] # <<<<<<<<<<<<<< + * stride_len[nest_level] = 1 + * if nest_level == 0: + */ + (__pyx_v_prev_stride_len[__pyx_v_nest_level]) = (__pyx_v_stride_len[__pyx_v_nest_level]); + + /* "asyncpg/protocol/codecs/array.pyx":683 + * + * prev_stride_len[nest_level] = stride_len[nest_level] + * stride_len[nest_level] = 1 # <<<<<<<<<<<<<< + * if nest_level == 0: + * end_of_array = end_of_item = True + */ + (__pyx_v_stride_len[__pyx_v_nest_level]) = 1; + + /* "asyncpg/protocol/codecs/array.pyx":684 + * prev_stride_len[nest_level] = stride_len[nest_level] + * stride_len[nest_level] = 1 + * if nest_level == 0: # <<<<<<<<<<<<<< + * end_of_array = end_of_item = True + * else: + */ + __pyx_t_2 = ((__pyx_v_nest_level == 0) != 0); + if (__pyx_t_2) { + + /* "asyncpg/protocol/codecs/array.pyx":685 + * stride_len[nest_level] = 1 + * if nest_level == 0: + * end_of_array = end_of_item = True # <<<<<<<<<<<<<< + * else: + * dims[nest_level - 1] += 1 + */ + __pyx_v_end_of_array = 1; + __pyx_v_end_of_item = 1; + + /* "asyncpg/protocol/codecs/array.pyx":684 + * prev_stride_len[nest_level] = stride_len[nest_level] + * stride_len[nest_level] = 1 + * if nest_level == 0: # <<<<<<<<<<<<<< + * end_of_array = end_of_item = True + * else: + */ + goto __pyx_L30; + } + + /* "asyncpg/protocol/codecs/array.pyx":687 + * end_of_array = end_of_item = True + * else: + * dims[nest_level - 1] += 1 # <<<<<<<<<<<<<< + * + * elif ptr[0] == typdelim: + */ + /*else*/ { + __pyx_t_10 = (__pyx_v_nest_level - 1); + (__pyx_v_dims[__pyx_t_10]) = ((__pyx_v_dims[__pyx_t_10]) + 1); + } + __pyx_L30:; + + /* "asyncpg/protocol/codecs/array.pyx":662 + * ndims[0] = nest_level + * + * elif ptr[0] == '}': # <<<<<<<<<<<<<< + * if (parse_state not in (APS_ELEM_STARTED, APS_STRIDE_DONE) and + * not (nest_level == 1 and + */ + goto __pyx_L9; + } + + /* "asyncpg/protocol/codecs/array.pyx":689 + * dims[nest_level - 1] += 1 + * + * elif ptr[0] == typdelim: # <<<<<<<<<<<<<< + * if parse_state not in (APS_ELEM_STARTED, APS_STRIDE_DONE): + * raise _UnexpectedCharacter(array_text, ptr) + */ + __pyx_t_2 = (((__pyx_v_ptr[0]) == __pyx_v_typdelim) != 0); + if (__pyx_t_2) { + + /* "asyncpg/protocol/codecs/array.pyx":690 + * + * elif ptr[0] == typdelim: + * if parse_state not in (APS_ELEM_STARTED, APS_STRIDE_DONE): # <<<<<<<<<<<<<< + * raise _UnexpectedCharacter(array_text, ptr) + * + */ + switch (__pyx_v_parse_state) { + case __pyx_e_7asyncpg_8protocol_8protocol_APS_ELEM_STARTED: + case __pyx_e_7asyncpg_8protocol_8protocol_APS_STRIDE_DONE: + __pyx_t_2 = 0; + break; + default: + __pyx_t_2 = 1; + break; + } + __pyx_t_4 = (__pyx_t_2 != 0); + if (__pyx_t_4) { + + /* "asyncpg/protocol/codecs/array.pyx":691 + * elif ptr[0] == typdelim: + * if parse_state not in (APS_ELEM_STARTED, APS_STRIDE_DONE): + * raise _UnexpectedCharacter(array_text, ptr) # <<<<<<<<<<<<<< + * + * if parse_state == APS_STRIDE_DONE: + */ + __pyx_t_3 = __pyx_f_7asyncpg_8protocol_8protocol__UnexpectedCharacter(__pyx_v_array_text, __pyx_v_ptr); if (unlikely(!__pyx_t_3)) __PYX_ERR(20, 691, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_Raise(__pyx_t_3, 0, 0, 0); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __PYX_ERR(20, 691, __pyx_L1_error) + + /* "asyncpg/protocol/codecs/array.pyx":690 + * + * elif ptr[0] == typdelim: + * if parse_state not in (APS_ELEM_STARTED, APS_STRIDE_DONE): # <<<<<<<<<<<<<< + * raise _UnexpectedCharacter(array_text, ptr) + * + */ + } + + /* "asyncpg/protocol/codecs/array.pyx":693 + * raise _UnexpectedCharacter(array_text, ptr) + * + * if parse_state == APS_STRIDE_DONE: # <<<<<<<<<<<<<< + * parse_state = APS_STRIDE_DELIMITED + * else: + */ + __pyx_t_4 = ((__pyx_v_parse_state == __pyx_e_7asyncpg_8protocol_8protocol_APS_STRIDE_DONE) != 0); + if (__pyx_t_4) { + + /* "asyncpg/protocol/codecs/array.pyx":694 + * + * if parse_state == APS_STRIDE_DONE: + * parse_state = APS_STRIDE_DELIMITED # <<<<<<<<<<<<<< + * else: + * parse_state = APS_ELEM_DELIMITED + */ + __pyx_v_parse_state = __pyx_e_7asyncpg_8protocol_8protocol_APS_STRIDE_DELIMITED; + + /* "asyncpg/protocol/codecs/array.pyx":693 + * raise _UnexpectedCharacter(array_text, ptr) + * + * if parse_state == APS_STRIDE_DONE: # <<<<<<<<<<<<<< + * parse_state = APS_STRIDE_DELIMITED + * else: + */ + goto __pyx_L32; + } + + /* "asyncpg/protocol/codecs/array.pyx":696 + * parse_state = APS_STRIDE_DELIMITED + * else: + * parse_state = APS_ELEM_DELIMITED # <<<<<<<<<<<<<< + * end_of_item = True + * stride_len[nest_level - 1] += 1 + */ + /*else*/ { + __pyx_v_parse_state = __pyx_e_7asyncpg_8protocol_8protocol_APS_ELEM_DELIMITED; + } + __pyx_L32:; + + /* "asyncpg/protocol/codecs/array.pyx":697 + * else: + * parse_state = APS_ELEM_DELIMITED + * end_of_item = True # <<<<<<<<<<<<<< + * stride_len[nest_level - 1] += 1 + * + */ + __pyx_v_end_of_item = 1; + + /* "asyncpg/protocol/codecs/array.pyx":698 + * parse_state = APS_ELEM_DELIMITED + * end_of_item = True + * stride_len[nest_level - 1] += 1 # <<<<<<<<<<<<<< + * + * elif not apg_ascii_isspace(ptr[0]): + */ + __pyx_t_10 = (__pyx_v_nest_level - 1); + (__pyx_v_stride_len[__pyx_t_10]) = ((__pyx_v_stride_len[__pyx_t_10]) + 1); + + /* "asyncpg/protocol/codecs/array.pyx":689 + * dims[nest_level - 1] += 1 + * + * elif ptr[0] == typdelim: # <<<<<<<<<<<<<< + * if parse_state not in (APS_ELEM_STARTED, APS_STRIDE_DONE): + * raise _UnexpectedCharacter(array_text, ptr) + */ + goto __pyx_L9; + } + + /* "asyncpg/protocol/codecs/array.pyx":700 + * stride_len[nest_level - 1] += 1 + * + * elif not apg_ascii_isspace(ptr[0]): # <<<<<<<<<<<<<< + * if parse_state not in (APS_STRIDE_STARTED, + * APS_ELEM_STARTED, + */ + __pyx_t_4 = ((!(__pyx_f_7asyncpg_8protocol_8protocol_apg_ascii_isspace((__pyx_v_ptr[0])) != 0)) != 0); + if (__pyx_t_4) { + + /* "asyncpg/protocol/codecs/array.pyx":701 + * + * elif not apg_ascii_isspace(ptr[0]): + * if parse_state not in (APS_STRIDE_STARTED, # <<<<<<<<<<<<<< + * APS_ELEM_STARTED, + * APS_ELEM_DELIMITED): + */ + switch (__pyx_v_parse_state) { + case __pyx_e_7asyncpg_8protocol_8protocol_APS_STRIDE_STARTED: + + /* "asyncpg/protocol/codecs/array.pyx":702 + * elif not apg_ascii_isspace(ptr[0]): + * if parse_state not in (APS_STRIDE_STARTED, + * APS_ELEM_STARTED, # <<<<<<<<<<<<<< + * APS_ELEM_DELIMITED): + * raise _UnexpectedCharacter(array_text, ptr) + */ + case __pyx_e_7asyncpg_8protocol_8protocol_APS_ELEM_STARTED: + + /* "asyncpg/protocol/codecs/array.pyx":703 + * if parse_state not in (APS_STRIDE_STARTED, + * APS_ELEM_STARTED, + * APS_ELEM_DELIMITED): # <<<<<<<<<<<<<< + * raise _UnexpectedCharacter(array_text, ptr) + * + */ + case __pyx_e_7asyncpg_8protocol_8protocol_APS_ELEM_DELIMITED: + + /* "asyncpg/protocol/codecs/array.pyx":701 + * + * elif not apg_ascii_isspace(ptr[0]): + * if parse_state not in (APS_STRIDE_STARTED, # <<<<<<<<<<<<<< + * APS_ELEM_STARTED, + * APS_ELEM_DELIMITED): + */ + __pyx_t_4 = 0; + break; + default: + __pyx_t_4 = 1; + break; + } + __pyx_t_2 = (__pyx_t_4 != 0); + if (__pyx_t_2) { + + /* "asyncpg/protocol/codecs/array.pyx":704 + * APS_ELEM_STARTED, + * APS_ELEM_DELIMITED): + * raise _UnexpectedCharacter(array_text, ptr) # <<<<<<<<<<<<<< + * + * parse_state = APS_ELEM_STARTED + */ + __pyx_t_3 = __pyx_f_7asyncpg_8protocol_8protocol__UnexpectedCharacter(__pyx_v_array_text, __pyx_v_ptr); if (unlikely(!__pyx_t_3)) __PYX_ERR(20, 704, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_Raise(__pyx_t_3, 0, 0, 0); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __PYX_ERR(20, 704, __pyx_L1_error) + + /* "asyncpg/protocol/codecs/array.pyx":701 + * + * elif not apg_ascii_isspace(ptr[0]): + * if parse_state not in (APS_STRIDE_STARTED, # <<<<<<<<<<<<<< + * APS_ELEM_STARTED, + * APS_ELEM_DELIMITED): + */ + } + + /* "asyncpg/protocol/codecs/array.pyx":706 + * raise _UnexpectedCharacter(array_text, ptr) + * + * parse_state = APS_ELEM_STARTED # <<<<<<<<<<<<<< + * array_is_empty = False + * + */ + __pyx_v_parse_state = __pyx_e_7asyncpg_8protocol_8protocol_APS_ELEM_STARTED; + + /* "asyncpg/protocol/codecs/array.pyx":707 + * + * parse_state = APS_ELEM_STARTED + * array_is_empty = False # <<<<<<<<<<<<<< + * + * if not end_of_item: + */ + __pyx_v_array_is_empty = 0; + + /* "asyncpg/protocol/codecs/array.pyx":700 + * stride_len[nest_level - 1] += 1 + * + * elif not apg_ascii_isspace(ptr[0]): # <<<<<<<<<<<<<< + * if parse_state not in (APS_STRIDE_STARTED, + * APS_ELEM_STARTED, + */ + } + __pyx_L9:; + + /* "asyncpg/protocol/codecs/array.pyx":709 + * array_is_empty = False + * + * if not end_of_item: # <<<<<<<<<<<<<< + * ptr += 1 + * + */ + __pyx_t_2 = ((!(__pyx_v_end_of_item != 0)) != 0); + if (__pyx_t_2) { + + /* "asyncpg/protocol/codecs/array.pyx":710 + * + * if not end_of_item: + * ptr += 1 # <<<<<<<<<<<<<< + * + * if not array_is_empty: + */ + __pyx_v_ptr = (__pyx_v_ptr + 1); + + /* "asyncpg/protocol/codecs/array.pyx":709 + * array_is_empty = False + * + * if not end_of_item: # <<<<<<<<<<<<<< + * ptr += 1 + * + */ + } + } + + /* "asyncpg/protocol/codecs/array.pyx":712 + * ptr += 1 + * + * if not array_is_empty: # <<<<<<<<<<<<<< + * dims[ndims[0] - 1] += 1 + * + */ + __pyx_t_2 = ((!(__pyx_v_array_is_empty != 0)) != 0); + if (__pyx_t_2) { + + /* "asyncpg/protocol/codecs/array.pyx":713 + * + * if not array_is_empty: + * dims[ndims[0] - 1] += 1 # <<<<<<<<<<<<<< + * + * ptr += 1 + */ + __pyx_t_10 = ((__pyx_v_ndims[0]) - 1); + (__pyx_v_dims[__pyx_t_10]) = ((__pyx_v_dims[__pyx_t_10]) + 1); + + /* "asyncpg/protocol/codecs/array.pyx":712 + * ptr += 1 + * + * if not array_is_empty: # <<<<<<<<<<<<<< + * dims[ndims[0] - 1] += 1 + * + */ + } + + /* "asyncpg/protocol/codecs/array.pyx":715 + * dims[ndims[0] - 1] += 1 + * + * ptr += 1 # <<<<<<<<<<<<<< + * + * # only whitespace is allowed after the closing brace + */ + __pyx_v_ptr = (__pyx_v_ptr + 1); + } + + /* "asyncpg/protocol/codecs/array.pyx":718 + * + * # only whitespace is allowed after the closing brace + * while ptr[0] != '\0': # <<<<<<<<<<<<<< + * if not apg_ascii_isspace(ptr[0]): + * raise _UnexpectedCharacter(array_text, ptr) + */ + while (1) { + __pyx_t_2 = (((__pyx_v_ptr[0]) != 0) != 0); + if (!__pyx_t_2) break; + + /* "asyncpg/protocol/codecs/array.pyx":719 + * # only whitespace is allowed after the closing brace + * while ptr[0] != '\0': + * if not apg_ascii_isspace(ptr[0]): # <<<<<<<<<<<<<< + * raise _UnexpectedCharacter(array_text, ptr) + * + */ + __pyx_t_2 = ((!(__pyx_f_7asyncpg_8protocol_8protocol_apg_ascii_isspace((__pyx_v_ptr[0])) != 0)) != 0); + if (__pyx_t_2) { + + /* "asyncpg/protocol/codecs/array.pyx":720 + * while ptr[0] != '\0': + * if not apg_ascii_isspace(ptr[0]): + * raise _UnexpectedCharacter(array_text, ptr) # <<<<<<<<<<<<<< + * + * ptr += 1 + */ + __pyx_t_3 = __pyx_f_7asyncpg_8protocol_8protocol__UnexpectedCharacter(__pyx_v_array_text, __pyx_v_ptr); if (unlikely(!__pyx_t_3)) __PYX_ERR(20, 720, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_Raise(__pyx_t_3, 0, 0, 0); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __PYX_ERR(20, 720, __pyx_L1_error) + + /* "asyncpg/protocol/codecs/array.pyx":719 + * # only whitespace is allowed after the closing brace + * while ptr[0] != '\0': + * if not apg_ascii_isspace(ptr[0]): # <<<<<<<<<<<<<< + * raise _UnexpectedCharacter(array_text, ptr) + * + */ + } + + /* "asyncpg/protocol/codecs/array.pyx":722 + * raise _UnexpectedCharacter(array_text, ptr) + * + * ptr += 1 # <<<<<<<<<<<<<< + * + * if array_is_empty: + */ + __pyx_v_ptr = (__pyx_v_ptr + 1); + } + + /* "asyncpg/protocol/codecs/array.pyx":724 + * ptr += 1 + * + * if array_is_empty: # <<<<<<<<<<<<<< + * ndims[0] = 0 + * + */ + __pyx_t_2 = (__pyx_v_array_is_empty != 0); + if (__pyx_t_2) { + + /* "asyncpg/protocol/codecs/array.pyx":725 + * + * if array_is_empty: + * ndims[0] = 0 # <<<<<<<<<<<<<< + * + * + */ + (__pyx_v_ndims[0]) = 0; + + /* "asyncpg/protocol/codecs/array.pyx":724 + * ptr += 1 + * + * if array_is_empty: # <<<<<<<<<<<<<< + * ndims[0] = 0 + * + */ + } + + /* "asyncpg/protocol/codecs/array.pyx":588 + * + * + * cdef _infer_array_dims(const Py_UCS4 *array_text, # <<<<<<<<<<<<<< + * Py_UCS4 typdelim, + * int32_t *dims, + */ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_6); + __Pyx_XDECREF(__pyx_t_7); + __Pyx_XDECREF(__pyx_t_8); + __Pyx_XDECREF(__pyx_t_9); + __Pyx_AddTraceback("asyncpg.protocol.protocol._infer_array_dims", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "asyncpg/protocol/codecs/array.pyx":728 + * + * + * cdef int4_encode_ex(ConnectionSettings settings, WriteBuffer buf, object obj, # <<<<<<<<<<<<<< + * const void *arg): + * return int4_encode(settings, buf, obj) + */ + +static PyObject *__pyx_f_7asyncpg_8protocol_8protocol_int4_encode_ex(struct __pyx_obj_7asyncpg_8protocol_8protocol_ConnectionSettings *__pyx_v_settings, struct __pyx_obj_7asyncpg_8protocol_8protocol_WriteBuffer *__pyx_v_buf, PyObject *__pyx_v_obj, CYTHON_UNUSED void const *__pyx_v_arg) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + __Pyx_RefNannySetupContext("int4_encode_ex", 0); + + /* "asyncpg/protocol/codecs/array.pyx":730 + * cdef int4_encode_ex(ConnectionSettings settings, WriteBuffer buf, object obj, + * const void *arg): + * return int4_encode(settings, buf, obj) # <<<<<<<<<<<<<< + * + * + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __pyx_f_7asyncpg_8protocol_8protocol_int4_encode(__pyx_v_settings, __pyx_v_buf, __pyx_v_obj); if (unlikely(!__pyx_t_1)) __PYX_ERR(20, 730, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "asyncpg/protocol/codecs/array.pyx":728 + * + * + * cdef int4_encode_ex(ConnectionSettings settings, WriteBuffer buf, object obj, # <<<<<<<<<<<<<< + * const void *arg): + * return int4_encode(settings, buf, obj) + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("asyncpg.protocol.protocol.int4_encode_ex", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "asyncpg/protocol/codecs/array.pyx":733 + * + * + * cdef int4_decode_ex(ConnectionSettings settings, FastReadBuffer buf, # <<<<<<<<<<<<<< + * const void *arg): + * return int4_decode(settings, buf) + */ + +static PyObject *__pyx_f_7asyncpg_8protocol_8protocol_int4_decode_ex(struct __pyx_obj_7asyncpg_8protocol_8protocol_ConnectionSettings *__pyx_v_settings, struct __pyx_obj_7asyncpg_8protocol_8protocol_FastReadBuffer *__pyx_v_buf, CYTHON_UNUSED void const *__pyx_v_arg) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + __Pyx_RefNannySetupContext("int4_decode_ex", 0); + + /* "asyncpg/protocol/codecs/array.pyx":735 + * cdef int4_decode_ex(ConnectionSettings settings, FastReadBuffer buf, + * const void *arg): + * return int4_decode(settings, buf) # <<<<<<<<<<<<<< + * + * + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __pyx_f_7asyncpg_8protocol_8protocol_int4_decode(__pyx_v_settings, __pyx_v_buf); if (unlikely(!__pyx_t_1)) __PYX_ERR(20, 735, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "asyncpg/protocol/codecs/array.pyx":733 + * + * + * cdef int4_decode_ex(ConnectionSettings settings, FastReadBuffer buf, # <<<<<<<<<<<<<< + * const void *arg): + * return int4_decode(settings, buf) + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("asyncpg.protocol.protocol.int4_decode_ex", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "asyncpg/protocol/codecs/array.pyx":738 + * + * + * cdef arrayoid_encode(ConnectionSettings settings, WriteBuffer buf, items): # <<<<<<<<<<<<<< + * array_encode(settings, buf, items, OIDOID, + * &int4_encode_ex, NULL) + */ + +static PyObject *__pyx_f_7asyncpg_8protocol_8protocol_arrayoid_encode(struct __pyx_obj_7asyncpg_8protocol_8protocol_ConnectionSettings *__pyx_v_settings, struct __pyx_obj_7asyncpg_8protocol_8protocol_WriteBuffer *__pyx_v_buf, PyObject *__pyx_v_items) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + __Pyx_RefNannySetupContext("arrayoid_encode", 0); + + /* "asyncpg/protocol/codecs/array.pyx":739 + * + * cdef arrayoid_encode(ConnectionSettings settings, WriteBuffer buf, items): + * array_encode(settings, buf, items, OIDOID, # <<<<<<<<<<<<<< + * &int4_encode_ex, NULL) + * + */ + __pyx_t_1 = __pyx_f_7asyncpg_8protocol_8protocol_array_encode(__pyx_v_settings, __pyx_v_buf, __pyx_v_items, 26, ((__pyx_t_7asyncpg_8protocol_8protocol_encode_func_ex)(&__pyx_f_7asyncpg_8protocol_8protocol_int4_encode_ex)), NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(20, 739, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "asyncpg/protocol/codecs/array.pyx":738 + * + * + * cdef arrayoid_encode(ConnectionSettings settings, WriteBuffer buf, items): # <<<<<<<<<<<<<< + * array_encode(settings, buf, items, OIDOID, + * &int4_encode_ex, NULL) + */ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("asyncpg.protocol.protocol.arrayoid_encode", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "asyncpg/protocol/codecs/array.pyx":743 + * + * + * cdef arrayoid_decode(ConnectionSettings settings, FastReadBuffer buf): # <<<<<<<<<<<<<< + * return array_decode(settings, buf, &int4_decode_ex, NULL) + * + */ + +static PyObject *__pyx_f_7asyncpg_8protocol_8protocol_arrayoid_decode(struct __pyx_obj_7asyncpg_8protocol_8protocol_ConnectionSettings *__pyx_v_settings, struct __pyx_obj_7asyncpg_8protocol_8protocol_FastReadBuffer *__pyx_v_buf) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + __Pyx_RefNannySetupContext("arrayoid_decode", 0); + + /* "asyncpg/protocol/codecs/array.pyx":744 + * + * cdef arrayoid_decode(ConnectionSettings settings, FastReadBuffer buf): + * return array_decode(settings, buf, &int4_decode_ex, NULL) # <<<<<<<<<<<<<< + * + * + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __pyx_f_7asyncpg_8protocol_8protocol_array_decode(__pyx_v_settings, __pyx_v_buf, ((__pyx_t_7asyncpg_8protocol_8protocol_decode_func_ex)(&__pyx_f_7asyncpg_8protocol_8protocol_int4_decode_ex)), NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(20, 744, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "asyncpg/protocol/codecs/array.pyx":743 + * + * + * cdef arrayoid_decode(ConnectionSettings settings, FastReadBuffer buf): # <<<<<<<<<<<<<< + * return array_decode(settings, buf, &int4_decode_ex, NULL) + * + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("asyncpg.protocol.protocol.arrayoid_decode", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "asyncpg/protocol/codecs/array.pyx":747 + * + * + * cdef text_encode_ex(ConnectionSettings settings, WriteBuffer buf, object obj, # <<<<<<<<<<<<<< + * const void *arg): + * return text_encode(settings, buf, obj) + */ + +static PyObject *__pyx_f_7asyncpg_8protocol_8protocol_text_encode_ex(struct __pyx_obj_7asyncpg_8protocol_8protocol_ConnectionSettings *__pyx_v_settings, struct __pyx_obj_7asyncpg_8protocol_8protocol_WriteBuffer *__pyx_v_buf, PyObject *__pyx_v_obj, CYTHON_UNUSED void const *__pyx_v_arg) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + __Pyx_RefNannySetupContext("text_encode_ex", 0); + + /* "asyncpg/protocol/codecs/array.pyx":749 + * cdef text_encode_ex(ConnectionSettings settings, WriteBuffer buf, object obj, + * const void *arg): + * return text_encode(settings, buf, obj) # <<<<<<<<<<<<<< + * + * + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __pyx_f_7asyncpg_8protocol_8protocol_text_encode(__pyx_v_settings, __pyx_v_buf, __pyx_v_obj); if (unlikely(!__pyx_t_1)) __PYX_ERR(20, 749, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "asyncpg/protocol/codecs/array.pyx":747 + * + * + * cdef text_encode_ex(ConnectionSettings settings, WriteBuffer buf, object obj, # <<<<<<<<<<<<<< + * const void *arg): + * return text_encode(settings, buf, obj) + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("asyncpg.protocol.protocol.text_encode_ex", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "asyncpg/protocol/codecs/array.pyx":752 + * + * + * cdef text_decode_ex(ConnectionSettings settings, FastReadBuffer buf, # <<<<<<<<<<<<<< + * const void *arg): + * return text_decode(settings, buf) + */ + +static PyObject *__pyx_f_7asyncpg_8protocol_8protocol_text_decode_ex(struct __pyx_obj_7asyncpg_8protocol_8protocol_ConnectionSettings *__pyx_v_settings, struct __pyx_obj_7asyncpg_8protocol_8protocol_FastReadBuffer *__pyx_v_buf, CYTHON_UNUSED void const *__pyx_v_arg) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + __Pyx_RefNannySetupContext("text_decode_ex", 0); + + /* "asyncpg/protocol/codecs/array.pyx":754 + * cdef text_decode_ex(ConnectionSettings settings, FastReadBuffer buf, + * const void *arg): + * return text_decode(settings, buf) # <<<<<<<<<<<<<< + * + * + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __pyx_f_7asyncpg_8protocol_8protocol_text_decode(__pyx_v_settings, __pyx_v_buf); if (unlikely(!__pyx_t_1)) __PYX_ERR(20, 754, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "asyncpg/protocol/codecs/array.pyx":752 + * + * + * cdef text_decode_ex(ConnectionSettings settings, FastReadBuffer buf, # <<<<<<<<<<<<<< + * const void *arg): + * return text_decode(settings, buf) + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("asyncpg.protocol.protocol.text_decode_ex", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "asyncpg/protocol/codecs/array.pyx":757 + * + * + * cdef arraytext_encode(ConnectionSettings settings, WriteBuffer buf, items): # <<<<<<<<<<<<<< + * array_encode(settings, buf, items, TEXTOID, + * &text_encode_ex, NULL) + */ + +static PyObject *__pyx_f_7asyncpg_8protocol_8protocol_arraytext_encode(struct __pyx_obj_7asyncpg_8protocol_8protocol_ConnectionSettings *__pyx_v_settings, struct __pyx_obj_7asyncpg_8protocol_8protocol_WriteBuffer *__pyx_v_buf, PyObject *__pyx_v_items) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + __Pyx_RefNannySetupContext("arraytext_encode", 0); + + /* "asyncpg/protocol/codecs/array.pyx":758 + * + * cdef arraytext_encode(ConnectionSettings settings, WriteBuffer buf, items): + * array_encode(settings, buf, items, TEXTOID, # <<<<<<<<<<<<<< + * &text_encode_ex, NULL) + * + */ + __pyx_t_1 = __pyx_f_7asyncpg_8protocol_8protocol_array_encode(__pyx_v_settings, __pyx_v_buf, __pyx_v_items, 25, ((__pyx_t_7asyncpg_8protocol_8protocol_encode_func_ex)(&__pyx_f_7asyncpg_8protocol_8protocol_text_encode_ex)), NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(20, 758, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "asyncpg/protocol/codecs/array.pyx":757 + * + * + * cdef arraytext_encode(ConnectionSettings settings, WriteBuffer buf, items): # <<<<<<<<<<<<<< + * array_encode(settings, buf, items, TEXTOID, + * &text_encode_ex, NULL) + */ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("asyncpg.protocol.protocol.arraytext_encode", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "asyncpg/protocol/codecs/array.pyx":762 + * + * + * cdef arraytext_decode(ConnectionSettings settings, FastReadBuffer buf): # <<<<<<<<<<<<<< + * return array_decode(settings, buf, &text_decode_ex, NULL) + * + */ + +static PyObject *__pyx_f_7asyncpg_8protocol_8protocol_arraytext_decode(struct __pyx_obj_7asyncpg_8protocol_8protocol_ConnectionSettings *__pyx_v_settings, struct __pyx_obj_7asyncpg_8protocol_8protocol_FastReadBuffer *__pyx_v_buf) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + __Pyx_RefNannySetupContext("arraytext_decode", 0); + + /* "asyncpg/protocol/codecs/array.pyx":763 + * + * cdef arraytext_decode(ConnectionSettings settings, FastReadBuffer buf): + * return array_decode(settings, buf, &text_decode_ex, NULL) # <<<<<<<<<<<<<< + * + * + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __pyx_f_7asyncpg_8protocol_8protocol_array_decode(__pyx_v_settings, __pyx_v_buf, ((__pyx_t_7asyncpg_8protocol_8protocol_decode_func_ex)(&__pyx_f_7asyncpg_8protocol_8protocol_text_decode_ex)), NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(20, 763, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "asyncpg/protocol/codecs/array.pyx":762 + * + * + * cdef arraytext_decode(ConnectionSettings settings, FastReadBuffer buf): # <<<<<<<<<<<<<< + * return array_decode(settings, buf, &text_decode_ex, NULL) + * + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("asyncpg.protocol.protocol.arraytext_decode", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "asyncpg/protocol/codecs/array.pyx":766 + * + * + * cdef anyarray_decode(ConnectionSettings settings, FastReadBuffer buf): # <<<<<<<<<<<<<< + * return array_decode(settings, buf, NULL, NULL) + * + */ + +static PyObject *__pyx_f_7asyncpg_8protocol_8protocol_anyarray_decode(struct __pyx_obj_7asyncpg_8protocol_8protocol_ConnectionSettings *__pyx_v_settings, struct __pyx_obj_7asyncpg_8protocol_8protocol_FastReadBuffer *__pyx_v_buf) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + __Pyx_RefNannySetupContext("anyarray_decode", 0); + + /* "asyncpg/protocol/codecs/array.pyx":767 + * + * cdef anyarray_decode(ConnectionSettings settings, FastReadBuffer buf): + * return array_decode(settings, buf, NULL, NULL) # <<<<<<<<<<<<<< + * + * + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __pyx_f_7asyncpg_8protocol_8protocol_array_decode(__pyx_v_settings, __pyx_v_buf, NULL, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(20, 767, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "asyncpg/protocol/codecs/array.pyx":766 + * + * + * cdef anyarray_decode(ConnectionSettings settings, FastReadBuffer buf): # <<<<<<<<<<<<<< + * return array_decode(settings, buf, NULL, NULL) + * + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("asyncpg.protocol.protocol.anyarray_decode", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "asyncpg/protocol/codecs/array.pyx":770 + * + * + * cdef init_array_codecs(): # <<<<<<<<<<<<<< + * register_core_codec(ANYARRAYOID, + * NULL, + */ + +static PyObject *__pyx_f_7asyncpg_8protocol_8protocol_init_array_codecs(void) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + __Pyx_RefNannySetupContext("init_array_codecs", 0); + + /* "asyncpg/protocol/codecs/array.pyx":771 + * + * cdef init_array_codecs(): + * register_core_codec(ANYARRAYOID, # <<<<<<<<<<<<<< + * NULL, + * &anyarray_decode, + */ + __pyx_t_1 = __pyx_f_7asyncpg_8protocol_8protocol_register_core_codec(0x8E5, NULL, ((__pyx_t_7asyncpg_8protocol_8protocol_decode_func)(&__pyx_f_7asyncpg_8protocol_8protocol_anyarray_decode)), __pyx_e_7asyncpg_8protocol_8protocol_PG_FORMAT_BINARY); if (unlikely(!__pyx_t_1)) __PYX_ERR(20, 771, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "asyncpg/protocol/codecs/array.pyx":779 + * # to make type introspection query work + * # + * register_core_codec(_OIDOID, # <<<<<<<<<<<<<< + * &arrayoid_encode, + * &arrayoid_decode, + */ + __pyx_t_1 = __pyx_f_7asyncpg_8protocol_8protocol_register_core_codec(0x404, ((__pyx_t_7asyncpg_8protocol_8protocol_encode_func)(&__pyx_f_7asyncpg_8protocol_8protocol_arrayoid_encode)), ((__pyx_t_7asyncpg_8protocol_8protocol_decode_func)(&__pyx_f_7asyncpg_8protocol_8protocol_arrayoid_decode)), __pyx_e_7asyncpg_8protocol_8protocol_PG_FORMAT_BINARY); if (unlikely(!__pyx_t_1)) __PYX_ERR(20, 779, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "asyncpg/protocol/codecs/array.pyx":784 + * PG_FORMAT_BINARY) + * + * register_core_codec(_TEXTOID, # <<<<<<<<<<<<<< + * &arraytext_encode, + * &arraytext_decode, + */ + __pyx_t_1 = __pyx_f_7asyncpg_8protocol_8protocol_register_core_codec(0x3F1, ((__pyx_t_7asyncpg_8protocol_8protocol_encode_func)(&__pyx_f_7asyncpg_8protocol_8protocol_arraytext_encode)), ((__pyx_t_7asyncpg_8protocol_8protocol_decode_func)(&__pyx_f_7asyncpg_8protocol_8protocol_arraytext_decode)), __pyx_e_7asyncpg_8protocol_8protocol_PG_FORMAT_BINARY); if (unlikely(!__pyx_t_1)) __PYX_ERR(20, 784, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "asyncpg/protocol/codecs/array.pyx":770 + * + * + * cdef init_array_codecs(): # <<<<<<<<<<<<<< + * register_core_codec(ANYARRAYOID, + * NULL, + */ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("asyncpg.protocol.protocol.init_array_codecs", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "asyncpg/protocol/codecs/range.pyx":24 + * + * + * cdef inline bint _range_has_lbound(uint8_t flags): # <<<<<<<<<<<<<< + * return not (flags & (RANGE_EMPTY | RANGE_LB_INF)) + * + */ + +static CYTHON_INLINE int __pyx_f_7asyncpg_8protocol_8protocol__range_has_lbound(uint8_t __pyx_v_flags) { + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("_range_has_lbound", 0); + + /* "asyncpg/protocol/codecs/range.pyx":25 + * + * cdef inline bint _range_has_lbound(uint8_t flags): + * return not (flags & (RANGE_EMPTY | RANGE_LB_INF)) # <<<<<<<<<<<<<< + * + * + */ + __pyx_r = (!((__pyx_v_flags & 9) != 0)); + goto __pyx_L0; + + /* "asyncpg/protocol/codecs/range.pyx":24 + * + * + * cdef inline bint _range_has_lbound(uint8_t flags): # <<<<<<<<<<<<<< + * return not (flags & (RANGE_EMPTY | RANGE_LB_INF)) + * + */ + + /* function exit code */ + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "asyncpg/protocol/codecs/range.pyx":28 + * + * + * cdef inline bint _range_has_ubound(uint8_t flags): # <<<<<<<<<<<<<< + * return not (flags & (RANGE_EMPTY | RANGE_UB_INF)) + * + */ + +static CYTHON_INLINE int __pyx_f_7asyncpg_8protocol_8protocol__range_has_ubound(uint8_t __pyx_v_flags) { + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("_range_has_ubound", 0); + + /* "asyncpg/protocol/codecs/range.pyx":29 + * + * cdef inline bint _range_has_ubound(uint8_t flags): + * return not (flags & (RANGE_EMPTY | RANGE_UB_INF)) # <<<<<<<<<<<<<< + * + * + */ + __pyx_r = (!((__pyx_v_flags & 17) != 0)); + goto __pyx_L0; + + /* "asyncpg/protocol/codecs/range.pyx":28 + * + * + * cdef inline bint _range_has_ubound(uint8_t flags): # <<<<<<<<<<<<<< + * return not (flags & (RANGE_EMPTY | RANGE_UB_INF)) + * + */ + + /* function exit code */ + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "asyncpg/protocol/codecs/range.pyx":32 + * + * + * cdef inline _RangeArgumentType _range_type(object obj): # <<<<<<<<<<<<<< + * if cpython.PyTuple_Check(obj) or cpython.PyList_Check(obj): + * return _RANGE_ARGUMENT_TUPLE + */ + +static CYTHON_INLINE enum __pyx_t_7asyncpg_8protocol_8protocol__RangeArgumentType __pyx_f_7asyncpg_8protocol_8protocol__range_type(PyObject *__pyx_v_obj) { + enum __pyx_t_7asyncpg_8protocol_8protocol__RangeArgumentType __pyx_r; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + int __pyx_t_2; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + __Pyx_RefNannySetupContext("_range_type", 0); + + /* "asyncpg/protocol/codecs/range.pyx":33 + * + * cdef inline _RangeArgumentType _range_type(object obj): + * if cpython.PyTuple_Check(obj) or cpython.PyList_Check(obj): # <<<<<<<<<<<<<< + * return _RANGE_ARGUMENT_TUPLE + * elif isinstance(obj, apg_types.Range): + */ + __pyx_t_2 = (PyTuple_Check(__pyx_v_obj) != 0); + if (!__pyx_t_2) { + } else { + __pyx_t_1 = __pyx_t_2; + goto __pyx_L4_bool_binop_done; + } + __pyx_t_2 = (PyList_Check(__pyx_v_obj) != 0); + __pyx_t_1 = __pyx_t_2; + __pyx_L4_bool_binop_done:; + if (__pyx_t_1) { + + /* "asyncpg/protocol/codecs/range.pyx":34 + * cdef inline _RangeArgumentType _range_type(object obj): + * if cpython.PyTuple_Check(obj) or cpython.PyList_Check(obj): + * return _RANGE_ARGUMENT_TUPLE # <<<<<<<<<<<<<< + * elif isinstance(obj, apg_types.Range): + * return _RANGE_ARGUMENT_RANGE + */ + __pyx_r = __pyx_e_7asyncpg_8protocol_8protocol__RANGE_ARGUMENT_TUPLE; + goto __pyx_L0; + + /* "asyncpg/protocol/codecs/range.pyx":33 + * + * cdef inline _RangeArgumentType _range_type(object obj): + * if cpython.PyTuple_Check(obj) or cpython.PyList_Check(obj): # <<<<<<<<<<<<<< + * return _RANGE_ARGUMENT_TUPLE + * elif isinstance(obj, apg_types.Range): + */ + } + + /* "asyncpg/protocol/codecs/range.pyx":35 + * if cpython.PyTuple_Check(obj) or cpython.PyList_Check(obj): + * return _RANGE_ARGUMENT_TUPLE + * elif isinstance(obj, apg_types.Range): # <<<<<<<<<<<<<< + * return _RANGE_ARGUMENT_RANGE + * else: + */ + __pyx_t_3 = __Pyx_GetModuleGlobalName(__pyx_n_s_apg_types); if (unlikely(!__pyx_t_3)) __PYX_ERR(21, 35, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_Range); if (unlikely(!__pyx_t_4)) __PYX_ERR(21, 35, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_1 = PyObject_IsInstance(__pyx_v_obj, __pyx_t_4); if (unlikely(__pyx_t_1 == -1)) __PYX_ERR(21, 35, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_2 = (__pyx_t_1 != 0); + if (__pyx_t_2) { + + /* "asyncpg/protocol/codecs/range.pyx":36 + * return _RANGE_ARGUMENT_TUPLE + * elif isinstance(obj, apg_types.Range): + * return _RANGE_ARGUMENT_RANGE # <<<<<<<<<<<<<< + * else: + * return _RANGE_ARGUMENT_INVALID + */ + __pyx_r = __pyx_e_7asyncpg_8protocol_8protocol__RANGE_ARGUMENT_RANGE; + goto __pyx_L0; + + /* "asyncpg/protocol/codecs/range.pyx":35 + * if cpython.PyTuple_Check(obj) or cpython.PyList_Check(obj): + * return _RANGE_ARGUMENT_TUPLE + * elif isinstance(obj, apg_types.Range): # <<<<<<<<<<<<<< + * return _RANGE_ARGUMENT_RANGE + * else: + */ + } + + /* "asyncpg/protocol/codecs/range.pyx":38 + * return _RANGE_ARGUMENT_RANGE + * else: + * return _RANGE_ARGUMENT_INVALID # <<<<<<<<<<<<<< + * + * + */ + /*else*/ { + __pyx_r = __pyx_e_7asyncpg_8protocol_8protocol__RANGE_ARGUMENT_INVALID; + goto __pyx_L0; + } + + /* "asyncpg/protocol/codecs/range.pyx":32 + * + * + * cdef inline _RangeArgumentType _range_type(object obj): # <<<<<<<<<<<<<< + * if cpython.PyTuple_Check(obj) or cpython.PyList_Check(obj): + * return _RANGE_ARGUMENT_TUPLE + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_WriteUnraisable("asyncpg.protocol.protocol._range_type", __pyx_clineno, __pyx_lineno, __pyx_filename, 0, 0); + __pyx_r = (enum __pyx_t_7asyncpg_8protocol_8protocol__RangeArgumentType) 0; + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "asyncpg/protocol/codecs/range.pyx":41 + * + * + * cdef range_encode(ConnectionSettings settings, WriteBuffer buf, # <<<<<<<<<<<<<< + * object obj, uint32_t elem_oid, + * encode_func_ex encoder, const void *encoder_arg): + */ + +static PyObject *__pyx_f_7asyncpg_8protocol_8protocol_range_encode(struct __pyx_obj_7asyncpg_8protocol_8protocol_ConnectionSettings *__pyx_v_settings, struct __pyx_obj_7asyncpg_8protocol_8protocol_WriteBuffer *__pyx_v_buf, PyObject *__pyx_v_obj, CYTHON_UNUSED uint32_t __pyx_v_elem_oid, __pyx_t_7asyncpg_8protocol_8protocol_encode_func_ex __pyx_v_encoder, void const *__pyx_v_encoder_arg) { + Py_ssize_t __pyx_v_obj_len; + uint8_t __pyx_v_flags; + PyObject *__pyx_v_lower = 0; + PyObject *__pyx_v_upper = 0; + struct __pyx_obj_7asyncpg_8protocol_8protocol_WriteBuffer *__pyx_v_bounds_data = 0; + enum __pyx_t_7asyncpg_8protocol_8protocol__RangeArgumentType __pyx_v_arg_type; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + Py_ssize_t __pyx_t_5; + int __pyx_t_6; + int __pyx_t_7; + PyObject *__pyx_t_8 = NULL; + int32_t __pyx_t_9; + __Pyx_RefNannySetupContext("range_encode", 0); + + /* "asyncpg/protocol/codecs/range.pyx":46 + * cdef: + * ssize_t obj_len + * uint8_t flags = 0 # <<<<<<<<<<<<<< + * object lower = None + * object upper = None + */ + __pyx_v_flags = 0; + + /* "asyncpg/protocol/codecs/range.pyx":47 + * ssize_t obj_len + * uint8_t flags = 0 + * object lower = None # <<<<<<<<<<<<<< + * object upper = None + * WriteBuffer bounds_data = WriteBuffer.new() + */ + __Pyx_INCREF(Py_None); + __pyx_v_lower = Py_None; + + /* "asyncpg/protocol/codecs/range.pyx":48 + * uint8_t flags = 0 + * object lower = None + * object upper = None # <<<<<<<<<<<<<< + * WriteBuffer bounds_data = WriteBuffer.new() + * _RangeArgumentType arg_type = _range_type(obj) + */ + __Pyx_INCREF(Py_None); + __pyx_v_upper = Py_None; + + /* "asyncpg/protocol/codecs/range.pyx":49 + * object lower = None + * object upper = None + * WriteBuffer bounds_data = WriteBuffer.new() # <<<<<<<<<<<<<< + * _RangeArgumentType arg_type = _range_type(obj) + * + */ + __pyx_t_1 = ((PyObject *)__pyx_f_7asyncpg_8protocol_8protocol_11WriteBuffer_new()); if (unlikely(!__pyx_t_1)) __PYX_ERR(21, 49, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_v_bounds_data = ((struct __pyx_obj_7asyncpg_8protocol_8protocol_WriteBuffer *)__pyx_t_1); + __pyx_t_1 = 0; + + /* "asyncpg/protocol/codecs/range.pyx":50 + * object upper = None + * WriteBuffer bounds_data = WriteBuffer.new() + * _RangeArgumentType arg_type = _range_type(obj) # <<<<<<<<<<<<<< + * + * if arg_type == _RANGE_ARGUMENT_INVALID: + */ + __pyx_v_arg_type = __pyx_f_7asyncpg_8protocol_8protocol__range_type(__pyx_v_obj); + + /* "asyncpg/protocol/codecs/range.pyx":52 + * _RangeArgumentType arg_type = _range_type(obj) + * + * if arg_type == _RANGE_ARGUMENT_INVALID: # <<<<<<<<<<<<<< + * raise TypeError( + * 'list, tuple or Range object expected (got type {})'.format( + */ + switch (__pyx_v_arg_type) { + case __pyx_e_7asyncpg_8protocol_8protocol__RANGE_ARGUMENT_INVALID: + + /* "asyncpg/protocol/codecs/range.pyx":54 + * if arg_type == _RANGE_ARGUMENT_INVALID: + * raise TypeError( + * 'list, tuple or Range object expected (got type {})'.format( # <<<<<<<<<<<<<< + * type(obj))) + * + */ + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_kp_u_list_tuple_or_Range_object_expec, __pyx_n_s_format); if (unlikely(!__pyx_t_2)) __PYX_ERR(21, 54, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + + /* "asyncpg/protocol/codecs/range.pyx":55 + * raise TypeError( + * 'list, tuple or Range object expected (got type {})'.format( + * type(obj))) # <<<<<<<<<<<<<< + * + * elif arg_type == _RANGE_ARGUMENT_TUPLE: + */ + __pyx_t_3 = NULL; + if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_3)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_3); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + } + } + if (!__pyx_t_3) { + __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_t_2, ((PyObject *)Py_TYPE(__pyx_v_obj))); if (unlikely(!__pyx_t_1)) __PYX_ERR(21, 54, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + } else { + #if CYTHON_FAST_PYCALL + if (PyFunction_Check(__pyx_t_2)) { + PyObject *__pyx_temp[2] = {__pyx_t_3, ((PyObject *)Py_TYPE(__pyx_v_obj))}; + __pyx_t_1 = __Pyx_PyFunction_FastCall(__pyx_t_2, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_1)) __PYX_ERR(21, 54, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_GOTREF(__pyx_t_1); + } else + #endif + #if CYTHON_FAST_PYCCALL + if (__Pyx_PyFastCFunction_Check(__pyx_t_2)) { + PyObject *__pyx_temp[2] = {__pyx_t_3, ((PyObject *)Py_TYPE(__pyx_v_obj))}; + __pyx_t_1 = __Pyx_PyCFunction_FastCall(__pyx_t_2, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_1)) __PYX_ERR(21, 54, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_GOTREF(__pyx_t_1); + } else + #endif + { + __pyx_t_4 = PyTuple_New(1+1); if (unlikely(!__pyx_t_4)) __PYX_ERR(21, 54, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_GIVEREF(__pyx_t_3); PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_3); __pyx_t_3 = NULL; + __Pyx_INCREF(((PyObject *)Py_TYPE(__pyx_v_obj))); + __Pyx_GIVEREF(((PyObject *)Py_TYPE(__pyx_v_obj))); + PyTuple_SET_ITEM(__pyx_t_4, 0+1, ((PyObject *)Py_TYPE(__pyx_v_obj))); + __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_t_4, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(21, 54, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + } + } + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "asyncpg/protocol/codecs/range.pyx":53 + * + * if arg_type == _RANGE_ARGUMENT_INVALID: + * raise TypeError( # <<<<<<<<<<<<<< + * 'list, tuple or Range object expected (got type {})'.format( + * type(obj))) + */ + __pyx_t_2 = PyTuple_New(1); if (unlikely(!__pyx_t_2)) __PYX_ERR(21, 53, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_GIVEREF(__pyx_t_1); + PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_t_1); + __pyx_t_1 = 0; + __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_t_2, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(21, 53, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_Raise(__pyx_t_1, 0, 0, 0); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __PYX_ERR(21, 53, __pyx_L1_error) + + /* "asyncpg/protocol/codecs/range.pyx":52 + * _RangeArgumentType arg_type = _range_type(obj) + * + * if arg_type == _RANGE_ARGUMENT_INVALID: # <<<<<<<<<<<<<< + * raise TypeError( + * 'list, tuple or Range object expected (got type {})'.format( + */ + break; + + /* "asyncpg/protocol/codecs/range.pyx":57 + * type(obj))) + * + * elif arg_type == _RANGE_ARGUMENT_TUPLE: # <<<<<<<<<<<<<< + * obj_len = len(obj) + * if obj_len == 2: + */ + case __pyx_e_7asyncpg_8protocol_8protocol__RANGE_ARGUMENT_TUPLE: + + /* "asyncpg/protocol/codecs/range.pyx":58 + * + * elif arg_type == _RANGE_ARGUMENT_TUPLE: + * obj_len = len(obj) # <<<<<<<<<<<<<< + * if obj_len == 2: + * lower = obj[0] + */ + __pyx_t_5 = PyObject_Length(__pyx_v_obj); if (unlikely(__pyx_t_5 == -1)) __PYX_ERR(21, 58, __pyx_L1_error) + __pyx_v_obj_len = __pyx_t_5; + + /* "asyncpg/protocol/codecs/range.pyx":59 + * elif arg_type == _RANGE_ARGUMENT_TUPLE: + * obj_len = len(obj) + * if obj_len == 2: # <<<<<<<<<<<<<< + * lower = obj[0] + * upper = obj[1] + */ + __pyx_t_6 = ((__pyx_v_obj_len == 2) != 0); + if (__pyx_t_6) { + + /* "asyncpg/protocol/codecs/range.pyx":60 + * obj_len = len(obj) + * if obj_len == 2: + * lower = obj[0] # <<<<<<<<<<<<<< + * upper = obj[1] + * + */ + __pyx_t_1 = __Pyx_GetItemInt(__pyx_v_obj, 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_1)) __PYX_ERR(21, 60, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF_SET(__pyx_v_lower, __pyx_t_1); + __pyx_t_1 = 0; + + /* "asyncpg/protocol/codecs/range.pyx":61 + * if obj_len == 2: + * lower = obj[0] + * upper = obj[1] # <<<<<<<<<<<<<< + * + * if lower is None: + */ + __pyx_t_1 = __Pyx_GetItemInt(__pyx_v_obj, 1, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_1)) __PYX_ERR(21, 61, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF_SET(__pyx_v_upper, __pyx_t_1); + __pyx_t_1 = 0; + + /* "asyncpg/protocol/codecs/range.pyx":63 + * upper = obj[1] + * + * if lower is None: # <<<<<<<<<<<<<< + * flags |= RANGE_LB_INF + * + */ + __pyx_t_6 = (__pyx_v_lower == Py_None); + __pyx_t_7 = (__pyx_t_6 != 0); + if (__pyx_t_7) { + + /* "asyncpg/protocol/codecs/range.pyx":64 + * + * if lower is None: + * flags |= RANGE_LB_INF # <<<<<<<<<<<<<< + * + * if upper is None: + */ + __pyx_v_flags = (__pyx_v_flags | 8); + + /* "asyncpg/protocol/codecs/range.pyx":63 + * upper = obj[1] + * + * if lower is None: # <<<<<<<<<<<<<< + * flags |= RANGE_LB_INF + * + */ + } + + /* "asyncpg/protocol/codecs/range.pyx":66 + * flags |= RANGE_LB_INF + * + * if upper is None: # <<<<<<<<<<<<<< + * flags |= RANGE_UB_INF + * + */ + __pyx_t_7 = (__pyx_v_upper == Py_None); + __pyx_t_6 = (__pyx_t_7 != 0); + if (__pyx_t_6) { + + /* "asyncpg/protocol/codecs/range.pyx":67 + * + * if upper is None: + * flags |= RANGE_UB_INF # <<<<<<<<<<<<<< + * + * flags |= RANGE_LB_INC | RANGE_UB_INC + */ + __pyx_v_flags = (__pyx_v_flags | 16); + + /* "asyncpg/protocol/codecs/range.pyx":66 + * flags |= RANGE_LB_INF + * + * if upper is None: # <<<<<<<<<<<<<< + * flags |= RANGE_UB_INF + * + */ + } + + /* "asyncpg/protocol/codecs/range.pyx":69 + * flags |= RANGE_UB_INF + * + * flags |= RANGE_LB_INC | RANGE_UB_INC # <<<<<<<<<<<<<< + * + * elif obj_len == 1: + */ + __pyx_v_flags = (__pyx_v_flags | 6); + + /* "asyncpg/protocol/codecs/range.pyx":59 + * elif arg_type == _RANGE_ARGUMENT_TUPLE: + * obj_len = len(obj) + * if obj_len == 2: # <<<<<<<<<<<<<< + * lower = obj[0] + * upper = obj[1] + */ + goto __pyx_L3; + } + + /* "asyncpg/protocol/codecs/range.pyx":71 + * flags |= RANGE_LB_INC | RANGE_UB_INC + * + * elif obj_len == 1: # <<<<<<<<<<<<<< + * lower = obj[0] + * flags |= RANGE_LB_INC | RANGE_UB_INF + */ + __pyx_t_6 = ((__pyx_v_obj_len == 1) != 0); + if (__pyx_t_6) { + + /* "asyncpg/protocol/codecs/range.pyx":72 + * + * elif obj_len == 1: + * lower = obj[0] # <<<<<<<<<<<<<< + * flags |= RANGE_LB_INC | RANGE_UB_INF + * + */ + __pyx_t_1 = __Pyx_GetItemInt(__pyx_v_obj, 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_1)) __PYX_ERR(21, 72, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF_SET(__pyx_v_lower, __pyx_t_1); + __pyx_t_1 = 0; + + /* "asyncpg/protocol/codecs/range.pyx":73 + * elif obj_len == 1: + * lower = obj[0] + * flags |= RANGE_LB_INC | RANGE_UB_INF # <<<<<<<<<<<<<< + * + * elif obj_len == 0: + */ + __pyx_v_flags = (__pyx_v_flags | 18); + + /* "asyncpg/protocol/codecs/range.pyx":71 + * flags |= RANGE_LB_INC | RANGE_UB_INC + * + * elif obj_len == 1: # <<<<<<<<<<<<<< + * lower = obj[0] + * flags |= RANGE_LB_INC | RANGE_UB_INF + */ + goto __pyx_L3; + } + + /* "asyncpg/protocol/codecs/range.pyx":75 + * flags |= RANGE_LB_INC | RANGE_UB_INF + * + * elif obj_len == 0: # <<<<<<<<<<<<<< + * flags |= RANGE_EMPTY + * + */ + __pyx_t_6 = ((__pyx_v_obj_len == 0) != 0); + if (__pyx_t_6) { + + /* "asyncpg/protocol/codecs/range.pyx":76 + * + * elif obj_len == 0: + * flags |= RANGE_EMPTY # <<<<<<<<<<<<<< + * + * else: + */ + __pyx_v_flags = (__pyx_v_flags | 1); + + /* "asyncpg/protocol/codecs/range.pyx":75 + * flags |= RANGE_LB_INC | RANGE_UB_INF + * + * elif obj_len == 0: # <<<<<<<<<<<<<< + * flags |= RANGE_EMPTY + * + */ + goto __pyx_L3; + } + + /* "asyncpg/protocol/codecs/range.pyx":79 + * + * else: + * raise ValueError( # <<<<<<<<<<<<<< + * 'expected 0, 1 or 2 elements in range (got {})'.format( + * obj_len)) + */ + /*else*/ { + + /* "asyncpg/protocol/codecs/range.pyx":80 + * else: + * raise ValueError( + * 'expected 0, 1 or 2 elements in range (got {})'.format( # <<<<<<<<<<<<<< + * obj_len)) + * + */ + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_kp_u_expected_0_1_or_2_elements_in_ra, __pyx_n_s_format); if (unlikely(!__pyx_t_2)) __PYX_ERR(21, 80, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + + /* "asyncpg/protocol/codecs/range.pyx":81 + * raise ValueError( + * 'expected 0, 1 or 2 elements in range (got {})'.format( + * obj_len)) # <<<<<<<<<<<<<< + * + * else: + */ + __pyx_t_4 = PyInt_FromSsize_t(__pyx_v_obj_len); if (unlikely(!__pyx_t_4)) __PYX_ERR(21, 81, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_3 = NULL; + if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_3)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_3); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + } + } + if (!__pyx_t_3) { + __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_4); if (unlikely(!__pyx_t_1)) __PYX_ERR(21, 80, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_GOTREF(__pyx_t_1); + } else { + #if CYTHON_FAST_PYCALL + if (PyFunction_Check(__pyx_t_2)) { + PyObject *__pyx_temp[2] = {__pyx_t_3, __pyx_t_4}; + __pyx_t_1 = __Pyx_PyFunction_FastCall(__pyx_t_2, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_1)) __PYX_ERR(21, 80, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + } else + #endif + #if CYTHON_FAST_PYCCALL + if (__Pyx_PyFastCFunction_Check(__pyx_t_2)) { + PyObject *__pyx_temp[2] = {__pyx_t_3, __pyx_t_4}; + __pyx_t_1 = __Pyx_PyCFunction_FastCall(__pyx_t_2, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_1)) __PYX_ERR(21, 80, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + } else + #endif + { + __pyx_t_8 = PyTuple_New(1+1); if (unlikely(!__pyx_t_8)) __PYX_ERR(21, 80, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __Pyx_GIVEREF(__pyx_t_3); PyTuple_SET_ITEM(__pyx_t_8, 0, __pyx_t_3); __pyx_t_3 = NULL; + __Pyx_GIVEREF(__pyx_t_4); + PyTuple_SET_ITEM(__pyx_t_8, 0+1, __pyx_t_4); + __pyx_t_4 = 0; + __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_t_8, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(21, 80, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + } + } + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "asyncpg/protocol/codecs/range.pyx":79 + * + * else: + * raise ValueError( # <<<<<<<<<<<<<< + * 'expected 0, 1 or 2 elements in range (got {})'.format( + * obj_len)) + */ + __pyx_t_2 = PyTuple_New(1); if (unlikely(!__pyx_t_2)) __PYX_ERR(21, 79, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_GIVEREF(__pyx_t_1); + PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_t_1); + __pyx_t_1 = 0; + __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_t_2, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(21, 79, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_Raise(__pyx_t_1, 0, 0, 0); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __PYX_ERR(21, 79, __pyx_L1_error) + } + __pyx_L3:; + + /* "asyncpg/protocol/codecs/range.pyx":57 + * type(obj))) + * + * elif arg_type == _RANGE_ARGUMENT_TUPLE: # <<<<<<<<<<<<<< + * obj_len = len(obj) + * if obj_len == 2: + */ + break; + default: + + /* "asyncpg/protocol/codecs/range.pyx":84 + * + * else: + * if obj.isempty: # <<<<<<<<<<<<<< + * flags |= RANGE_EMPTY + * else: + */ + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_obj, __pyx_n_s_isempty); if (unlikely(!__pyx_t_1)) __PYX_ERR(21, 84, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_1); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(21, 84, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + if (__pyx_t_6) { + + /* "asyncpg/protocol/codecs/range.pyx":85 + * else: + * if obj.isempty: + * flags |= RANGE_EMPTY # <<<<<<<<<<<<<< + * else: + * lower = obj.lower + */ + __pyx_v_flags = (__pyx_v_flags | 1); + + /* "asyncpg/protocol/codecs/range.pyx":84 + * + * else: + * if obj.isempty: # <<<<<<<<<<<<<< + * flags |= RANGE_EMPTY + * else: + */ + goto __pyx_L6; + } + + /* "asyncpg/protocol/codecs/range.pyx":87 + * flags |= RANGE_EMPTY + * else: + * lower = obj.lower # <<<<<<<<<<<<<< + * upper = obj.upper + * + */ + /*else*/ { + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_obj, __pyx_n_s_lower); if (unlikely(!__pyx_t_1)) __PYX_ERR(21, 87, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF_SET(__pyx_v_lower, __pyx_t_1); + __pyx_t_1 = 0; + + /* "asyncpg/protocol/codecs/range.pyx":88 + * else: + * lower = obj.lower + * upper = obj.upper # <<<<<<<<<<<<<< + * + * if obj.lower_inc: + */ + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_obj, __pyx_n_s_upper); if (unlikely(!__pyx_t_1)) __PYX_ERR(21, 88, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF_SET(__pyx_v_upper, __pyx_t_1); + __pyx_t_1 = 0; + + /* "asyncpg/protocol/codecs/range.pyx":90 + * upper = obj.upper + * + * if obj.lower_inc: # <<<<<<<<<<<<<< + * flags |= RANGE_LB_INC + * elif lower is None: + */ + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_obj, __pyx_n_s_lower_inc); if (unlikely(!__pyx_t_1)) __PYX_ERR(21, 90, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_1); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(21, 90, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + if (__pyx_t_6) { + + /* "asyncpg/protocol/codecs/range.pyx":91 + * + * if obj.lower_inc: + * flags |= RANGE_LB_INC # <<<<<<<<<<<<<< + * elif lower is None: + * flags |= RANGE_LB_INF + */ + __pyx_v_flags = (__pyx_v_flags | 2); + + /* "asyncpg/protocol/codecs/range.pyx":90 + * upper = obj.upper + * + * if obj.lower_inc: # <<<<<<<<<<<<<< + * flags |= RANGE_LB_INC + * elif lower is None: + */ + goto __pyx_L7; + } + + /* "asyncpg/protocol/codecs/range.pyx":92 + * if obj.lower_inc: + * flags |= RANGE_LB_INC + * elif lower is None: # <<<<<<<<<<<<<< + * flags |= RANGE_LB_INF + * + */ + __pyx_t_6 = (__pyx_v_lower == Py_None); + __pyx_t_7 = (__pyx_t_6 != 0); + if (__pyx_t_7) { + + /* "asyncpg/protocol/codecs/range.pyx":93 + * flags |= RANGE_LB_INC + * elif lower is None: + * flags |= RANGE_LB_INF # <<<<<<<<<<<<<< + * + * if obj.upper_inc: + */ + __pyx_v_flags = (__pyx_v_flags | 8); + + /* "asyncpg/protocol/codecs/range.pyx":92 + * if obj.lower_inc: + * flags |= RANGE_LB_INC + * elif lower is None: # <<<<<<<<<<<<<< + * flags |= RANGE_LB_INF + * + */ + } + __pyx_L7:; + + /* "asyncpg/protocol/codecs/range.pyx":95 + * flags |= RANGE_LB_INF + * + * if obj.upper_inc: # <<<<<<<<<<<<<< + * flags |= RANGE_UB_INC + * elif upper is None: + */ + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_obj, __pyx_n_s_upper_inc); if (unlikely(!__pyx_t_1)) __PYX_ERR(21, 95, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_7 = __Pyx_PyObject_IsTrue(__pyx_t_1); if (unlikely(__pyx_t_7 < 0)) __PYX_ERR(21, 95, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + if (__pyx_t_7) { + + /* "asyncpg/protocol/codecs/range.pyx":96 + * + * if obj.upper_inc: + * flags |= RANGE_UB_INC # <<<<<<<<<<<<<< + * elif upper is None: + * flags |= RANGE_UB_INF + */ + __pyx_v_flags = (__pyx_v_flags | 4); + + /* "asyncpg/protocol/codecs/range.pyx":95 + * flags |= RANGE_LB_INF + * + * if obj.upper_inc: # <<<<<<<<<<<<<< + * flags |= RANGE_UB_INC + * elif upper is None: + */ + goto __pyx_L8; + } + + /* "asyncpg/protocol/codecs/range.pyx":97 + * if obj.upper_inc: + * flags |= RANGE_UB_INC + * elif upper is None: # <<<<<<<<<<<<<< + * flags |= RANGE_UB_INF + * + */ + __pyx_t_7 = (__pyx_v_upper == Py_None); + __pyx_t_6 = (__pyx_t_7 != 0); + if (__pyx_t_6) { + + /* "asyncpg/protocol/codecs/range.pyx":98 + * flags |= RANGE_UB_INC + * elif upper is None: + * flags |= RANGE_UB_INF # <<<<<<<<<<<<<< + * + * if _range_has_lbound(flags): + */ + __pyx_v_flags = (__pyx_v_flags | 16); + + /* "asyncpg/protocol/codecs/range.pyx":97 + * if obj.upper_inc: + * flags |= RANGE_UB_INC + * elif upper is None: # <<<<<<<<<<<<<< + * flags |= RANGE_UB_INF + * + */ + } + __pyx_L8:; + } + __pyx_L6:; + break; + } + + /* "asyncpg/protocol/codecs/range.pyx":100 + * flags |= RANGE_UB_INF + * + * if _range_has_lbound(flags): # <<<<<<<<<<<<<< + * encoder(settings, bounds_data, lower, encoder_arg) + * + */ + __pyx_t_6 = (__pyx_f_7asyncpg_8protocol_8protocol__range_has_lbound(__pyx_v_flags) != 0); + if (__pyx_t_6) { + + /* "asyncpg/protocol/codecs/range.pyx":101 + * + * if _range_has_lbound(flags): + * encoder(settings, bounds_data, lower, encoder_arg) # <<<<<<<<<<<<<< + * + * if _range_has_ubound(flags): + */ + __pyx_t_1 = __pyx_v_encoder(__pyx_v_settings, __pyx_v_bounds_data, __pyx_v_lower, __pyx_v_encoder_arg); if (unlikely(!__pyx_t_1)) __PYX_ERR(21, 101, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "asyncpg/protocol/codecs/range.pyx":100 + * flags |= RANGE_UB_INF + * + * if _range_has_lbound(flags): # <<<<<<<<<<<<<< + * encoder(settings, bounds_data, lower, encoder_arg) + * + */ + } + + /* "asyncpg/protocol/codecs/range.pyx":103 + * encoder(settings, bounds_data, lower, encoder_arg) + * + * if _range_has_ubound(flags): # <<<<<<<<<<<<<< + * encoder(settings, bounds_data, upper, encoder_arg) + * + */ + __pyx_t_6 = (__pyx_f_7asyncpg_8protocol_8protocol__range_has_ubound(__pyx_v_flags) != 0); + if (__pyx_t_6) { + + /* "asyncpg/protocol/codecs/range.pyx":104 + * + * if _range_has_ubound(flags): + * encoder(settings, bounds_data, upper, encoder_arg) # <<<<<<<<<<<<<< + * + * buf.write_int32(1 + bounds_data.len()) + */ + __pyx_t_1 = __pyx_v_encoder(__pyx_v_settings, __pyx_v_bounds_data, __pyx_v_upper, __pyx_v_encoder_arg); if (unlikely(!__pyx_t_1)) __PYX_ERR(21, 104, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "asyncpg/protocol/codecs/range.pyx":103 + * encoder(settings, bounds_data, lower, encoder_arg) + * + * if _range_has_ubound(flags): # <<<<<<<<<<<<<< + * encoder(settings, bounds_data, upper, encoder_arg) + * + */ + } + + /* "asyncpg/protocol/codecs/range.pyx":106 + * encoder(settings, bounds_data, upper, encoder_arg) + * + * buf.write_int32(1 + bounds_data.len()) # <<<<<<<<<<<<<< + * buf.write_byte(flags) + * buf.write_buffer(bounds_data) + */ + __pyx_t_1 = __pyx_f_7asyncpg_8protocol_8protocol_11WriteBuffer_len(__pyx_v_bounds_data); if (unlikely(!__pyx_t_1)) __PYX_ERR(21, 106, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = __Pyx_PyInt_AddCObj(__pyx_int_1, __pyx_t_1, 1, 0); if (unlikely(!__pyx_t_2)) __PYX_ERR(21, 106, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_9 = __Pyx_PyInt_As_int32_t(__pyx_t_2); if (unlikely((__pyx_t_9 == ((int32_t)-1)) && PyErr_Occurred())) __PYX_ERR(21, 106, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_2 = __pyx_f_7asyncpg_8protocol_8protocol_11WriteBuffer_write_int32(__pyx_v_buf, __pyx_t_9); if (unlikely(!__pyx_t_2)) __PYX_ERR(21, 106, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "asyncpg/protocol/codecs/range.pyx":107 + * + * buf.write_int32(1 + bounds_data.len()) + * buf.write_byte(flags) # <<<<<<<<<<<<<< + * buf.write_buffer(bounds_data) + * + */ + __pyx_t_2 = __pyx_f_7asyncpg_8protocol_8protocol_11WriteBuffer_write_byte(__pyx_v_buf, ((int8_t)__pyx_v_flags)); if (unlikely(!__pyx_t_2)) __PYX_ERR(21, 107, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "asyncpg/protocol/codecs/range.pyx":108 + * buf.write_int32(1 + bounds_data.len()) + * buf.write_byte(flags) + * buf.write_buffer(bounds_data) # <<<<<<<<<<<<<< + * + * + */ + __pyx_t_2 = __pyx_f_7asyncpg_8protocol_8protocol_11WriteBuffer_write_buffer(__pyx_v_buf, __pyx_v_bounds_data); if (unlikely(!__pyx_t_2)) __PYX_ERR(21, 108, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "asyncpg/protocol/codecs/range.pyx":41 + * + * + * cdef range_encode(ConnectionSettings settings, WriteBuffer buf, # <<<<<<<<<<<<<< + * object obj, uint32_t elem_oid, + * encode_func_ex encoder, const void *encoder_arg): + */ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_XDECREF(__pyx_t_8); + __Pyx_AddTraceback("asyncpg.protocol.protocol.range_encode", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XDECREF(__pyx_v_lower); + __Pyx_XDECREF(__pyx_v_upper); + __Pyx_XDECREF((PyObject *)__pyx_v_bounds_data); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "asyncpg/protocol/codecs/range.pyx":111 + * + * + * cdef range_decode(ConnectionSettings settings, FastReadBuffer buf, # <<<<<<<<<<<<<< + * decode_func_ex decoder, const void *decoder_arg): + * cdef: + */ + +static PyObject *__pyx_f_7asyncpg_8protocol_8protocol_range_decode(struct __pyx_obj_7asyncpg_8protocol_8protocol_ConnectionSettings *__pyx_v_settings, struct __pyx_obj_7asyncpg_8protocol_8protocol_FastReadBuffer *__pyx_v_buf, __pyx_t_7asyncpg_8protocol_8protocol_decode_func_ex __pyx_v_decoder, void const *__pyx_v_decoder_arg) { + uint8_t __pyx_v_flags; + int32_t __pyx_v_bound_len; + PyObject *__pyx_v_lower = 0; + PyObject *__pyx_v_upper = 0; + struct __pyx_obj_7asyncpg_8protocol_8protocol_FastReadBuffer *__pyx_v_bound_buf = 0; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + char const *__pyx_t_1; + PyObject *__pyx_t_2 = NULL; + int __pyx_t_3; + PyObject *__pyx_t_4 = NULL; + PyObject *__pyx_t_5 = NULL; + __Pyx_RefNannySetupContext("range_decode", 0); + + /* "asyncpg/protocol/codecs/range.pyx":114 + * decode_func_ex decoder, const void *decoder_arg): + * cdef: + * uint8_t flags = buf.read(1)[0] # <<<<<<<<<<<<<< + * int32_t bound_len + * object lower = None + */ + __pyx_t_1 = __pyx_f_7asyncpg_8protocol_8protocol_14FastReadBuffer_read(__pyx_v_buf, 1); if (unlikely(__pyx_t_1 == NULL)) __PYX_ERR(21, 114, __pyx_L1_error) + __pyx_v_flags = ((uint8_t)(__pyx_t_1[0])); + + /* "asyncpg/protocol/codecs/range.pyx":116 + * uint8_t flags = buf.read(1)[0] + * int32_t bound_len + * object lower = None # <<<<<<<<<<<<<< + * object upper = None + * FastReadBuffer bound_buf = FastReadBuffer.new() + */ + __Pyx_INCREF(Py_None); + __pyx_v_lower = Py_None; + + /* "asyncpg/protocol/codecs/range.pyx":117 + * int32_t bound_len + * object lower = None + * object upper = None # <<<<<<<<<<<<<< + * FastReadBuffer bound_buf = FastReadBuffer.new() + * + */ + __Pyx_INCREF(Py_None); + __pyx_v_upper = Py_None; + + /* "asyncpg/protocol/codecs/range.pyx":118 + * object lower = None + * object upper = None + * FastReadBuffer bound_buf = FastReadBuffer.new() # <<<<<<<<<<<<<< + * + * if _range_has_lbound(flags): + */ + __pyx_t_2 = ((PyObject *)__pyx_f_7asyncpg_8protocol_8protocol_14FastReadBuffer_new()); if (unlikely(!__pyx_t_2)) __PYX_ERR(21, 118, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_v_bound_buf = ((struct __pyx_obj_7asyncpg_8protocol_8protocol_FastReadBuffer *)__pyx_t_2); + __pyx_t_2 = 0; + + /* "asyncpg/protocol/codecs/range.pyx":120 + * FastReadBuffer bound_buf = FastReadBuffer.new() + * + * if _range_has_lbound(flags): # <<<<<<<<<<<<<< + * bound_len = hton.unpack_int32(buf.read(4)) + * if bound_len == -1: + */ + __pyx_t_3 = (__pyx_f_7asyncpg_8protocol_8protocol__range_has_lbound(__pyx_v_flags) != 0); + if (__pyx_t_3) { + + /* "asyncpg/protocol/codecs/range.pyx":121 + * + * if _range_has_lbound(flags): + * bound_len = hton.unpack_int32(buf.read(4)) # <<<<<<<<<<<<<< + * if bound_len == -1: + * lower = None + */ + __pyx_t_1 = __pyx_f_7asyncpg_8protocol_8protocol_14FastReadBuffer_read(__pyx_v_buf, 4); if (unlikely(__pyx_t_1 == NULL)) __PYX_ERR(21, 121, __pyx_L1_error) + __pyx_v_bound_len = __pyx_f_7asyncpg_8protocol_4hton_unpack_int32(__pyx_t_1); + + /* "asyncpg/protocol/codecs/range.pyx":122 + * if _range_has_lbound(flags): + * bound_len = hton.unpack_int32(buf.read(4)) + * if bound_len == -1: # <<<<<<<<<<<<<< + * lower = None + * else: + */ + __pyx_t_3 = ((__pyx_v_bound_len == -1L) != 0); + if (__pyx_t_3) { + + /* "asyncpg/protocol/codecs/range.pyx":123 + * bound_len = hton.unpack_int32(buf.read(4)) + * if bound_len == -1: + * lower = None # <<<<<<<<<<<<<< + * else: + * bound_buf.slice_from(buf, bound_len) + */ + __Pyx_INCREF(Py_None); + __Pyx_DECREF_SET(__pyx_v_lower, Py_None); + + /* "asyncpg/protocol/codecs/range.pyx":122 + * if _range_has_lbound(flags): + * bound_len = hton.unpack_int32(buf.read(4)) + * if bound_len == -1: # <<<<<<<<<<<<<< + * lower = None + * else: + */ + goto __pyx_L4; + } + + /* "asyncpg/protocol/codecs/range.pyx":125 + * lower = None + * else: + * bound_buf.slice_from(buf, bound_len) # <<<<<<<<<<<<<< + * lower = decoder(settings, bound_buf, decoder_arg) + * + */ + /*else*/ { + __pyx_t_2 = ((PyObject *)__pyx_f_7asyncpg_8protocol_8protocol_14FastReadBuffer_slice_from(__pyx_v_bound_buf, __pyx_v_buf, __pyx_v_bound_len)); if (unlikely(!__pyx_t_2)) __PYX_ERR(21, 125, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "asyncpg/protocol/codecs/range.pyx":126 + * else: + * bound_buf.slice_from(buf, bound_len) + * lower = decoder(settings, bound_buf, decoder_arg) # <<<<<<<<<<<<<< + * + * if _range_has_ubound(flags): + */ + __pyx_t_2 = __pyx_v_decoder(__pyx_v_settings, __pyx_v_bound_buf, __pyx_v_decoder_arg); if (unlikely(!__pyx_t_2)) __PYX_ERR(21, 126, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF_SET(__pyx_v_lower, __pyx_t_2); + __pyx_t_2 = 0; + } + __pyx_L4:; + + /* "asyncpg/protocol/codecs/range.pyx":120 + * FastReadBuffer bound_buf = FastReadBuffer.new() + * + * if _range_has_lbound(flags): # <<<<<<<<<<<<<< + * bound_len = hton.unpack_int32(buf.read(4)) + * if bound_len == -1: + */ + } + + /* "asyncpg/protocol/codecs/range.pyx":128 + * lower = decoder(settings, bound_buf, decoder_arg) + * + * if _range_has_ubound(flags): # <<<<<<<<<<<<<< + * bound_len = hton.unpack_int32(buf.read(4)) + * if bound_len == -1: + */ + __pyx_t_3 = (__pyx_f_7asyncpg_8protocol_8protocol__range_has_ubound(__pyx_v_flags) != 0); + if (__pyx_t_3) { + + /* "asyncpg/protocol/codecs/range.pyx":129 + * + * if _range_has_ubound(flags): + * bound_len = hton.unpack_int32(buf.read(4)) # <<<<<<<<<<<<<< + * if bound_len == -1: + * upper = None + */ + __pyx_t_1 = __pyx_f_7asyncpg_8protocol_8protocol_14FastReadBuffer_read(__pyx_v_buf, 4); if (unlikely(__pyx_t_1 == NULL)) __PYX_ERR(21, 129, __pyx_L1_error) + __pyx_v_bound_len = __pyx_f_7asyncpg_8protocol_4hton_unpack_int32(__pyx_t_1); + + /* "asyncpg/protocol/codecs/range.pyx":130 + * if _range_has_ubound(flags): + * bound_len = hton.unpack_int32(buf.read(4)) + * if bound_len == -1: # <<<<<<<<<<<<<< + * upper = None + * else: + */ + __pyx_t_3 = ((__pyx_v_bound_len == -1L) != 0); + if (__pyx_t_3) { + + /* "asyncpg/protocol/codecs/range.pyx":131 + * bound_len = hton.unpack_int32(buf.read(4)) + * if bound_len == -1: + * upper = None # <<<<<<<<<<<<<< + * else: + * bound_buf.slice_from(buf, bound_len) + */ + __Pyx_INCREF(Py_None); + __Pyx_DECREF_SET(__pyx_v_upper, Py_None); + + /* "asyncpg/protocol/codecs/range.pyx":130 + * if _range_has_ubound(flags): + * bound_len = hton.unpack_int32(buf.read(4)) + * if bound_len == -1: # <<<<<<<<<<<<<< + * upper = None + * else: + */ + goto __pyx_L6; + } + + /* "asyncpg/protocol/codecs/range.pyx":133 + * upper = None + * else: + * bound_buf.slice_from(buf, bound_len) # <<<<<<<<<<<<<< + * upper = decoder(settings, bound_buf, decoder_arg) + * + */ + /*else*/ { + __pyx_t_2 = ((PyObject *)__pyx_f_7asyncpg_8protocol_8protocol_14FastReadBuffer_slice_from(__pyx_v_bound_buf, __pyx_v_buf, __pyx_v_bound_len)); if (unlikely(!__pyx_t_2)) __PYX_ERR(21, 133, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "asyncpg/protocol/codecs/range.pyx":134 + * else: + * bound_buf.slice_from(buf, bound_len) + * upper = decoder(settings, bound_buf, decoder_arg) # <<<<<<<<<<<<<< + * + * return apg_types.Range(lower=lower, upper=upper, + */ + __pyx_t_2 = __pyx_v_decoder(__pyx_v_settings, __pyx_v_bound_buf, __pyx_v_decoder_arg); if (unlikely(!__pyx_t_2)) __PYX_ERR(21, 134, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF_SET(__pyx_v_upper, __pyx_t_2); + __pyx_t_2 = 0; + } + __pyx_L6:; + + /* "asyncpg/protocol/codecs/range.pyx":128 + * lower = decoder(settings, bound_buf, decoder_arg) + * + * if _range_has_ubound(flags): # <<<<<<<<<<<<<< + * bound_len = hton.unpack_int32(buf.read(4)) + * if bound_len == -1: + */ + } + + /* "asyncpg/protocol/codecs/range.pyx":136 + * upper = decoder(settings, bound_buf, decoder_arg) + * + * return apg_types.Range(lower=lower, upper=upper, # <<<<<<<<<<<<<< + * lower_inc=(flags & RANGE_LB_INC) != 0, + * upper_inc=(flags & RANGE_UB_INC) != 0, + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_2 = __Pyx_GetModuleGlobalName(__pyx_n_s_apg_types); if (unlikely(!__pyx_t_2)) __PYX_ERR(21, 136, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_Range); if (unlikely(!__pyx_t_4)) __PYX_ERR(21, 136, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_2 = PyDict_New(); if (unlikely(!__pyx_t_2)) __PYX_ERR(21, 136, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_lower, __pyx_v_lower) < 0) __PYX_ERR(21, 136, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_upper, __pyx_v_upper) < 0) __PYX_ERR(21, 136, __pyx_L1_error) + + /* "asyncpg/protocol/codecs/range.pyx":137 + * + * return apg_types.Range(lower=lower, upper=upper, + * lower_inc=(flags & RANGE_LB_INC) != 0, # <<<<<<<<<<<<<< + * upper_inc=(flags & RANGE_UB_INC) != 0, + * empty=(flags & RANGE_EMPTY) != 0) + */ + __pyx_t_5 = __Pyx_PyBool_FromLong(((__pyx_v_flags & 2) != 0)); if (unlikely(!__pyx_t_5)) __PYX_ERR(21, 137, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_lower_inc, __pyx_t_5) < 0) __PYX_ERR(21, 136, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + + /* "asyncpg/protocol/codecs/range.pyx":138 + * return apg_types.Range(lower=lower, upper=upper, + * lower_inc=(flags & RANGE_LB_INC) != 0, + * upper_inc=(flags & RANGE_UB_INC) != 0, # <<<<<<<<<<<<<< + * empty=(flags & RANGE_EMPTY) != 0) + * + */ + __pyx_t_5 = __Pyx_PyBool_FromLong(((__pyx_v_flags & 4) != 0)); if (unlikely(!__pyx_t_5)) __PYX_ERR(21, 138, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_upper_inc, __pyx_t_5) < 0) __PYX_ERR(21, 136, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + + /* "asyncpg/protocol/codecs/range.pyx":139 + * lower_inc=(flags & RANGE_LB_INC) != 0, + * upper_inc=(flags & RANGE_UB_INC) != 0, + * empty=(flags & RANGE_EMPTY) != 0) # <<<<<<<<<<<<<< + * + * + */ + __pyx_t_5 = __Pyx_PyBool_FromLong(((__pyx_v_flags & 1) != 0)); if (unlikely(!__pyx_t_5)) __PYX_ERR(21, 139, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_empty, __pyx_t_5) < 0) __PYX_ERR(21, 136, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + + /* "asyncpg/protocol/codecs/range.pyx":136 + * upper = decoder(settings, bound_buf, decoder_arg) + * + * return apg_types.Range(lower=lower, upper=upper, # <<<<<<<<<<<<<< + * lower_inc=(flags & RANGE_LB_INC) != 0, + * upper_inc=(flags & RANGE_UB_INC) != 0, + */ + __pyx_t_5 = __Pyx_PyObject_Call(__pyx_t_4, __pyx_empty_tuple, __pyx_t_2); if (unlikely(!__pyx_t_5)) __PYX_ERR(21, 136, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_r = __pyx_t_5; + __pyx_t_5 = 0; + goto __pyx_L0; + + /* "asyncpg/protocol/codecs/range.pyx":111 + * + * + * cdef range_decode(ConnectionSettings settings, FastReadBuffer buf, # <<<<<<<<<<<<<< + * decode_func_ex decoder, const void *decoder_arg): + * cdef: + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_AddTraceback("asyncpg.protocol.protocol.range_decode", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XDECREF(__pyx_v_lower); + __Pyx_XDECREF(__pyx_v_upper); + __Pyx_XDECREF((PyObject *)__pyx_v_bound_buf); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "asyncpg/protocol/codecs/range.pyx":142 + * + * + * cdef init_range_codecs(): # <<<<<<<<<<<<<< + * register_core_codec(ANYRANGEOID, + * NULL, + */ + +static PyObject *__pyx_f_7asyncpg_8protocol_8protocol_init_range_codecs(void) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + __Pyx_RefNannySetupContext("init_range_codecs", 0); + + /* "asyncpg/protocol/codecs/range.pyx":143 + * + * cdef init_range_codecs(): + * register_core_codec(ANYRANGEOID, # <<<<<<<<<<<<<< + * NULL, + * &text_decode, + */ + __pyx_t_1 = __pyx_f_7asyncpg_8protocol_8protocol_register_core_codec(0xEF7, NULL, ((__pyx_t_7asyncpg_8protocol_8protocol_decode_func)(&__pyx_f_7asyncpg_8protocol_8protocol_text_decode)), __pyx_e_7asyncpg_8protocol_8protocol_PG_FORMAT_TEXT); if (unlikely(!__pyx_t_1)) __PYX_ERR(21, 143, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "asyncpg/protocol/codecs/range.pyx":142 + * + * + * cdef init_range_codecs(): # <<<<<<<<<<<<<< + * register_core_codec(ANYRANGEOID, + * NULL, + */ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("asyncpg.protocol.protocol.init_range_codecs", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "asyncpg/protocol/codecs/record.pyx":8 + * + * + * cdef inline record_encode_frame(ConnectionSettings settings, WriteBuffer buf, # <<<<<<<<<<<<<< + * WriteBuffer elem_data, int32_t elem_count): + * buf.write_int32(4 + elem_data.len()) + */ + +static CYTHON_INLINE PyObject *__pyx_f_7asyncpg_8protocol_8protocol_record_encode_frame(CYTHON_UNUSED struct __pyx_obj_7asyncpg_8protocol_8protocol_ConnectionSettings *__pyx_v_settings, struct __pyx_obj_7asyncpg_8protocol_8protocol_WriteBuffer *__pyx_v_buf, struct __pyx_obj_7asyncpg_8protocol_8protocol_WriteBuffer *__pyx_v_elem_data, int32_t __pyx_v_elem_count) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + int32_t __pyx_t_3; + __Pyx_RefNannySetupContext("record_encode_frame", 0); + + /* "asyncpg/protocol/codecs/record.pyx":10 + * cdef inline record_encode_frame(ConnectionSettings settings, WriteBuffer buf, + * WriteBuffer elem_data, int32_t elem_count): + * buf.write_int32(4 + elem_data.len()) # <<<<<<<<<<<<<< + * # attribute count + * buf.write_int32(elem_count) + */ + __pyx_t_1 = __pyx_f_7asyncpg_8protocol_8protocol_11WriteBuffer_len(__pyx_v_elem_data); if (unlikely(!__pyx_t_1)) __PYX_ERR(22, 10, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = __Pyx_PyInt_AddCObj(__pyx_int_4, __pyx_t_1, 4, 0); if (unlikely(!__pyx_t_2)) __PYX_ERR(22, 10, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_3 = __Pyx_PyInt_As_int32_t(__pyx_t_2); if (unlikely((__pyx_t_3 == ((int32_t)-1)) && PyErr_Occurred())) __PYX_ERR(22, 10, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_2 = __pyx_f_7asyncpg_8protocol_8protocol_11WriteBuffer_write_int32(__pyx_v_buf, __pyx_t_3); if (unlikely(!__pyx_t_2)) __PYX_ERR(22, 10, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "asyncpg/protocol/codecs/record.pyx":12 + * buf.write_int32(4 + elem_data.len()) + * # attribute count + * buf.write_int32(elem_count) # <<<<<<<<<<<<<< + * # encoded attribute data + * buf.write_buffer(elem_data) + */ + __pyx_t_2 = __pyx_f_7asyncpg_8protocol_8protocol_11WriteBuffer_write_int32(__pyx_v_buf, __pyx_v_elem_count); if (unlikely(!__pyx_t_2)) __PYX_ERR(22, 12, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "asyncpg/protocol/codecs/record.pyx":14 + * buf.write_int32(elem_count) + * # encoded attribute data + * buf.write_buffer(elem_data) # <<<<<<<<<<<<<< + * + * + */ + __pyx_t_2 = __pyx_f_7asyncpg_8protocol_8protocol_11WriteBuffer_write_buffer(__pyx_v_buf, __pyx_v_elem_data); if (unlikely(!__pyx_t_2)) __PYX_ERR(22, 14, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "asyncpg/protocol/codecs/record.pyx":8 + * + * + * cdef inline record_encode_frame(ConnectionSettings settings, WriteBuffer buf, # <<<<<<<<<<<<<< + * WriteBuffer elem_data, int32_t elem_count): + * buf.write_int32(4 + elem_data.len()) + */ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_AddTraceback("asyncpg.protocol.protocol.record_encode_frame", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "asyncpg/protocol/codecs/record.pyx":17 + * + * + * cdef anonymous_record_decode(ConnectionSettings settings, FastReadBuffer buf): # <<<<<<<<<<<<<< + * cdef: + * tuple result + */ + +static PyObject *__pyx_f_7asyncpg_8protocol_8protocol_anonymous_record_decode(struct __pyx_obj_7asyncpg_8protocol_8protocol_ConnectionSettings *__pyx_v_settings, struct __pyx_obj_7asyncpg_8protocol_8protocol_FastReadBuffer *__pyx_v_buf) { + PyObject *__pyx_v_result = 0; + uint32_t __pyx_v_elem_count; + int32_t __pyx_v_elem_len; + uint32_t __pyx_v_elem_typ; + uint32_t __pyx_v_i; + struct __pyx_obj_7asyncpg_8protocol_8protocol_Codec *__pyx_v_elem_codec = 0; + struct __pyx_obj_7asyncpg_8protocol_8protocol_FastReadBuffer *__pyx_v_elem_buf = 0; + PyObject *__pyx_v_elem = NULL; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + char const *__pyx_t_2; + uint32_t __pyx_t_3; + uint32_t __pyx_t_4; + int __pyx_t_5; + int __pyx_t_6; + int __pyx_t_7; + PyObject *__pyx_t_8 = NULL; + PyObject *__pyx_t_9 = NULL; + PyObject *__pyx_t_10 = NULL; + PyObject *__pyx_t_11 = NULL; + int __pyx_t_12; + PyObject *__pyx_t_13 = NULL; + __Pyx_RefNannySetupContext("anonymous_record_decode", 0); + + /* "asyncpg/protocol/codecs/record.pyx":25 + * uint32_t i + * Codec elem_codec + * FastReadBuffer elem_buf = FastReadBuffer.new() # <<<<<<<<<<<<<< + * + * elem_count = hton.unpack_int32(buf.read(4)) + */ + __pyx_t_1 = ((PyObject *)__pyx_f_7asyncpg_8protocol_8protocol_14FastReadBuffer_new()); if (unlikely(!__pyx_t_1)) __PYX_ERR(22, 25, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_v_elem_buf = ((struct __pyx_obj_7asyncpg_8protocol_8protocol_FastReadBuffer *)__pyx_t_1); + __pyx_t_1 = 0; + + /* "asyncpg/protocol/codecs/record.pyx":27 + * FastReadBuffer elem_buf = FastReadBuffer.new() + * + * elem_count = hton.unpack_int32(buf.read(4)) # <<<<<<<<<<<<<< + * result = cpython.PyTuple_New(elem_count) + * + */ + __pyx_t_2 = __pyx_f_7asyncpg_8protocol_8protocol_14FastReadBuffer_read(__pyx_v_buf, 4); if (unlikely(__pyx_t_2 == NULL)) __PYX_ERR(22, 27, __pyx_L1_error) + __pyx_v_elem_count = ((uint32_t)__pyx_f_7asyncpg_8protocol_4hton_unpack_int32(__pyx_t_2)); + + /* "asyncpg/protocol/codecs/record.pyx":28 + * + * elem_count = hton.unpack_int32(buf.read(4)) + * result = cpython.PyTuple_New(elem_count) # <<<<<<<<<<<<<< + * + * for i in range(elem_count): + */ + __pyx_t_1 = PyTuple_New(__pyx_v_elem_count); if (unlikely(!__pyx_t_1)) __PYX_ERR(22, 28, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_v_result = ((PyObject*)__pyx_t_1); + __pyx_t_1 = 0; + + /* "asyncpg/protocol/codecs/record.pyx":30 + * result = cpython.PyTuple_New(elem_count) + * + * for i in range(elem_count): # <<<<<<<<<<<<<< + * elem_typ = hton.unpack_int32(buf.read(4)) + * elem_len = hton.unpack_int32(buf.read(4)) + */ + __pyx_t_3 = __pyx_v_elem_count; + for (__pyx_t_4 = 0; __pyx_t_4 < __pyx_t_3; __pyx_t_4+=1) { + __pyx_v_i = __pyx_t_4; + + /* "asyncpg/protocol/codecs/record.pyx":31 + * + * for i in range(elem_count): + * elem_typ = hton.unpack_int32(buf.read(4)) # <<<<<<<<<<<<<< + * elem_len = hton.unpack_int32(buf.read(4)) + * + */ + __pyx_t_2 = __pyx_f_7asyncpg_8protocol_8protocol_14FastReadBuffer_read(__pyx_v_buf, 4); if (unlikely(__pyx_t_2 == NULL)) __PYX_ERR(22, 31, __pyx_L1_error) + __pyx_v_elem_typ = ((uint32_t)__pyx_f_7asyncpg_8protocol_4hton_unpack_int32(__pyx_t_2)); + + /* "asyncpg/protocol/codecs/record.pyx":32 + * for i in range(elem_count): + * elem_typ = hton.unpack_int32(buf.read(4)) + * elem_len = hton.unpack_int32(buf.read(4)) # <<<<<<<<<<<<<< + * + * if elem_len == -1: + */ + __pyx_t_2 = __pyx_f_7asyncpg_8protocol_8protocol_14FastReadBuffer_read(__pyx_v_buf, 4); if (unlikely(__pyx_t_2 == NULL)) __PYX_ERR(22, 32, __pyx_L1_error) + __pyx_v_elem_len = __pyx_f_7asyncpg_8protocol_4hton_unpack_int32(__pyx_t_2); + + /* "asyncpg/protocol/codecs/record.pyx":34 + * elem_len = hton.unpack_int32(buf.read(4)) + * + * if elem_len == -1: # <<<<<<<<<<<<<< + * elem = None + * else: + */ + __pyx_t_5 = ((__pyx_v_elem_len == -1L) != 0); + if (__pyx_t_5) { + + /* "asyncpg/protocol/codecs/record.pyx":35 + * + * if elem_len == -1: + * elem = None # <<<<<<<<<<<<<< + * else: + * elem_codec = settings.get_data_codec(elem_typ) + */ + __Pyx_INCREF(Py_None); + __Pyx_XDECREF_SET(__pyx_v_elem, Py_None); + + /* "asyncpg/protocol/codecs/record.pyx":34 + * elem_len = hton.unpack_int32(buf.read(4)) + * + * if elem_len == -1: # <<<<<<<<<<<<<< + * elem = None + * else: + */ + goto __pyx_L5; + } + + /* "asyncpg/protocol/codecs/record.pyx":37 + * elem = None + * else: + * elem_codec = settings.get_data_codec(elem_typ) # <<<<<<<<<<<<<< + * if elem_codec is None or not elem_codec.has_decoder(): + * raise RuntimeError( + */ + /*else*/ { + __pyx_t_1 = ((PyObject *)__pyx_f_7asyncpg_8protocol_8protocol_18ConnectionSettings_get_data_codec(__pyx_v_settings, __pyx_v_elem_typ, 0, NULL)); if (unlikely(!__pyx_t_1)) __PYX_ERR(22, 37, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_XDECREF_SET(__pyx_v_elem_codec, ((struct __pyx_obj_7asyncpg_8protocol_8protocol_Codec *)__pyx_t_1)); + __pyx_t_1 = 0; + + /* "asyncpg/protocol/codecs/record.pyx":38 + * else: + * elem_codec = settings.get_data_codec(elem_typ) + * if elem_codec is None or not elem_codec.has_decoder(): # <<<<<<<<<<<<<< + * raise RuntimeError( + * 'no decoder for composite type element in ' + */ + __pyx_t_6 = (((PyObject *)__pyx_v_elem_codec) == Py_None); + __pyx_t_7 = (__pyx_t_6 != 0); + if (!__pyx_t_7) { + } else { + __pyx_t_5 = __pyx_t_7; + goto __pyx_L7_bool_binop_done; + } + __pyx_t_1 = __pyx_f_7asyncpg_8protocol_8protocol_5Codec_has_decoder(__pyx_v_elem_codec); if (unlikely(!__pyx_t_1)) __PYX_ERR(22, 38, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_7 = __Pyx_PyObject_IsTrue(__pyx_t_1); if (unlikely(__pyx_t_7 < 0)) __PYX_ERR(22, 38, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_6 = ((!__pyx_t_7) != 0); + __pyx_t_5 = __pyx_t_6; + __pyx_L7_bool_binop_done:; + if (__pyx_t_5) { + + /* "asyncpg/protocol/codecs/record.pyx":41 + * raise RuntimeError( + * 'no decoder for composite type element in ' + * 'position {} of type OID {}'.format(i, elem_typ)) # <<<<<<<<<<<<<< + * elem = elem_codec.decode(settings, + * elem_buf.slice_from(buf, elem_len)) + */ + __pyx_t_8 = __Pyx_PyObject_GetAttrStr(__pyx_kp_u_no_decoder_for_composite_type_el, __pyx_n_s_format); if (unlikely(!__pyx_t_8)) __PYX_ERR(22, 41, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __pyx_t_9 = __Pyx_PyInt_From_uint32_t(__pyx_v_i); if (unlikely(!__pyx_t_9)) __PYX_ERR(22, 41, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_9); + __pyx_t_10 = __Pyx_PyInt_From_uint32_t(__pyx_v_elem_typ); if (unlikely(!__pyx_t_10)) __PYX_ERR(22, 41, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_10); + __pyx_t_11 = NULL; + __pyx_t_12 = 0; + if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_8))) { + __pyx_t_11 = PyMethod_GET_SELF(__pyx_t_8); + if (likely(__pyx_t_11)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_8); + __Pyx_INCREF(__pyx_t_11); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_8, function); + __pyx_t_12 = 1; + } + } + #if CYTHON_FAST_PYCALL + if (PyFunction_Check(__pyx_t_8)) { + PyObject *__pyx_temp[3] = {__pyx_t_11, __pyx_t_9, __pyx_t_10}; + __pyx_t_1 = __Pyx_PyFunction_FastCall(__pyx_t_8, __pyx_temp+1-__pyx_t_12, 2+__pyx_t_12); if (unlikely(!__pyx_t_1)) __PYX_ERR(22, 41, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_11); __pyx_t_11 = 0; + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; + } else + #endif + #if CYTHON_FAST_PYCCALL + if (__Pyx_PyFastCFunction_Check(__pyx_t_8)) { + PyObject *__pyx_temp[3] = {__pyx_t_11, __pyx_t_9, __pyx_t_10}; + __pyx_t_1 = __Pyx_PyCFunction_FastCall(__pyx_t_8, __pyx_temp+1-__pyx_t_12, 2+__pyx_t_12); if (unlikely(!__pyx_t_1)) __PYX_ERR(22, 41, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_11); __pyx_t_11 = 0; + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; + } else + #endif + { + __pyx_t_13 = PyTuple_New(2+__pyx_t_12); if (unlikely(!__pyx_t_13)) __PYX_ERR(22, 41, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_13); + if (__pyx_t_11) { + __Pyx_GIVEREF(__pyx_t_11); PyTuple_SET_ITEM(__pyx_t_13, 0, __pyx_t_11); __pyx_t_11 = NULL; + } + __Pyx_GIVEREF(__pyx_t_9); + PyTuple_SET_ITEM(__pyx_t_13, 0+__pyx_t_12, __pyx_t_9); + __Pyx_GIVEREF(__pyx_t_10); + PyTuple_SET_ITEM(__pyx_t_13, 1+__pyx_t_12, __pyx_t_10); + __pyx_t_9 = 0; + __pyx_t_10 = 0; + __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_8, __pyx_t_13, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(22, 41, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0; + } + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + + /* "asyncpg/protocol/codecs/record.pyx":39 + * elem_codec = settings.get_data_codec(elem_typ) + * if elem_codec is None or not elem_codec.has_decoder(): + * raise RuntimeError( # <<<<<<<<<<<<<< + * 'no decoder for composite type element in ' + * 'position {} of type OID {}'.format(i, elem_typ)) + */ + __pyx_t_8 = PyTuple_New(1); if (unlikely(!__pyx_t_8)) __PYX_ERR(22, 39, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __Pyx_GIVEREF(__pyx_t_1); + PyTuple_SET_ITEM(__pyx_t_8, 0, __pyx_t_1); + __pyx_t_1 = 0; + __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_RuntimeError, __pyx_t_8, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(22, 39, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + __Pyx_Raise(__pyx_t_1, 0, 0, 0); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __PYX_ERR(22, 39, __pyx_L1_error) + + /* "asyncpg/protocol/codecs/record.pyx":38 + * else: + * elem_codec = settings.get_data_codec(elem_typ) + * if elem_codec is None or not elem_codec.has_decoder(): # <<<<<<<<<<<<<< + * raise RuntimeError( + * 'no decoder for composite type element in ' + */ + } + + /* "asyncpg/protocol/codecs/record.pyx":43 + * 'position {} of type OID {}'.format(i, elem_typ)) + * elem = elem_codec.decode(settings, + * elem_buf.slice_from(buf, elem_len)) # <<<<<<<<<<<<<< + * + * cpython.Py_INCREF(elem) + */ + __pyx_t_1 = ((PyObject *)__pyx_f_7asyncpg_8protocol_8protocol_14FastReadBuffer_slice_from(__pyx_v_elem_buf, __pyx_v_buf, __pyx_v_elem_len)); if (unlikely(!__pyx_t_1)) __PYX_ERR(22, 43, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + + /* "asyncpg/protocol/codecs/record.pyx":42 + * 'no decoder for composite type element in ' + * 'position {} of type OID {}'.format(i, elem_typ)) + * elem = elem_codec.decode(settings, # <<<<<<<<<<<<<< + * elem_buf.slice_from(buf, elem_len)) + * + */ + __pyx_t_8 = __pyx_f_7asyncpg_8protocol_8protocol_5Codec_decode(__pyx_v_elem_codec, __pyx_v_settings, ((struct __pyx_obj_7asyncpg_8protocol_8protocol_FastReadBuffer *)__pyx_t_1)); if (unlikely(!__pyx_t_8)) __PYX_ERR(22, 42, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_XDECREF_SET(__pyx_v_elem, __pyx_t_8); + __pyx_t_8 = 0; + } + __pyx_L5:; + + /* "asyncpg/protocol/codecs/record.pyx":45 + * elem_buf.slice_from(buf, elem_len)) + * + * cpython.Py_INCREF(elem) # <<<<<<<<<<<<<< + * cpython.PyTuple_SET_ITEM(result, i, elem) + * + */ + Py_INCREF(__pyx_v_elem); + + /* "asyncpg/protocol/codecs/record.pyx":46 + * + * cpython.Py_INCREF(elem) + * cpython.PyTuple_SET_ITEM(result, i, elem) # <<<<<<<<<<<<<< + * + * return result + */ + PyTuple_SET_ITEM(__pyx_v_result, __pyx_v_i, __pyx_v_elem); + } + + /* "asyncpg/protocol/codecs/record.pyx":48 + * cpython.PyTuple_SET_ITEM(result, i, elem) + * + * return result # <<<<<<<<<<<<<< + * + * + */ + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(__pyx_v_result); + __pyx_r = __pyx_v_result; + goto __pyx_L0; + + /* "asyncpg/protocol/codecs/record.pyx":17 + * + * + * cdef anonymous_record_decode(ConnectionSettings settings, FastReadBuffer buf): # <<<<<<<<<<<<<< + * cdef: + * tuple result + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_8); + __Pyx_XDECREF(__pyx_t_9); + __Pyx_XDECREF(__pyx_t_10); + __Pyx_XDECREF(__pyx_t_11); + __Pyx_XDECREF(__pyx_t_13); + __Pyx_AddTraceback("asyncpg.protocol.protocol.anonymous_record_decode", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XDECREF(__pyx_v_result); + __Pyx_XDECREF((PyObject *)__pyx_v_elem_codec); + __Pyx_XDECREF((PyObject *)__pyx_v_elem_buf); + __Pyx_XDECREF(__pyx_v_elem); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "asyncpg/protocol/codecs/record.pyx":51 + * + * + * cdef init_record_codecs(): # <<<<<<<<<<<<<< + * register_core_codec(RECORDOID, + * NULL, + */ + +static PyObject *__pyx_f_7asyncpg_8protocol_8protocol_init_record_codecs(void) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + __Pyx_RefNannySetupContext("init_record_codecs", 0); + + /* "asyncpg/protocol/codecs/record.pyx":52 + * + * cdef init_record_codecs(): + * register_core_codec(RECORDOID, # <<<<<<<<<<<<<< + * NULL, + * &anonymous_record_decode, + */ + __pyx_t_1 = __pyx_f_7asyncpg_8protocol_8protocol_register_core_codec(0x8C9, ((__pyx_t_7asyncpg_8protocol_8protocol_encode_func)NULL), ((__pyx_t_7asyncpg_8protocol_8protocol_decode_func)(&__pyx_f_7asyncpg_8protocol_8protocol_anonymous_record_decode)), __pyx_e_7asyncpg_8protocol_8protocol_PG_FORMAT_BINARY); if (unlikely(!__pyx_t_1)) __PYX_ERR(22, 52, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "asyncpg/protocol/codecs/record.pyx":51 + * + * + * cdef init_record_codecs(): # <<<<<<<<<<<<<< + * register_core_codec(RECORDOID, + * NULL, + */ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("asyncpg.protocol.protocol.init_record_codecs", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "asyncpg/protocol/codecs/hstore.pyx":8 + * + * + * cdef hstore_encode(ConnectionSettings settings, WriteBuffer buf, obj): # <<<<<<<<<<<<<< + * cdef: + * char *str + */ + +static PyObject *__pyx_f_7asyncpg_8protocol_8protocol_hstore_encode(struct __pyx_obj_7asyncpg_8protocol_8protocol_ConnectionSettings *__pyx_v_settings, struct __pyx_obj_7asyncpg_8protocol_8protocol_WriteBuffer *__pyx_v_buf, PyObject *__pyx_v_obj) { + char *__pyx_v_str; + Py_ssize_t __pyx_v_size; + Py_ssize_t __pyx_v_count; + PyObject *__pyx_v_items = 0; + struct __pyx_obj_7asyncpg_8protocol_8protocol_WriteBuffer *__pyx_v_item_buf = 0; + PyObject *__pyx_v_k = NULL; + PyObject *__pyx_v_v = NULL; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + Py_ssize_t __pyx_t_2; + int __pyx_t_3; + int __pyx_t_4; + PyObject *__pyx_t_5 = NULL; + PyObject *__pyx_t_6 = NULL; + PyObject *(*__pyx_t_7)(PyObject *); + PyObject *__pyx_t_8 = NULL; + PyObject *__pyx_t_9 = NULL; + PyObject *(*__pyx_t_10)(PyObject *); + int32_t __pyx_t_11; + __Pyx_RefNannySetupContext("hstore_encode", 0); + + /* "asyncpg/protocol/codecs/hstore.pyx":14 + * ssize_t count + * object items + * WriteBuffer item_buf = WriteBuffer.new() # <<<<<<<<<<<<<< + * + * count = len(obj) + */ + __pyx_t_1 = ((PyObject *)__pyx_f_7asyncpg_8protocol_8protocol_11WriteBuffer_new()); if (unlikely(!__pyx_t_1)) __PYX_ERR(23, 14, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_v_item_buf = ((struct __pyx_obj_7asyncpg_8protocol_8protocol_WriteBuffer *)__pyx_t_1); + __pyx_t_1 = 0; + + /* "asyncpg/protocol/codecs/hstore.pyx":16 + * WriteBuffer item_buf = WriteBuffer.new() + * + * count = len(obj) # <<<<<<<<<<<<<< + * if count > _MAXINT32: + * raise ValueError('hstore value is too large') + */ + __pyx_t_2 = PyObject_Length(__pyx_v_obj); if (unlikely(__pyx_t_2 == -1)) __PYX_ERR(23, 16, __pyx_L1_error) + __pyx_v_count = __pyx_t_2; + + /* "asyncpg/protocol/codecs/hstore.pyx":17 + * + * count = len(obj) + * if count > _MAXINT32: # <<<<<<<<<<<<<< + * raise ValueError('hstore value is too large') + * item_buf.write_int32(count) + */ + __pyx_t_3 = ((__pyx_v_count > 0x7FFFFFFF) != 0); + if (__pyx_t_3) { + + /* "asyncpg/protocol/codecs/hstore.pyx":18 + * count = len(obj) + * if count > _MAXINT32: + * raise ValueError('hstore value is too large') # <<<<<<<<<<<<<< + * item_buf.write_int32(count) + * + */ + __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__51, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(23, 18, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_Raise(__pyx_t_1, 0, 0, 0); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __PYX_ERR(23, 18, __pyx_L1_error) + + /* "asyncpg/protocol/codecs/hstore.pyx":17 + * + * count = len(obj) + * if count > _MAXINT32: # <<<<<<<<<<<<<< + * raise ValueError('hstore value is too large') + * item_buf.write_int32(count) + */ + } + + /* "asyncpg/protocol/codecs/hstore.pyx":19 + * if count > _MAXINT32: + * raise ValueError('hstore value is too large') + * item_buf.write_int32(count) # <<<<<<<<<<<<<< + * + * if hasattr(obj, 'items'): + */ + __pyx_t_1 = __pyx_f_7asyncpg_8protocol_8protocol_11WriteBuffer_write_int32(__pyx_v_item_buf, ((int32_t)__pyx_v_count)); if (unlikely(!__pyx_t_1)) __PYX_ERR(23, 19, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "asyncpg/protocol/codecs/hstore.pyx":21 + * item_buf.write_int32(count) + * + * if hasattr(obj, 'items'): # <<<<<<<<<<<<<< + * items = obj.items() + * else: + */ + __pyx_t_3 = PyObject_HasAttr(__pyx_v_obj, __pyx_n_u_items); if (unlikely(__pyx_t_3 == -1)) __PYX_ERR(23, 21, __pyx_L1_error) + __pyx_t_4 = (__pyx_t_3 != 0); + if (__pyx_t_4) { + + /* "asyncpg/protocol/codecs/hstore.pyx":22 + * + * if hasattr(obj, 'items'): + * items = obj.items() # <<<<<<<<<<<<<< + * else: + * items = obj + */ + __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_v_obj, __pyx_n_s_items); if (unlikely(!__pyx_t_5)) __PYX_ERR(23, 22, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_6 = NULL; + if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_5))) { + __pyx_t_6 = PyMethod_GET_SELF(__pyx_t_5); + if (likely(__pyx_t_6)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_5); + __Pyx_INCREF(__pyx_t_6); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_5, function); + } + } + if (__pyx_t_6) { + __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_t_5, __pyx_t_6); if (unlikely(!__pyx_t_1)) __PYX_ERR(23, 22, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + } else { + __pyx_t_1 = __Pyx_PyObject_CallNoArg(__pyx_t_5); if (unlikely(!__pyx_t_1)) __PYX_ERR(23, 22, __pyx_L1_error) + } + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __pyx_v_items = __pyx_t_1; + __pyx_t_1 = 0; + + /* "asyncpg/protocol/codecs/hstore.pyx":21 + * item_buf.write_int32(count) + * + * if hasattr(obj, 'items'): # <<<<<<<<<<<<<< + * items = obj.items() + * else: + */ + goto __pyx_L4; + } + + /* "asyncpg/protocol/codecs/hstore.pyx":24 + * items = obj.items() + * else: + * items = obj # <<<<<<<<<<<<<< + * + * for k, v in items: + */ + /*else*/ { + __Pyx_INCREF(__pyx_v_obj); + __pyx_v_items = __pyx_v_obj; + } + __pyx_L4:; + + /* "asyncpg/protocol/codecs/hstore.pyx":26 + * items = obj + * + * for k, v in items: # <<<<<<<<<<<<<< + * if k is None: + * raise ValueError('null value not allowed in hstore key') + */ + if (likely(PyList_CheckExact(__pyx_v_items)) || PyTuple_CheckExact(__pyx_v_items)) { + __pyx_t_1 = __pyx_v_items; __Pyx_INCREF(__pyx_t_1); __pyx_t_2 = 0; + __pyx_t_7 = NULL; + } else { + __pyx_t_2 = -1; __pyx_t_1 = PyObject_GetIter(__pyx_v_items); if (unlikely(!__pyx_t_1)) __PYX_ERR(23, 26, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_7 = Py_TYPE(__pyx_t_1)->tp_iternext; if (unlikely(!__pyx_t_7)) __PYX_ERR(23, 26, __pyx_L1_error) + } + for (;;) { + if (likely(!__pyx_t_7)) { + if (likely(PyList_CheckExact(__pyx_t_1))) { + if (__pyx_t_2 >= PyList_GET_SIZE(__pyx_t_1)) break; + #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + __pyx_t_5 = PyList_GET_ITEM(__pyx_t_1, __pyx_t_2); __Pyx_INCREF(__pyx_t_5); __pyx_t_2++; if (unlikely(0 < 0)) __PYX_ERR(23, 26, __pyx_L1_error) + #else + __pyx_t_5 = PySequence_ITEM(__pyx_t_1, __pyx_t_2); __pyx_t_2++; if (unlikely(!__pyx_t_5)) __PYX_ERR(23, 26, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + #endif + } else { + if (__pyx_t_2 >= PyTuple_GET_SIZE(__pyx_t_1)) break; + #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + __pyx_t_5 = PyTuple_GET_ITEM(__pyx_t_1, __pyx_t_2); __Pyx_INCREF(__pyx_t_5); __pyx_t_2++; if (unlikely(0 < 0)) __PYX_ERR(23, 26, __pyx_L1_error) + #else + __pyx_t_5 = PySequence_ITEM(__pyx_t_1, __pyx_t_2); __pyx_t_2++; if (unlikely(!__pyx_t_5)) __PYX_ERR(23, 26, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + #endif + } + } else { + __pyx_t_5 = __pyx_t_7(__pyx_t_1); + if (unlikely(!__pyx_t_5)) { + PyObject* exc_type = PyErr_Occurred(); + if (exc_type) { + if (likely(exc_type == PyExc_StopIteration || PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) PyErr_Clear(); + else __PYX_ERR(23, 26, __pyx_L1_error) + } + break; + } + __Pyx_GOTREF(__pyx_t_5); + } + if ((likely(PyTuple_CheckExact(__pyx_t_5))) || (PyList_CheckExact(__pyx_t_5))) { + PyObject* sequence = __pyx_t_5; + #if !CYTHON_COMPILING_IN_PYPY + Py_ssize_t size = Py_SIZE(sequence); + #else + Py_ssize_t size = PySequence_Size(sequence); + #endif + if (unlikely(size != 2)) { + if (size > 2) __Pyx_RaiseTooManyValuesError(2); + else if (size >= 0) __Pyx_RaiseNeedMoreValuesError(size); + __PYX_ERR(23, 26, __pyx_L1_error) + } + #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + if (likely(PyTuple_CheckExact(sequence))) { + __pyx_t_6 = PyTuple_GET_ITEM(sequence, 0); + __pyx_t_8 = PyTuple_GET_ITEM(sequence, 1); + } else { + __pyx_t_6 = PyList_GET_ITEM(sequence, 0); + __pyx_t_8 = PyList_GET_ITEM(sequence, 1); + } + __Pyx_INCREF(__pyx_t_6); + __Pyx_INCREF(__pyx_t_8); + #else + __pyx_t_6 = PySequence_ITEM(sequence, 0); if (unlikely(!__pyx_t_6)) __PYX_ERR(23, 26, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_8 = PySequence_ITEM(sequence, 1); if (unlikely(!__pyx_t_8)) __PYX_ERR(23, 26, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + #endif + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + } else { + Py_ssize_t index = -1; + __pyx_t_9 = PyObject_GetIter(__pyx_t_5); if (unlikely(!__pyx_t_9)) __PYX_ERR(23, 26, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_9); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __pyx_t_10 = Py_TYPE(__pyx_t_9)->tp_iternext; + index = 0; __pyx_t_6 = __pyx_t_10(__pyx_t_9); if (unlikely(!__pyx_t_6)) goto __pyx_L7_unpacking_failed; + __Pyx_GOTREF(__pyx_t_6); + index = 1; __pyx_t_8 = __pyx_t_10(__pyx_t_9); if (unlikely(!__pyx_t_8)) goto __pyx_L7_unpacking_failed; + __Pyx_GOTREF(__pyx_t_8); + if (__Pyx_IternextUnpackEndCheck(__pyx_t_10(__pyx_t_9), 2) < 0) __PYX_ERR(23, 26, __pyx_L1_error) + __pyx_t_10 = NULL; + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + goto __pyx_L8_unpacking_done; + __pyx_L7_unpacking_failed:; + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + __pyx_t_10 = NULL; + if (__Pyx_IterFinish() == 0) __Pyx_RaiseNeedMoreValuesError(index); + __PYX_ERR(23, 26, __pyx_L1_error) + __pyx_L8_unpacking_done:; + } + __Pyx_XDECREF_SET(__pyx_v_k, __pyx_t_6); + __pyx_t_6 = 0; + __Pyx_XDECREF_SET(__pyx_v_v, __pyx_t_8); + __pyx_t_8 = 0; + + /* "asyncpg/protocol/codecs/hstore.pyx":27 + * + * for k, v in items: + * if k is None: # <<<<<<<<<<<<<< + * raise ValueError('null value not allowed in hstore key') + * as_pg_string_and_size(settings, k, &str, &size) + */ + __pyx_t_4 = (__pyx_v_k == Py_None); + __pyx_t_3 = (__pyx_t_4 != 0); + if (__pyx_t_3) { + + /* "asyncpg/protocol/codecs/hstore.pyx":28 + * for k, v in items: + * if k is None: + * raise ValueError('null value not allowed in hstore key') # <<<<<<<<<<<<<< + * as_pg_string_and_size(settings, k, &str, &size) + * item_buf.write_int32(size) + */ + __pyx_t_5 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__52, NULL); if (unlikely(!__pyx_t_5)) __PYX_ERR(23, 28, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_Raise(__pyx_t_5, 0, 0, 0); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __PYX_ERR(23, 28, __pyx_L1_error) + + /* "asyncpg/protocol/codecs/hstore.pyx":27 + * + * for k, v in items: + * if k is None: # <<<<<<<<<<<<<< + * raise ValueError('null value not allowed in hstore key') + * as_pg_string_and_size(settings, k, &str, &size) + */ + } + + /* "asyncpg/protocol/codecs/hstore.pyx":29 + * if k is None: + * raise ValueError('null value not allowed in hstore key') + * as_pg_string_and_size(settings, k, &str, &size) # <<<<<<<<<<<<<< + * item_buf.write_int32(size) + * item_buf.write_cstr(str, size) + */ + __pyx_t_5 = __pyx_f_7asyncpg_8protocol_8protocol_as_pg_string_and_size(__pyx_v_settings, __pyx_v_k, (&__pyx_v_str), (&__pyx_v_size)); if (unlikely(!__pyx_t_5)) __PYX_ERR(23, 29, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + + /* "asyncpg/protocol/codecs/hstore.pyx":30 + * raise ValueError('null value not allowed in hstore key') + * as_pg_string_and_size(settings, k, &str, &size) + * item_buf.write_int32(size) # <<<<<<<<<<<<<< + * item_buf.write_cstr(str, size) + * if v is None: + */ + __pyx_t_5 = __pyx_f_7asyncpg_8protocol_8protocol_11WriteBuffer_write_int32(__pyx_v_item_buf, ((int32_t)__pyx_v_size)); if (unlikely(!__pyx_t_5)) __PYX_ERR(23, 30, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + + /* "asyncpg/protocol/codecs/hstore.pyx":31 + * as_pg_string_and_size(settings, k, &str, &size) + * item_buf.write_int32(size) + * item_buf.write_cstr(str, size) # <<<<<<<<<<<<<< + * if v is None: + * item_buf.write_int32(-1) + */ + __pyx_t_5 = __pyx_f_7asyncpg_8protocol_8protocol_11WriteBuffer_write_cstr(__pyx_v_item_buf, __pyx_v_str, __pyx_v_size); if (unlikely(!__pyx_t_5)) __PYX_ERR(23, 31, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + + /* "asyncpg/protocol/codecs/hstore.pyx":32 + * item_buf.write_int32(size) + * item_buf.write_cstr(str, size) + * if v is None: # <<<<<<<<<<<<<< + * item_buf.write_int32(-1) + * else: + */ + __pyx_t_3 = (__pyx_v_v == Py_None); + __pyx_t_4 = (__pyx_t_3 != 0); + if (__pyx_t_4) { + + /* "asyncpg/protocol/codecs/hstore.pyx":33 + * item_buf.write_cstr(str, size) + * if v is None: + * item_buf.write_int32(-1) # <<<<<<<<<<<<<< + * else: + * as_pg_string_and_size(settings, v, &str, &size) + */ + __pyx_t_5 = __pyx_f_7asyncpg_8protocol_8protocol_11WriteBuffer_write_int32(__pyx_v_item_buf, ((int32_t)-1L)); if (unlikely(!__pyx_t_5)) __PYX_ERR(23, 33, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + + /* "asyncpg/protocol/codecs/hstore.pyx":32 + * item_buf.write_int32(size) + * item_buf.write_cstr(str, size) + * if v is None: # <<<<<<<<<<<<<< + * item_buf.write_int32(-1) + * else: + */ + goto __pyx_L10; + } + + /* "asyncpg/protocol/codecs/hstore.pyx":35 + * item_buf.write_int32(-1) + * else: + * as_pg_string_and_size(settings, v, &str, &size) # <<<<<<<<<<<<<< + * item_buf.write_int32(size) + * item_buf.write_cstr(str, size) + */ + /*else*/ { + __pyx_t_5 = __pyx_f_7asyncpg_8protocol_8protocol_as_pg_string_and_size(__pyx_v_settings, __pyx_v_v, (&__pyx_v_str), (&__pyx_v_size)); if (unlikely(!__pyx_t_5)) __PYX_ERR(23, 35, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + + /* "asyncpg/protocol/codecs/hstore.pyx":36 + * else: + * as_pg_string_and_size(settings, v, &str, &size) + * item_buf.write_int32(size) # <<<<<<<<<<<<<< + * item_buf.write_cstr(str, size) + * + */ + __pyx_t_5 = __pyx_f_7asyncpg_8protocol_8protocol_11WriteBuffer_write_int32(__pyx_v_item_buf, ((int32_t)__pyx_v_size)); if (unlikely(!__pyx_t_5)) __PYX_ERR(23, 36, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + + /* "asyncpg/protocol/codecs/hstore.pyx":37 + * as_pg_string_and_size(settings, v, &str, &size) + * item_buf.write_int32(size) + * item_buf.write_cstr(str, size) # <<<<<<<<<<<<<< + * + * buf.write_int32(item_buf.len()) + */ + __pyx_t_5 = __pyx_f_7asyncpg_8protocol_8protocol_11WriteBuffer_write_cstr(__pyx_v_item_buf, __pyx_v_str, __pyx_v_size); if (unlikely(!__pyx_t_5)) __PYX_ERR(23, 37, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + } + __pyx_L10:; + + /* "asyncpg/protocol/codecs/hstore.pyx":26 + * items = obj + * + * for k, v in items: # <<<<<<<<<<<<<< + * if k is None: + * raise ValueError('null value not allowed in hstore key') + */ + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "asyncpg/protocol/codecs/hstore.pyx":39 + * item_buf.write_cstr(str, size) + * + * buf.write_int32(item_buf.len()) # <<<<<<<<<<<<<< + * buf.write_buffer(item_buf) + * + */ + __pyx_t_1 = __pyx_f_7asyncpg_8protocol_8protocol_11WriteBuffer_len(__pyx_v_item_buf); if (unlikely(!__pyx_t_1)) __PYX_ERR(23, 39, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_11 = __Pyx_PyInt_As_int32_t(__pyx_t_1); if (unlikely((__pyx_t_11 == ((int32_t)-1)) && PyErr_Occurred())) __PYX_ERR(23, 39, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_1 = __pyx_f_7asyncpg_8protocol_8protocol_11WriteBuffer_write_int32(__pyx_v_buf, __pyx_t_11); if (unlikely(!__pyx_t_1)) __PYX_ERR(23, 39, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "asyncpg/protocol/codecs/hstore.pyx":40 + * + * buf.write_int32(item_buf.len()) + * buf.write_buffer(item_buf) # <<<<<<<<<<<<<< + * + * + */ + __pyx_t_1 = __pyx_f_7asyncpg_8protocol_8protocol_11WriteBuffer_write_buffer(__pyx_v_buf, __pyx_v_item_buf); if (unlikely(!__pyx_t_1)) __PYX_ERR(23, 40, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "asyncpg/protocol/codecs/hstore.pyx":8 + * + * + * cdef hstore_encode(ConnectionSettings settings, WriteBuffer buf, obj): # <<<<<<<<<<<<<< + * cdef: + * char *str + */ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_XDECREF(__pyx_t_6); + __Pyx_XDECREF(__pyx_t_8); + __Pyx_XDECREF(__pyx_t_9); + __Pyx_AddTraceback("asyncpg.protocol.protocol.hstore_encode", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XDECREF(__pyx_v_items); + __Pyx_XDECREF((PyObject *)__pyx_v_item_buf); + __Pyx_XDECREF(__pyx_v_k); + __Pyx_XDECREF(__pyx_v_v); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "asyncpg/protocol/codecs/hstore.pyx":43 + * + * + * cdef hstore_decode(ConnectionSettings settings, FastReadBuffer buf): # <<<<<<<<<<<<<< + * cdef: + * dict result + */ + +static PyObject *__pyx_f_7asyncpg_8protocol_8protocol_hstore_decode(struct __pyx_obj_7asyncpg_8protocol_8protocol_ConnectionSettings *__pyx_v_settings, struct __pyx_obj_7asyncpg_8protocol_8protocol_FastReadBuffer *__pyx_v_buf) { + PyObject *__pyx_v_result = 0; + uint32_t __pyx_v_elem_count; + int32_t __pyx_v_elem_len; + CYTHON_UNUSED uint32_t __pyx_v_i; + PyObject *__pyx_v_k = 0; + PyObject *__pyx_v_v = 0; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + char const *__pyx_t_2; + int __pyx_t_3; + uint32_t __pyx_t_4; + uint32_t __pyx_t_5; + __Pyx_RefNannySetupContext("hstore_decode", 0); + + /* "asyncpg/protocol/codecs/hstore.pyx":52 + * str v + * + * result = {} # <<<<<<<<<<<<<< + * + * elem_count = hton.unpack_int32(buf.read(4)) + */ + __pyx_t_1 = PyDict_New(); if (unlikely(!__pyx_t_1)) __PYX_ERR(23, 52, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_v_result = ((PyObject*)__pyx_t_1); + __pyx_t_1 = 0; + + /* "asyncpg/protocol/codecs/hstore.pyx":54 + * result = {} + * + * elem_count = hton.unpack_int32(buf.read(4)) # <<<<<<<<<<<<<< + * if elem_count == 0: + * return result + */ + __pyx_t_2 = __pyx_f_7asyncpg_8protocol_8protocol_14FastReadBuffer_read(__pyx_v_buf, 4); if (unlikely(__pyx_t_2 == NULL)) __PYX_ERR(23, 54, __pyx_L1_error) + __pyx_v_elem_count = ((uint32_t)__pyx_f_7asyncpg_8protocol_4hton_unpack_int32(__pyx_t_2)); + + /* "asyncpg/protocol/codecs/hstore.pyx":55 + * + * elem_count = hton.unpack_int32(buf.read(4)) + * if elem_count == 0: # <<<<<<<<<<<<<< + * return result + * + */ + __pyx_t_3 = ((__pyx_v_elem_count == 0) != 0); + if (__pyx_t_3) { + + /* "asyncpg/protocol/codecs/hstore.pyx":56 + * elem_count = hton.unpack_int32(buf.read(4)) + * if elem_count == 0: + * return result # <<<<<<<<<<<<<< + * + * for i in range(elem_count): + */ + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(__pyx_v_result); + __pyx_r = __pyx_v_result; + goto __pyx_L0; + + /* "asyncpg/protocol/codecs/hstore.pyx":55 + * + * elem_count = hton.unpack_int32(buf.read(4)) + * if elem_count == 0: # <<<<<<<<<<<<<< + * return result + * + */ + } + + /* "asyncpg/protocol/codecs/hstore.pyx":58 + * return result + * + * for i in range(elem_count): # <<<<<<<<<<<<<< + * elem_len = hton.unpack_int32(buf.read(4)) + * if elem_len < 0: + */ + __pyx_t_4 = __pyx_v_elem_count; + for (__pyx_t_5 = 0; __pyx_t_5 < __pyx_t_4; __pyx_t_5+=1) { + __pyx_v_i = __pyx_t_5; + + /* "asyncpg/protocol/codecs/hstore.pyx":59 + * + * for i in range(elem_count): + * elem_len = hton.unpack_int32(buf.read(4)) # <<<<<<<<<<<<<< + * if elem_len < 0: + * raise ValueError('null value not allowed in hstore key') + */ + __pyx_t_2 = __pyx_f_7asyncpg_8protocol_8protocol_14FastReadBuffer_read(__pyx_v_buf, 4); if (unlikely(__pyx_t_2 == NULL)) __PYX_ERR(23, 59, __pyx_L1_error) + __pyx_v_elem_len = __pyx_f_7asyncpg_8protocol_4hton_unpack_int32(__pyx_t_2); + + /* "asyncpg/protocol/codecs/hstore.pyx":60 + * for i in range(elem_count): + * elem_len = hton.unpack_int32(buf.read(4)) + * if elem_len < 0: # <<<<<<<<<<<<<< + * raise ValueError('null value not allowed in hstore key') + * + */ + __pyx_t_3 = ((__pyx_v_elem_len < 0) != 0); + if (__pyx_t_3) { + + /* "asyncpg/protocol/codecs/hstore.pyx":61 + * elem_len = hton.unpack_int32(buf.read(4)) + * if elem_len < 0: + * raise ValueError('null value not allowed in hstore key') # <<<<<<<<<<<<<< + * + * k = decode_pg_string(settings, buf.read(elem_len), elem_len) + */ + __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__53, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(23, 61, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_Raise(__pyx_t_1, 0, 0, 0); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __PYX_ERR(23, 61, __pyx_L1_error) + + /* "asyncpg/protocol/codecs/hstore.pyx":60 + * for i in range(elem_count): + * elem_len = hton.unpack_int32(buf.read(4)) + * if elem_len < 0: # <<<<<<<<<<<<<< + * raise ValueError('null value not allowed in hstore key') + * + */ + } + + /* "asyncpg/protocol/codecs/hstore.pyx":63 + * raise ValueError('null value not allowed in hstore key') + * + * k = decode_pg_string(settings, buf.read(elem_len), elem_len) # <<<<<<<<<<<<<< + * + * elem_len = hton.unpack_int32(buf.read(4)) + */ + __pyx_t_2 = __pyx_f_7asyncpg_8protocol_8protocol_14FastReadBuffer_read(__pyx_v_buf, __pyx_v_elem_len); if (unlikely(__pyx_t_2 == NULL)) __PYX_ERR(23, 63, __pyx_L1_error) + __pyx_t_1 = __pyx_f_7asyncpg_8protocol_8protocol_decode_pg_string(__pyx_v_settings, __pyx_t_2, __pyx_v_elem_len); if (unlikely(!__pyx_t_1)) __PYX_ERR(23, 63, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (!(likely(PyUnicode_CheckExact(__pyx_t_1))||((__pyx_t_1) == Py_None)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "unicode", Py_TYPE(__pyx_t_1)->tp_name), 0))) __PYX_ERR(23, 63, __pyx_L1_error) + __Pyx_XDECREF_SET(__pyx_v_k, ((PyObject*)__pyx_t_1)); + __pyx_t_1 = 0; + + /* "asyncpg/protocol/codecs/hstore.pyx":65 + * k = decode_pg_string(settings, buf.read(elem_len), elem_len) + * + * elem_len = hton.unpack_int32(buf.read(4)) # <<<<<<<<<<<<<< + * if elem_len < 0: + * v = None + */ + __pyx_t_2 = __pyx_f_7asyncpg_8protocol_8protocol_14FastReadBuffer_read(__pyx_v_buf, 4); if (unlikely(__pyx_t_2 == NULL)) __PYX_ERR(23, 65, __pyx_L1_error) + __pyx_v_elem_len = __pyx_f_7asyncpg_8protocol_4hton_unpack_int32(__pyx_t_2); + + /* "asyncpg/protocol/codecs/hstore.pyx":66 + * + * elem_len = hton.unpack_int32(buf.read(4)) + * if elem_len < 0: # <<<<<<<<<<<<<< + * v = None + * else: + */ + __pyx_t_3 = ((__pyx_v_elem_len < 0) != 0); + if (__pyx_t_3) { + + /* "asyncpg/protocol/codecs/hstore.pyx":67 + * elem_len = hton.unpack_int32(buf.read(4)) + * if elem_len < 0: + * v = None # <<<<<<<<<<<<<< + * else: + * v = decode_pg_string(settings, buf.read(elem_len), elem_len) + */ + __Pyx_INCREF(Py_None); + __Pyx_XDECREF_SET(__pyx_v_v, ((PyObject*)Py_None)); + + /* "asyncpg/protocol/codecs/hstore.pyx":66 + * + * elem_len = hton.unpack_int32(buf.read(4)) + * if elem_len < 0: # <<<<<<<<<<<<<< + * v = None + * else: + */ + goto __pyx_L7; + } + + /* "asyncpg/protocol/codecs/hstore.pyx":69 + * v = None + * else: + * v = decode_pg_string(settings, buf.read(elem_len), elem_len) # <<<<<<<<<<<<<< + * + * result[k] = v + */ + /*else*/ { + __pyx_t_2 = __pyx_f_7asyncpg_8protocol_8protocol_14FastReadBuffer_read(__pyx_v_buf, __pyx_v_elem_len); if (unlikely(__pyx_t_2 == NULL)) __PYX_ERR(23, 69, __pyx_L1_error) + __pyx_t_1 = __pyx_f_7asyncpg_8protocol_8protocol_decode_pg_string(__pyx_v_settings, __pyx_t_2, __pyx_v_elem_len); if (unlikely(!__pyx_t_1)) __PYX_ERR(23, 69, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (!(likely(PyUnicode_CheckExact(__pyx_t_1))||((__pyx_t_1) == Py_None)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "unicode", Py_TYPE(__pyx_t_1)->tp_name), 0))) __PYX_ERR(23, 69, __pyx_L1_error) + __Pyx_XDECREF_SET(__pyx_v_v, ((PyObject*)__pyx_t_1)); + __pyx_t_1 = 0; + } + __pyx_L7:; + + /* "asyncpg/protocol/codecs/hstore.pyx":71 + * v = decode_pg_string(settings, buf.read(elem_len), elem_len) + * + * result[k] = v # <<<<<<<<<<<<<< + * + * return result + */ + if (unlikely(PyDict_SetItem(__pyx_v_result, __pyx_v_k, __pyx_v_v) < 0)) __PYX_ERR(23, 71, __pyx_L1_error) + } + + /* "asyncpg/protocol/codecs/hstore.pyx":73 + * result[k] = v + * + * return result # <<<<<<<<<<<<<< + * + * + */ + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(__pyx_v_result); + __pyx_r = __pyx_v_result; + goto __pyx_L0; + + /* "asyncpg/protocol/codecs/hstore.pyx":43 + * + * + * cdef hstore_decode(ConnectionSettings settings, FastReadBuffer buf): # <<<<<<<<<<<<<< + * cdef: + * dict result + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("asyncpg.protocol.protocol.hstore_decode", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XDECREF(__pyx_v_result); + __Pyx_XDECREF(__pyx_v_k); + __Pyx_XDECREF(__pyx_v_v); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "asyncpg/protocol/codecs/hstore.pyx":76 + * + * + * cdef init_hstore_codecs(): # <<<<<<<<<<<<<< + * register_extra_codec('pg_contrib.hstore', + * &hstore_encode, + */ + +static PyObject *__pyx_f_7asyncpg_8protocol_8protocol_init_hstore_codecs(void) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + __Pyx_RefNannySetupContext("init_hstore_codecs", 0); + + /* "asyncpg/protocol/codecs/hstore.pyx":77 + * + * cdef init_hstore_codecs(): + * register_extra_codec('pg_contrib.hstore', # <<<<<<<<<<<<<< + * &hstore_encode, + * &hstore_decode, + */ + __pyx_t_1 = __pyx_f_7asyncpg_8protocol_8protocol_register_extra_codec(__pyx_kp_u_pg_contrib_hstore, ((__pyx_t_7asyncpg_8protocol_8protocol_encode_func)(&__pyx_f_7asyncpg_8protocol_8protocol_hstore_encode)), ((__pyx_t_7asyncpg_8protocol_8protocol_decode_func)(&__pyx_f_7asyncpg_8protocol_8protocol_hstore_decode)), __pyx_e_7asyncpg_8protocol_8protocol_PG_FORMAT_BINARY); if (unlikely(!__pyx_t_1)) __PYX_ERR(23, 77, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "asyncpg/protocol/codecs/hstore.pyx":76 + * + * + * cdef init_hstore_codecs(): # <<<<<<<<<<<<<< + * register_extra_codec('pg_contrib.hstore', + * &hstore_encode, + */ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("asyncpg.protocol.protocol.init_hstore_codecs", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "asyncpg/protocol/coreproto.pyx":13 + * cdef class CoreProtocol: + * + * def __init__(self, con_args): # <<<<<<<<<<<<<< + * self.buffer = ReadBuffer() + * self.user = con_args.get('user') + */ + +/* Python wrapper */ +static int __pyx_pw_7asyncpg_8protocol_8protocol_12CoreProtocol_1__init__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ +static int __pyx_pw_7asyncpg_8protocol_8protocol_12CoreProtocol_1__init__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { + PyObject *__pyx_v_con_args = 0; + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__init__ (wrapper)", 0); + { + static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_con_args,0}; + PyObject* values[1] = {0}; + if (unlikely(__pyx_kwds)) { + Py_ssize_t kw_args; + const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args); + switch (pos_args) { + case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = PyDict_Size(__pyx_kwds); + switch (pos_args) { + case 0: + if (likely((values[0] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_con_args)) != 0)) kw_args--; + else goto __pyx_L5_argtuple_error; + } + if (unlikely(kw_args > 0)) { + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "__init__") < 0)) __PYX_ERR(4, 13, __pyx_L3_error) + } + } else if (PyTuple_GET_SIZE(__pyx_args) != 1) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + } + __pyx_v_con_args = values[0]; + } + goto __pyx_L4_argument_unpacking_done; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("__init__", 1, 1, 1, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(4, 13, __pyx_L3_error) + __pyx_L3_error:; + __Pyx_AddTraceback("asyncpg.protocol.protocol.CoreProtocol.__init__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return -1; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_7asyncpg_8protocol_8protocol_12CoreProtocol___init__(((struct __pyx_obj_7asyncpg_8protocol_8protocol_CoreProtocol *)__pyx_v_self), __pyx_v_con_args); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_7asyncpg_8protocol_8protocol_12CoreProtocol___init__(struct __pyx_obj_7asyncpg_8protocol_8protocol_CoreProtocol *__pyx_v_self, PyObject *__pyx_v_con_args) { + int __pyx_r; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + __Pyx_RefNannySetupContext("__init__", 0); + + /* "asyncpg/protocol/coreproto.pyx":14 + * + * def __init__(self, con_args): + * self.buffer = ReadBuffer() # <<<<<<<<<<<<<< + * self.user = con_args.get('user') + * self.password = con_args.get('password') + */ + __pyx_t_1 = __Pyx_PyObject_Call(((PyObject *)__pyx_ptype_7asyncpg_8protocol_8protocol_ReadBuffer), __pyx_empty_tuple, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 14, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_GIVEREF(__pyx_t_1); + __Pyx_GOTREF(__pyx_v_self->buffer); + __Pyx_DECREF(((PyObject *)__pyx_v_self->buffer)); + __pyx_v_self->buffer = ((struct __pyx_obj_7asyncpg_8protocol_8protocol_ReadBuffer *)__pyx_t_1); + __pyx_t_1 = 0; + + /* "asyncpg/protocol/coreproto.pyx":15 + * def __init__(self, con_args): + * self.buffer = ReadBuffer() + * self.user = con_args.get('user') # <<<<<<<<<<<<<< + * self.password = con_args.get('password') + * self.auth_msg = None + */ + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_con_args, __pyx_n_s_get); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 15, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_tuple__54, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(4, 15, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + if (__Pyx_PyObject_SetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_user, __pyx_t_2) < 0) __PYX_ERR(4, 15, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "asyncpg/protocol/coreproto.pyx":16 + * self.buffer = ReadBuffer() + * self.user = con_args.get('user') + * self.password = con_args.get('password') # <<<<<<<<<<<<<< + * self.auth_msg = None + * self.con_args = con_args + */ + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_con_args, __pyx_n_s_get); if (unlikely(!__pyx_t_2)) __PYX_ERR(4, 16, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_tuple__55, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 16, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + if (__Pyx_PyObject_SetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_password, __pyx_t_1) < 0) __PYX_ERR(4, 16, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "asyncpg/protocol/coreproto.pyx":17 + * self.user = con_args.get('user') + * self.password = con_args.get('password') + * self.auth_msg = None # <<<<<<<<<<<<<< + * self.con_args = con_args + * self.transport = None + */ + if (__Pyx_PyObject_SetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_auth_msg, Py_None) < 0) __PYX_ERR(4, 17, __pyx_L1_error) + + /* "asyncpg/protocol/coreproto.pyx":18 + * self.password = con_args.get('password') + * self.auth_msg = None + * self.con_args = con_args # <<<<<<<<<<<<<< + * self.transport = None + * self.con_status = CONNECTION_BAD + */ + if (!(likely(PyDict_CheckExact(__pyx_v_con_args))||((__pyx_v_con_args) == Py_None)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "dict", Py_TYPE(__pyx_v_con_args)->tp_name), 0))) __PYX_ERR(4, 18, __pyx_L1_error) + __pyx_t_1 = __pyx_v_con_args; + __Pyx_INCREF(__pyx_t_1); + __Pyx_GIVEREF(__pyx_t_1); + __Pyx_GOTREF(__pyx_v_self->con_args); + __Pyx_DECREF(__pyx_v_self->con_args); + __pyx_v_self->con_args = ((PyObject*)__pyx_t_1); + __pyx_t_1 = 0; + + /* "asyncpg/protocol/coreproto.pyx":19 + * self.auth_msg = None + * self.con_args = con_args + * self.transport = None # <<<<<<<<<<<<<< + * self.con_status = CONNECTION_BAD + * self.state = PROTOCOL_IDLE + */ + __Pyx_INCREF(Py_None); + __Pyx_GIVEREF(Py_None); + __Pyx_GOTREF(__pyx_v_self->transport); + __Pyx_DECREF(__pyx_v_self->transport); + __pyx_v_self->transport = Py_None; + + /* "asyncpg/protocol/coreproto.pyx":20 + * self.con_args = con_args + * self.transport = None + * self.con_status = CONNECTION_BAD # <<<<<<<<<<<<<< + * self.state = PROTOCOL_IDLE + * self.xact_status = PQTRANS_IDLE + */ + __pyx_v_self->con_status = __pyx_e_7asyncpg_8protocol_8protocol_CONNECTION_BAD; + + /* "asyncpg/protocol/coreproto.pyx":21 + * self.transport = None + * self.con_status = CONNECTION_BAD + * self.state = PROTOCOL_IDLE # <<<<<<<<<<<<<< + * self.xact_status = PQTRANS_IDLE + * self.encoding = 'utf-8' + */ + __pyx_v_self->state = __pyx_e_7asyncpg_8protocol_8protocol_PROTOCOL_IDLE; + + /* "asyncpg/protocol/coreproto.pyx":22 + * self.con_status = CONNECTION_BAD + * self.state = PROTOCOL_IDLE + * self.xact_status = PQTRANS_IDLE # <<<<<<<<<<<<<< + * self.encoding = 'utf-8' + * + */ + __pyx_v_self->xact_status = __pyx_e_7asyncpg_8protocol_8protocol_PQTRANS_IDLE; + + /* "asyncpg/protocol/coreproto.pyx":23 + * self.state = PROTOCOL_IDLE + * self.xact_status = PQTRANS_IDLE + * self.encoding = 'utf-8' # <<<<<<<<<<<<<< + * + * self._skip_discard = False + */ + __Pyx_INCREF(__pyx_kp_u_utf_8); + __Pyx_GIVEREF(__pyx_kp_u_utf_8); + __Pyx_GOTREF(__pyx_v_self->encoding); + __Pyx_DECREF(__pyx_v_self->encoding); + __pyx_v_self->encoding = __pyx_kp_u_utf_8; + + /* "asyncpg/protocol/coreproto.pyx":25 + * self.encoding = 'utf-8' + * + * self._skip_discard = False # <<<<<<<<<<<<<< + * + * # executemany support data + */ + __pyx_v_self->_skip_discard = 0; + + /* "asyncpg/protocol/coreproto.pyx":28 + * + * # executemany support data + * self._execute_iter = None # <<<<<<<<<<<<<< + * self._execute_portal_name = None + * self._execute_stmt_name = None + */ + __Pyx_INCREF(Py_None); + __Pyx_GIVEREF(Py_None); + __Pyx_GOTREF(__pyx_v_self->_execute_iter); + __Pyx_DECREF(__pyx_v_self->_execute_iter); + __pyx_v_self->_execute_iter = Py_None; + + /* "asyncpg/protocol/coreproto.pyx":29 + * # executemany support data + * self._execute_iter = None + * self._execute_portal_name = None # <<<<<<<<<<<<<< + * self._execute_stmt_name = None + * + */ + __Pyx_INCREF(Py_None); + __Pyx_GIVEREF(Py_None); + __Pyx_GOTREF(__pyx_v_self->_execute_portal_name); + __Pyx_DECREF(__pyx_v_self->_execute_portal_name); + __pyx_v_self->_execute_portal_name = ((PyObject*)Py_None); + + /* "asyncpg/protocol/coreproto.pyx":30 + * self._execute_iter = None + * self._execute_portal_name = None + * self._execute_stmt_name = None # <<<<<<<<<<<<<< + * + * self._reset_result() + */ + __Pyx_INCREF(Py_None); + __Pyx_GIVEREF(Py_None); + __Pyx_GOTREF(__pyx_v_self->_execute_stmt_name); + __Pyx_DECREF(__pyx_v_self->_execute_stmt_name); + __pyx_v_self->_execute_stmt_name = ((PyObject*)Py_None); + + /* "asyncpg/protocol/coreproto.pyx":32 + * self._execute_stmt_name = None + * + * self._reset_result() # <<<<<<<<<<<<<< + * + * cdef _write(self, buf): + */ + __pyx_t_1 = ((struct __pyx_vtabstruct_7asyncpg_8protocol_8protocol_CoreProtocol *)__pyx_v_self->__pyx_vtab)->_reset_result(__pyx_v_self); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 32, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "asyncpg/protocol/coreproto.pyx":13 + * cdef class CoreProtocol: + * + * def __init__(self, con_args): # <<<<<<<<<<<<<< + * self.buffer = ReadBuffer() + * self.user = con_args.get('user') + */ + + /* function exit code */ + __pyx_r = 0; + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_AddTraceback("asyncpg.protocol.protocol.CoreProtocol.__init__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = -1; + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "asyncpg/protocol/coreproto.pyx":34 + * self._reset_result() + * + * cdef _write(self, buf): # <<<<<<<<<<<<<< + * self.transport.write(memoryview(buf)) + * + */ + +static PyObject *__pyx_f_7asyncpg_8protocol_8protocol_12CoreProtocol__write(struct __pyx_obj_7asyncpg_8protocol_8protocol_CoreProtocol *__pyx_v_self, PyObject *__pyx_v_buf) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + PyObject *__pyx_t_5 = NULL; + __Pyx_RefNannySetupContext("_write", 0); + + /* "asyncpg/protocol/coreproto.pyx":35 + * + * cdef _write(self, buf): + * self.transport.write(memoryview(buf)) # <<<<<<<<<<<<<< + * + * cdef inline _write_sync_message(self): + */ + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_self->transport, __pyx_n_s_write); if (unlikely(!__pyx_t_2)) __PYX_ERR(4, 35, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = PyTuple_New(1); if (unlikely(!__pyx_t_3)) __PYX_ERR(4, 35, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_INCREF(__pyx_v_buf); + __Pyx_GIVEREF(__pyx_v_buf); + PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_v_buf); + __pyx_t_4 = __Pyx_PyObject_Call(__pyx_builtin_memoryview, __pyx_t_3, NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(4, 35, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_3 = NULL; + if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_3)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_3); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + } + } + if (!__pyx_t_3) { + __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_4); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 35, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_GOTREF(__pyx_t_1); + } else { + #if CYTHON_FAST_PYCALL + if (PyFunction_Check(__pyx_t_2)) { + PyObject *__pyx_temp[2] = {__pyx_t_3, __pyx_t_4}; + __pyx_t_1 = __Pyx_PyFunction_FastCall(__pyx_t_2, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 35, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + } else + #endif + #if CYTHON_FAST_PYCCALL + if (__Pyx_PyFastCFunction_Check(__pyx_t_2)) { + PyObject *__pyx_temp[2] = {__pyx_t_3, __pyx_t_4}; + __pyx_t_1 = __Pyx_PyCFunction_FastCall(__pyx_t_2, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 35, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + } else + #endif + { + __pyx_t_5 = PyTuple_New(1+1); if (unlikely(!__pyx_t_5)) __PYX_ERR(4, 35, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_GIVEREF(__pyx_t_3); PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_t_3); __pyx_t_3 = NULL; + __Pyx_GIVEREF(__pyx_t_4); + PyTuple_SET_ITEM(__pyx_t_5, 0+1, __pyx_t_4); + __pyx_t_4 = 0; + __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_t_5, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 35, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + } + } + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "asyncpg/protocol/coreproto.pyx":34 + * self._reset_result() + * + * cdef _write(self, buf): # <<<<<<<<<<<<<< + * self.transport.write(memoryview(buf)) + * + */ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_AddTraceback("asyncpg.protocol.protocol.CoreProtocol._write", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "asyncpg/protocol/coreproto.pyx":37 + * self.transport.write(memoryview(buf)) + * + * cdef inline _write_sync_message(self): # <<<<<<<<<<<<<< + * self.transport.write(SYNC_MESSAGE) + * + */ + +static CYTHON_INLINE PyObject *__pyx_f_7asyncpg_8protocol_8protocol_12CoreProtocol__write_sync_message(struct __pyx_obj_7asyncpg_8protocol_8protocol_CoreProtocol *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + __Pyx_RefNannySetupContext("_write_sync_message", 0); + + /* "asyncpg/protocol/coreproto.pyx":38 + * + * cdef inline _write_sync_message(self): + * self.transport.write(SYNC_MESSAGE) # <<<<<<<<<<<<<< + * + * cdef _read_server_messages(self): + */ + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_self->transport, __pyx_n_s_write); if (unlikely(!__pyx_t_2)) __PYX_ERR(4, 38, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = NULL; + if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_3)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_3); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + } + } + if (!__pyx_t_3) { + __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_v_7asyncpg_8protocol_8protocol_SYNC_MESSAGE); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 38, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + } else { + #if CYTHON_FAST_PYCALL + if (PyFunction_Check(__pyx_t_2)) { + PyObject *__pyx_temp[2] = {__pyx_t_3, __pyx_v_7asyncpg_8protocol_8protocol_SYNC_MESSAGE}; + __pyx_t_1 = __Pyx_PyFunction_FastCall(__pyx_t_2, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 38, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_GOTREF(__pyx_t_1); + } else + #endif + #if CYTHON_FAST_PYCCALL + if (__Pyx_PyFastCFunction_Check(__pyx_t_2)) { + PyObject *__pyx_temp[2] = {__pyx_t_3, __pyx_v_7asyncpg_8protocol_8protocol_SYNC_MESSAGE}; + __pyx_t_1 = __Pyx_PyCFunction_FastCall(__pyx_t_2, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 38, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_GOTREF(__pyx_t_1); + } else + #endif + { + __pyx_t_4 = PyTuple_New(1+1); if (unlikely(!__pyx_t_4)) __PYX_ERR(4, 38, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_GIVEREF(__pyx_t_3); PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_3); __pyx_t_3 = NULL; + __Pyx_INCREF(__pyx_v_7asyncpg_8protocol_8protocol_SYNC_MESSAGE); + __Pyx_GIVEREF(__pyx_v_7asyncpg_8protocol_8protocol_SYNC_MESSAGE); + PyTuple_SET_ITEM(__pyx_t_4, 0+1, __pyx_v_7asyncpg_8protocol_8protocol_SYNC_MESSAGE); + __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_t_4, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 38, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + } + } + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "asyncpg/protocol/coreproto.pyx":37 + * self.transport.write(memoryview(buf)) + * + * cdef inline _write_sync_message(self): # <<<<<<<<<<<<<< + * self.transport.write(SYNC_MESSAGE) + * + */ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_AddTraceback("asyncpg.protocol.protocol.CoreProtocol._write_sync_message", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "asyncpg/protocol/coreproto.pyx":40 + * self.transport.write(SYNC_MESSAGE) + * + * cdef _read_server_messages(self): # <<<<<<<<<<<<<< + * cdef: + * char mtype + */ + +static PyObject *__pyx_f_7asyncpg_8protocol_8protocol_12CoreProtocol__read_server_messages(struct __pyx_obj_7asyncpg_8protocol_8protocol_CoreProtocol *__pyx_v_self) { + char __pyx_v_mtype; + enum __pyx_t_7asyncpg_8protocol_8protocol_ProtocolState __pyx_v_state; + PyObject *__pyx_v_ex = NULL; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + int32_t __pyx_t_1; + int __pyx_t_2; + enum __pyx_t_7asyncpg_8protocol_8protocol_ProtocolState __pyx_t_3; + PyObject *__pyx_t_4 = NULL; + PyObject *__pyx_t_5 = NULL; + PyObject *__pyx_t_6 = NULL; + PyObject *__pyx_t_7 = NULL; + PyObject *__pyx_t_8 = NULL; + PyObject *__pyx_t_9 = NULL; + PyObject *__pyx_t_10 = NULL; + PyObject *__pyx_t_11 = NULL; + int __pyx_t_12; + int __pyx_t_13; + char const *__pyx_t_14; + PyObject *__pyx_t_15 = NULL; + PyObject *__pyx_t_16 = NULL; + PyObject *__pyx_t_17 = NULL; + PyObject *__pyx_t_18 = NULL; + PyObject *__pyx_t_19 = NULL; + PyObject *__pyx_t_20 = NULL; + char const *__pyx_t_21; + __Pyx_RefNannySetupContext("_read_server_messages", 0); + + /* "asyncpg/protocol/coreproto.pyx":45 + * ProtocolState state + * + * while self.buffer.has_message() == 1: # <<<<<<<<<<<<<< + * mtype = self.buffer.get_message_type() + * state = self.state + */ + while (1) { + __pyx_t_1 = __pyx_f_7asyncpg_8protocol_8protocol_10ReadBuffer_has_message(__pyx_v_self->buffer); if (unlikely(__pyx_t_1 == -1)) __PYX_ERR(4, 45, __pyx_L1_error) + __pyx_t_2 = ((__pyx_t_1 == 1) != 0); + if (!__pyx_t_2) break; + + /* "asyncpg/protocol/coreproto.pyx":46 + * + * while self.buffer.has_message() == 1: + * mtype = self.buffer.get_message_type() # <<<<<<<<<<<<<< + * state = self.state + * + */ + __pyx_v_mtype = __pyx_f_7asyncpg_8protocol_8protocol_10ReadBuffer_get_message_type(__pyx_v_self->buffer); + + /* "asyncpg/protocol/coreproto.pyx":47 + * while self.buffer.has_message() == 1: + * mtype = self.buffer.get_message_type() + * state = self.state # <<<<<<<<<<<<<< + * + * try: + */ + __pyx_t_3 = __pyx_v_self->state; + __pyx_v_state = __pyx_t_3; + + /* "asyncpg/protocol/coreproto.pyx":49 + * state = self.state + * + * try: # <<<<<<<<<<<<<< + * if mtype == b'S': + * # ParameterStatus + */ + /*try:*/ { + { + __Pyx_PyThreadState_declare + __Pyx_PyThreadState_assign + __Pyx_ExceptionSave(&__pyx_t_4, &__pyx_t_5, &__pyx_t_6); + __Pyx_XGOTREF(__pyx_t_4); + __Pyx_XGOTREF(__pyx_t_5); + __Pyx_XGOTREF(__pyx_t_6); + /*try:*/ { + + /* "asyncpg/protocol/coreproto.pyx":50 + * + * try: + * if mtype == b'S': # <<<<<<<<<<<<<< + * # ParameterStatus + * self._parse_msg_parameter_status() + */ + switch (__pyx_v_mtype) { + case 'S': + + /* "asyncpg/protocol/coreproto.pyx":52 + * if mtype == b'S': + * # ParameterStatus + * self._parse_msg_parameter_status() # <<<<<<<<<<<<<< + * continue + * elif mtype == b'A': + */ + __pyx_t_7 = ((struct __pyx_vtabstruct_7asyncpg_8protocol_8protocol_CoreProtocol *)__pyx_v_self->__pyx_vtab)->_parse_msg_parameter_status(__pyx_v_self); if (unlikely(!__pyx_t_7)) __PYX_ERR(4, 52, __pyx_L10_error) + __Pyx_GOTREF(__pyx_t_7); + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + + /* "asyncpg/protocol/coreproto.pyx":53 + * # ParameterStatus + * self._parse_msg_parameter_status() + * continue # <<<<<<<<<<<<<< + * elif mtype == b'A': + * # NotificationResponse + */ + goto __pyx_L16_try_continue; + + /* "asyncpg/protocol/coreproto.pyx":50 + * + * try: + * if mtype == b'S': # <<<<<<<<<<<<<< + * # ParameterStatus + * self._parse_msg_parameter_status() + */ + break; + + /* "asyncpg/protocol/coreproto.pyx":54 + * self._parse_msg_parameter_status() + * continue + * elif mtype == b'A': # <<<<<<<<<<<<<< + * # NotificationResponse + * self._parse_msg_notification() + */ + case 'A': + + /* "asyncpg/protocol/coreproto.pyx":56 + * elif mtype == b'A': + * # NotificationResponse + * self._parse_msg_notification() # <<<<<<<<<<<<<< + * continue + * + */ + __pyx_t_7 = ((struct __pyx_vtabstruct_7asyncpg_8protocol_8protocol_CoreProtocol *)__pyx_v_self->__pyx_vtab)->_parse_msg_notification(__pyx_v_self); if (unlikely(!__pyx_t_7)) __PYX_ERR(4, 56, __pyx_L10_error) + __Pyx_GOTREF(__pyx_t_7); + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + + /* "asyncpg/protocol/coreproto.pyx":57 + * # NotificationResponse + * self._parse_msg_notification() + * continue # <<<<<<<<<<<<<< + * + * if state == PROTOCOL_AUTH: + */ + goto __pyx_L16_try_continue; + + /* "asyncpg/protocol/coreproto.pyx":54 + * self._parse_msg_parameter_status() + * continue + * elif mtype == b'A': # <<<<<<<<<<<<<< + * # NotificationResponse + * self._parse_msg_notification() + */ + break; + default: break; + } + + /* "asyncpg/protocol/coreproto.pyx":59 + * continue + * + * if state == PROTOCOL_AUTH: # <<<<<<<<<<<<<< + * self._process__auth(mtype) + * + */ + switch (__pyx_v_state) { + case __pyx_e_7asyncpg_8protocol_8protocol_PROTOCOL_AUTH: + + /* "asyncpg/protocol/coreproto.pyx":60 + * + * if state == PROTOCOL_AUTH: + * self._process__auth(mtype) # <<<<<<<<<<<<<< + * + * elif state == PROTOCOL_PREPARE: + */ + __pyx_t_7 = ((struct __pyx_vtabstruct_7asyncpg_8protocol_8protocol_CoreProtocol *)__pyx_v_self->__pyx_vtab)->_process__auth(__pyx_v_self, __pyx_v_mtype); if (unlikely(!__pyx_t_7)) __PYX_ERR(4, 60, __pyx_L10_error) + __Pyx_GOTREF(__pyx_t_7); + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + + /* "asyncpg/protocol/coreproto.pyx":59 + * continue + * + * if state == PROTOCOL_AUTH: # <<<<<<<<<<<<<< + * self._process__auth(mtype) + * + */ + break; + + /* "asyncpg/protocol/coreproto.pyx":62 + * self._process__auth(mtype) + * + * elif state == PROTOCOL_PREPARE: # <<<<<<<<<<<<<< + * self._process__prepare(mtype) + * + */ + case __pyx_e_7asyncpg_8protocol_8protocol_PROTOCOL_PREPARE: + + /* "asyncpg/protocol/coreproto.pyx":63 + * + * elif state == PROTOCOL_PREPARE: + * self._process__prepare(mtype) # <<<<<<<<<<<<<< + * + * elif state == PROTOCOL_BIND_EXECUTE: + */ + __pyx_t_7 = ((struct __pyx_vtabstruct_7asyncpg_8protocol_8protocol_CoreProtocol *)__pyx_v_self->__pyx_vtab)->_process__prepare(__pyx_v_self, __pyx_v_mtype); if (unlikely(!__pyx_t_7)) __PYX_ERR(4, 63, __pyx_L10_error) + __Pyx_GOTREF(__pyx_t_7); + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + + /* "asyncpg/protocol/coreproto.pyx":62 + * self._process__auth(mtype) + * + * elif state == PROTOCOL_PREPARE: # <<<<<<<<<<<<<< + * self._process__prepare(mtype) + * + */ + break; + + /* "asyncpg/protocol/coreproto.pyx":65 + * self._process__prepare(mtype) + * + * elif state == PROTOCOL_BIND_EXECUTE: # <<<<<<<<<<<<<< + * self._process__bind_execute(mtype) + * + */ + case __pyx_e_7asyncpg_8protocol_8protocol_PROTOCOL_BIND_EXECUTE: + + /* "asyncpg/protocol/coreproto.pyx":66 + * + * elif state == PROTOCOL_BIND_EXECUTE: + * self._process__bind_execute(mtype) # <<<<<<<<<<<<<< + * + * elif state == PROTOCOL_BIND_EXECUTE_MANY: + */ + __pyx_t_7 = ((struct __pyx_vtabstruct_7asyncpg_8protocol_8protocol_CoreProtocol *)__pyx_v_self->__pyx_vtab)->_process__bind_execute(__pyx_v_self, __pyx_v_mtype); if (unlikely(!__pyx_t_7)) __PYX_ERR(4, 66, __pyx_L10_error) + __Pyx_GOTREF(__pyx_t_7); + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + + /* "asyncpg/protocol/coreproto.pyx":65 + * self._process__prepare(mtype) + * + * elif state == PROTOCOL_BIND_EXECUTE: # <<<<<<<<<<<<<< + * self._process__bind_execute(mtype) + * + */ + break; + + /* "asyncpg/protocol/coreproto.pyx":68 + * self._process__bind_execute(mtype) + * + * elif state == PROTOCOL_BIND_EXECUTE_MANY: # <<<<<<<<<<<<<< + * self._process__bind_execute_many(mtype) + * + */ + case __pyx_e_7asyncpg_8protocol_8protocol_PROTOCOL_BIND_EXECUTE_MANY: + + /* "asyncpg/protocol/coreproto.pyx":69 + * + * elif state == PROTOCOL_BIND_EXECUTE_MANY: + * self._process__bind_execute_many(mtype) # <<<<<<<<<<<<<< + * + * elif state == PROTOCOL_EXECUTE: + */ + __pyx_t_7 = ((struct __pyx_vtabstruct_7asyncpg_8protocol_8protocol_CoreProtocol *)__pyx_v_self->__pyx_vtab)->_process__bind_execute_many(__pyx_v_self, __pyx_v_mtype); if (unlikely(!__pyx_t_7)) __PYX_ERR(4, 69, __pyx_L10_error) + __Pyx_GOTREF(__pyx_t_7); + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + + /* "asyncpg/protocol/coreproto.pyx":68 + * self._process__bind_execute(mtype) + * + * elif state == PROTOCOL_BIND_EXECUTE_MANY: # <<<<<<<<<<<<<< + * self._process__bind_execute_many(mtype) + * + */ + break; + + /* "asyncpg/protocol/coreproto.pyx":71 + * self._process__bind_execute_many(mtype) + * + * elif state == PROTOCOL_EXECUTE: # <<<<<<<<<<<<<< + * self._process__bind_execute(mtype) + * + */ + case __pyx_e_7asyncpg_8protocol_8protocol_PROTOCOL_EXECUTE: + + /* "asyncpg/protocol/coreproto.pyx":72 + * + * elif state == PROTOCOL_EXECUTE: + * self._process__bind_execute(mtype) # <<<<<<<<<<<<<< + * + * elif state == PROTOCOL_BIND: + */ + __pyx_t_7 = ((struct __pyx_vtabstruct_7asyncpg_8protocol_8protocol_CoreProtocol *)__pyx_v_self->__pyx_vtab)->_process__bind_execute(__pyx_v_self, __pyx_v_mtype); if (unlikely(!__pyx_t_7)) __PYX_ERR(4, 72, __pyx_L10_error) + __Pyx_GOTREF(__pyx_t_7); + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + + /* "asyncpg/protocol/coreproto.pyx":71 + * self._process__bind_execute_many(mtype) + * + * elif state == PROTOCOL_EXECUTE: # <<<<<<<<<<<<<< + * self._process__bind_execute(mtype) + * + */ + break; + + /* "asyncpg/protocol/coreproto.pyx":74 + * self._process__bind_execute(mtype) + * + * elif state == PROTOCOL_BIND: # <<<<<<<<<<<<<< + * self._process__bind(mtype) + * + */ + case __pyx_e_7asyncpg_8protocol_8protocol_PROTOCOL_BIND: + + /* "asyncpg/protocol/coreproto.pyx":75 + * + * elif state == PROTOCOL_BIND: + * self._process__bind(mtype) # <<<<<<<<<<<<<< + * + * elif state == PROTOCOL_CLOSE_STMT_PORTAL: + */ + __pyx_t_7 = ((struct __pyx_vtabstruct_7asyncpg_8protocol_8protocol_CoreProtocol *)__pyx_v_self->__pyx_vtab)->_process__bind(__pyx_v_self, __pyx_v_mtype); if (unlikely(!__pyx_t_7)) __PYX_ERR(4, 75, __pyx_L10_error) + __Pyx_GOTREF(__pyx_t_7); + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + + /* "asyncpg/protocol/coreproto.pyx":74 + * self._process__bind_execute(mtype) + * + * elif state == PROTOCOL_BIND: # <<<<<<<<<<<<<< + * self._process__bind(mtype) + * + */ + break; + + /* "asyncpg/protocol/coreproto.pyx":77 + * self._process__bind(mtype) + * + * elif state == PROTOCOL_CLOSE_STMT_PORTAL: # <<<<<<<<<<<<<< + * self._process__close_stmt_portal(mtype) + * + */ + case __pyx_e_7asyncpg_8protocol_8protocol_PROTOCOL_CLOSE_STMT_PORTAL: + + /* "asyncpg/protocol/coreproto.pyx":78 + * + * elif state == PROTOCOL_CLOSE_STMT_PORTAL: + * self._process__close_stmt_portal(mtype) # <<<<<<<<<<<<<< + * + * elif state == PROTOCOL_SIMPLE_QUERY: + */ + __pyx_t_7 = ((struct __pyx_vtabstruct_7asyncpg_8protocol_8protocol_CoreProtocol *)__pyx_v_self->__pyx_vtab)->_process__close_stmt_portal(__pyx_v_self, __pyx_v_mtype); if (unlikely(!__pyx_t_7)) __PYX_ERR(4, 78, __pyx_L10_error) + __Pyx_GOTREF(__pyx_t_7); + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + + /* "asyncpg/protocol/coreproto.pyx":77 + * self._process__bind(mtype) + * + * elif state == PROTOCOL_CLOSE_STMT_PORTAL: # <<<<<<<<<<<<<< + * self._process__close_stmt_portal(mtype) + * + */ + break; + + /* "asyncpg/protocol/coreproto.pyx":80 + * self._process__close_stmt_portal(mtype) + * + * elif state == PROTOCOL_SIMPLE_QUERY: # <<<<<<<<<<<<<< + * self._process__simple_query(mtype) + * + */ + case __pyx_e_7asyncpg_8protocol_8protocol_PROTOCOL_SIMPLE_QUERY: + + /* "asyncpg/protocol/coreproto.pyx":81 + * + * elif state == PROTOCOL_SIMPLE_QUERY: + * self._process__simple_query(mtype) # <<<<<<<<<<<<<< + * + * elif state == PROTOCOL_ERROR_CONSUME: + */ + __pyx_t_7 = ((struct __pyx_vtabstruct_7asyncpg_8protocol_8protocol_CoreProtocol *)__pyx_v_self->__pyx_vtab)->_process__simple_query(__pyx_v_self, __pyx_v_mtype); if (unlikely(!__pyx_t_7)) __PYX_ERR(4, 81, __pyx_L10_error) + __Pyx_GOTREF(__pyx_t_7); + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + + /* "asyncpg/protocol/coreproto.pyx":80 + * self._process__close_stmt_portal(mtype) + * + * elif state == PROTOCOL_SIMPLE_QUERY: # <<<<<<<<<<<<<< + * self._process__simple_query(mtype) + * + */ + break; + + /* "asyncpg/protocol/coreproto.pyx":83 + * self._process__simple_query(mtype) + * + * elif state == PROTOCOL_ERROR_CONSUME: # <<<<<<<<<<<<<< + * # Error in protocol (on asyncpg side); + * # discard all messages until sync message + */ + case __pyx_e_7asyncpg_8protocol_8protocol_PROTOCOL_ERROR_CONSUME: + + /* "asyncpg/protocol/coreproto.pyx":87 + * # discard all messages until sync message + * + * if mtype == b'Z': # <<<<<<<<<<<<<< + * # Sync point, self to push the result + * if self.result_type != RESULT_FAILED: + */ + __pyx_t_2 = ((__pyx_v_mtype == 'Z') != 0); + if (__pyx_t_2) { + + /* "asyncpg/protocol/coreproto.pyx":89 + * if mtype == b'Z': + * # Sync point, self to push the result + * if self.result_type != RESULT_FAILED: # <<<<<<<<<<<<<< + * self.result_type = RESULT_FAILED + * self.result = RuntimeError( + */ + __pyx_t_2 = ((__pyx_v_self->result_type != __pyx_e_7asyncpg_8protocol_8protocol_RESULT_FAILED) != 0); + if (__pyx_t_2) { + + /* "asyncpg/protocol/coreproto.pyx":90 + * # Sync point, self to push the result + * if self.result_type != RESULT_FAILED: + * self.result_type = RESULT_FAILED # <<<<<<<<<<<<<< + * self.result = RuntimeError( + * 'unknown error in protocol implementation') + */ + __pyx_v_self->result_type = __pyx_e_7asyncpg_8protocol_8protocol_RESULT_FAILED; + + /* "asyncpg/protocol/coreproto.pyx":91 + * if self.result_type != RESULT_FAILED: + * self.result_type = RESULT_FAILED + * self.result = RuntimeError( # <<<<<<<<<<<<<< + * 'unknown error in protocol implementation') + * + */ + __pyx_t_7 = __Pyx_PyObject_Call(__pyx_builtin_RuntimeError, __pyx_tuple__56, NULL); if (unlikely(!__pyx_t_7)) __PYX_ERR(4, 91, __pyx_L10_error) + __Pyx_GOTREF(__pyx_t_7); + __Pyx_GIVEREF(__pyx_t_7); + __Pyx_GOTREF(__pyx_v_self->result); + __Pyx_DECREF(__pyx_v_self->result); + __pyx_v_self->result = __pyx_t_7; + __pyx_t_7 = 0; + + /* "asyncpg/protocol/coreproto.pyx":89 + * if mtype == b'Z': + * # Sync point, self to push the result + * if self.result_type != RESULT_FAILED: # <<<<<<<<<<<<<< + * self.result_type = RESULT_FAILED + * self.result = RuntimeError( + */ + } + + /* "asyncpg/protocol/coreproto.pyx":94 + * 'unknown error in protocol implementation') + * + * self._push_result() # <<<<<<<<<<<<<< + * + * else: + */ + __pyx_t_7 = ((struct __pyx_vtabstruct_7asyncpg_8protocol_8protocol_CoreProtocol *)__pyx_v_self->__pyx_vtab)->_push_result(__pyx_v_self); if (unlikely(!__pyx_t_7)) __PYX_ERR(4, 94, __pyx_L10_error) + __Pyx_GOTREF(__pyx_t_7); + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + + /* "asyncpg/protocol/coreproto.pyx":87 + * # discard all messages until sync message + * + * if mtype == b'Z': # <<<<<<<<<<<<<< + * # Sync point, self to push the result + * if self.result_type != RESULT_FAILED: + */ + goto __pyx_L18; + } + + /* "asyncpg/protocol/coreproto.pyx":97 + * + * else: + * self.buffer.consume_message() # <<<<<<<<<<<<<< + * + * else: + */ + /*else*/ { + __pyx_t_7 = ((PyObject *)__pyx_f_7asyncpg_8protocol_8protocol_10ReadBuffer_consume_message(__pyx_v_self->buffer)); if (unlikely(!__pyx_t_7)) __PYX_ERR(4, 97, __pyx_L10_error) + __Pyx_GOTREF(__pyx_t_7); + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + } + __pyx_L18:; + + /* "asyncpg/protocol/coreproto.pyx":83 + * self._process__simple_query(mtype) + * + * elif state == PROTOCOL_ERROR_CONSUME: # <<<<<<<<<<<<<< + * # Error in protocol (on asyncpg side); + * # discard all messages until sync message + */ + break; + default: + + /* "asyncpg/protocol/coreproto.pyx":101 + * else: + * raise RuntimeError( + * 'protocol is in an unknown state {}'.format(state)) # <<<<<<<<<<<<<< + * + * except Exception as ex: + */ + __pyx_t_8 = __Pyx_PyObject_GetAttrStr(__pyx_kp_u_protocol_is_in_an_unknown_state, __pyx_n_s_format); if (unlikely(!__pyx_t_8)) __PYX_ERR(4, 101, __pyx_L10_error) + __Pyx_GOTREF(__pyx_t_8); + __pyx_t_9 = __Pyx_PyInt_From_enum____pyx_t_7asyncpg_8protocol_8protocol_ProtocolState(__pyx_v_state); if (unlikely(!__pyx_t_9)) __PYX_ERR(4, 101, __pyx_L10_error) + __Pyx_GOTREF(__pyx_t_9); + __pyx_t_10 = NULL; + if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_8))) { + __pyx_t_10 = PyMethod_GET_SELF(__pyx_t_8); + if (likely(__pyx_t_10)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_8); + __Pyx_INCREF(__pyx_t_10); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_8, function); + } + } + if (!__pyx_t_10) { + __pyx_t_7 = __Pyx_PyObject_CallOneArg(__pyx_t_8, __pyx_t_9); if (unlikely(!__pyx_t_7)) __PYX_ERR(4, 101, __pyx_L10_error) + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + __Pyx_GOTREF(__pyx_t_7); + } else { + #if CYTHON_FAST_PYCALL + if (PyFunction_Check(__pyx_t_8)) { + PyObject *__pyx_temp[2] = {__pyx_t_10, __pyx_t_9}; + __pyx_t_7 = __Pyx_PyFunction_FastCall(__pyx_t_8, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_7)) __PYX_ERR(4, 101, __pyx_L10_error) + __Pyx_XDECREF(__pyx_t_10); __pyx_t_10 = 0; + __Pyx_GOTREF(__pyx_t_7); + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + } else + #endif + #if CYTHON_FAST_PYCCALL + if (__Pyx_PyFastCFunction_Check(__pyx_t_8)) { + PyObject *__pyx_temp[2] = {__pyx_t_10, __pyx_t_9}; + __pyx_t_7 = __Pyx_PyCFunction_FastCall(__pyx_t_8, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_7)) __PYX_ERR(4, 101, __pyx_L10_error) + __Pyx_XDECREF(__pyx_t_10); __pyx_t_10 = 0; + __Pyx_GOTREF(__pyx_t_7); + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + } else + #endif + { + __pyx_t_11 = PyTuple_New(1+1); if (unlikely(!__pyx_t_11)) __PYX_ERR(4, 101, __pyx_L10_error) + __Pyx_GOTREF(__pyx_t_11); + __Pyx_GIVEREF(__pyx_t_10); PyTuple_SET_ITEM(__pyx_t_11, 0, __pyx_t_10); __pyx_t_10 = NULL; + __Pyx_GIVEREF(__pyx_t_9); + PyTuple_SET_ITEM(__pyx_t_11, 0+1, __pyx_t_9); + __pyx_t_9 = 0; + __pyx_t_7 = __Pyx_PyObject_Call(__pyx_t_8, __pyx_t_11, NULL); if (unlikely(!__pyx_t_7)) __PYX_ERR(4, 101, __pyx_L10_error) + __Pyx_GOTREF(__pyx_t_7); + __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0; + } + } + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + + /* "asyncpg/protocol/coreproto.pyx":100 + * + * else: + * raise RuntimeError( # <<<<<<<<<<<<<< + * 'protocol is in an unknown state {}'.format(state)) + * + */ + __pyx_t_8 = PyTuple_New(1); if (unlikely(!__pyx_t_8)) __PYX_ERR(4, 100, __pyx_L10_error) + __Pyx_GOTREF(__pyx_t_8); + __Pyx_GIVEREF(__pyx_t_7); + PyTuple_SET_ITEM(__pyx_t_8, 0, __pyx_t_7); + __pyx_t_7 = 0; + __pyx_t_7 = __Pyx_PyObject_Call(__pyx_builtin_RuntimeError, __pyx_t_8, NULL); if (unlikely(!__pyx_t_7)) __PYX_ERR(4, 100, __pyx_L10_error) + __Pyx_GOTREF(__pyx_t_7); + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + __Pyx_Raise(__pyx_t_7, 0, 0, 0); + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __PYX_ERR(4, 100, __pyx_L10_error) + break; + } + + /* "asyncpg/protocol/coreproto.pyx":49 + * state = self.state + * + * try: # <<<<<<<<<<<<<< + * if mtype == b'S': + * # ParameterStatus + */ + } + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; + goto __pyx_L17_try_end; + __pyx_L10_error:; + __Pyx_PyThreadState_assign + __Pyx_XDECREF(__pyx_t_10); __pyx_t_10 = 0; + __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0; + __Pyx_XDECREF(__pyx_t_11); __pyx_t_11 = 0; + __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; + __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; + + /* "asyncpg/protocol/coreproto.pyx":103 + * 'protocol is in an unknown state {}'.format(state)) + * + * except Exception as ex: # <<<<<<<<<<<<<< + * self.result_type = RESULT_FAILED + * self.result = ex + */ + __pyx_t_12 = __Pyx_PyErr_ExceptionMatches(((PyObject *)(&((PyTypeObject*)PyExc_Exception)[0]))); + if (__pyx_t_12) { + __Pyx_AddTraceback("asyncpg.protocol.protocol.CoreProtocol._read_server_messages", __pyx_clineno, __pyx_lineno, __pyx_filename); + if (__Pyx_GetException(&__pyx_t_7, &__pyx_t_8, &__pyx_t_11) < 0) __PYX_ERR(4, 103, __pyx_L12_except_error) + __Pyx_GOTREF(__pyx_t_7); + __Pyx_GOTREF(__pyx_t_8); + __Pyx_GOTREF(__pyx_t_11); + __Pyx_INCREF(__pyx_t_8); + __pyx_v_ex = __pyx_t_8; + /*try:*/ { + + /* "asyncpg/protocol/coreproto.pyx":104 + * + * except Exception as ex: + * self.result_type = RESULT_FAILED # <<<<<<<<<<<<<< + * self.result = ex + * + */ + __pyx_v_self->result_type = __pyx_e_7asyncpg_8protocol_8protocol_RESULT_FAILED; + + /* "asyncpg/protocol/coreproto.pyx":105 + * except Exception as ex: + * self.result_type = RESULT_FAILED + * self.result = ex # <<<<<<<<<<<<<< + * + * if mtype == b'Z': + */ + __Pyx_INCREF(__pyx_v_ex); + __Pyx_GIVEREF(__pyx_v_ex); + __Pyx_GOTREF(__pyx_v_self->result); + __Pyx_DECREF(__pyx_v_self->result); + __pyx_v_self->result = __pyx_v_ex; + + /* "asyncpg/protocol/coreproto.pyx":107 + * self.result = ex + * + * if mtype == b'Z': # <<<<<<<<<<<<<< + * self._push_result() + * else: + */ + __pyx_t_2 = ((__pyx_v_mtype == 'Z') != 0); + if (__pyx_t_2) { + + /* "asyncpg/protocol/coreproto.pyx":108 + * + * if mtype == b'Z': + * self._push_result() # <<<<<<<<<<<<<< + * else: + * self.state = PROTOCOL_ERROR_CONSUME + */ + __pyx_t_9 = ((struct __pyx_vtabstruct_7asyncpg_8protocol_8protocol_CoreProtocol *)__pyx_v_self->__pyx_vtab)->_push_result(__pyx_v_self); if (unlikely(!__pyx_t_9)) __PYX_ERR(4, 108, __pyx_L25_error) + __Pyx_GOTREF(__pyx_t_9); + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + + /* "asyncpg/protocol/coreproto.pyx":107 + * self.result = ex + * + * if mtype == b'Z': # <<<<<<<<<<<<<< + * self._push_result() + * else: + */ + goto __pyx_L27; + } + + /* "asyncpg/protocol/coreproto.pyx":110 + * self._push_result() + * else: + * self.state = PROTOCOL_ERROR_CONSUME # <<<<<<<<<<<<<< + * + * finally: + */ + /*else*/ { + __pyx_v_self->state = __pyx_e_7asyncpg_8protocol_8protocol_PROTOCOL_ERROR_CONSUME; + } + __pyx_L27:; + } + + /* "asyncpg/protocol/coreproto.pyx":103 + * 'protocol is in an unknown state {}'.format(state)) + * + * except Exception as ex: # <<<<<<<<<<<<<< + * self.result_type = RESULT_FAILED + * self.result = ex + */ + /*finally:*/ { + /*normal exit:*/{ + __Pyx_DECREF(__pyx_v_ex); + __pyx_v_ex = NULL; + goto __pyx_L26; + } + /*exception exit:*/{ + __Pyx_PyThreadState_declare + __pyx_L25_error:; + __pyx_t_15 = 0; __pyx_t_16 = 0; __pyx_t_17 = 0; __pyx_t_18 = 0; __pyx_t_19 = 0; __pyx_t_20 = 0; + __Pyx_PyThreadState_assign + __Pyx_XDECREF(__pyx_t_10); __pyx_t_10 = 0; + __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0; + if (PY_MAJOR_VERSION >= 3) __Pyx_ExceptionSwap(&__pyx_t_18, &__pyx_t_19, &__pyx_t_20); + if ((PY_MAJOR_VERSION < 3) || unlikely(__Pyx_GetException(&__pyx_t_15, &__pyx_t_16, &__pyx_t_17) < 0)) __Pyx_ErrFetch(&__pyx_t_15, &__pyx_t_16, &__pyx_t_17); + __Pyx_XGOTREF(__pyx_t_15); + __Pyx_XGOTREF(__pyx_t_16); + __Pyx_XGOTREF(__pyx_t_17); + __Pyx_XGOTREF(__pyx_t_18); + __Pyx_XGOTREF(__pyx_t_19); + __Pyx_XGOTREF(__pyx_t_20); + __pyx_t_12 = __pyx_lineno; __pyx_t_13 = __pyx_clineno; __pyx_t_14 = __pyx_filename; + { + __Pyx_DECREF(__pyx_v_ex); + __pyx_v_ex = NULL; + } + __Pyx_PyThreadState_assign + if (PY_MAJOR_VERSION >= 3) { + __Pyx_XGIVEREF(__pyx_t_18); + __Pyx_XGIVEREF(__pyx_t_19); + __Pyx_XGIVEREF(__pyx_t_20); + __Pyx_ExceptionReset(__pyx_t_18, __pyx_t_19, __pyx_t_20); + } + __Pyx_XGIVEREF(__pyx_t_15); + __Pyx_XGIVEREF(__pyx_t_16); + __Pyx_XGIVEREF(__pyx_t_17); + __Pyx_ErrRestore(__pyx_t_15, __pyx_t_16, __pyx_t_17); + __pyx_t_15 = 0; __pyx_t_16 = 0; __pyx_t_17 = 0; __pyx_t_18 = 0; __pyx_t_19 = 0; __pyx_t_20 = 0; + __pyx_lineno = __pyx_t_12; __pyx_clineno = __pyx_t_13; __pyx_filename = __pyx_t_14; + goto __pyx_L12_except_error; + } + __pyx_L26:; + } + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0; + goto __pyx_L11_exception_handled; + } + goto __pyx_L12_except_error; + __pyx_L12_except_error:; + + /* "asyncpg/protocol/coreproto.pyx":49 + * state = self.state + * + * try: # <<<<<<<<<<<<<< + * if mtype == b'S': + * # ParameterStatus + */ + __Pyx_PyThreadState_assign + __Pyx_XGIVEREF(__pyx_t_4); + __Pyx_XGIVEREF(__pyx_t_5); + __Pyx_XGIVEREF(__pyx_t_6); + __Pyx_ExceptionReset(__pyx_t_4, __pyx_t_5, __pyx_t_6); + goto __pyx_L8_error; + __pyx_L16_try_continue:; + __Pyx_PyThreadState_assign + __Pyx_XGIVEREF(__pyx_t_4); + __Pyx_XGIVEREF(__pyx_t_5); + __Pyx_XGIVEREF(__pyx_t_6); + __Pyx_ExceptionReset(__pyx_t_4, __pyx_t_5, __pyx_t_6); + goto __pyx_L5_continue; + __pyx_L11_exception_handled:; + __Pyx_PyThreadState_assign + __Pyx_XGIVEREF(__pyx_t_4); + __Pyx_XGIVEREF(__pyx_t_5); + __Pyx_XGIVEREF(__pyx_t_6); + __Pyx_ExceptionReset(__pyx_t_4, __pyx_t_5, __pyx_t_6); + __pyx_L17_try_end:; + } + } + + /* "asyncpg/protocol/coreproto.pyx":113 + * + * finally: + * if self._skip_discard: # <<<<<<<<<<<<<< + * self._skip_discard = False + * else: + */ + /*finally:*/ { + /*normal exit:*/{ + __pyx_t_2 = (__pyx_v_self->_skip_discard != 0); + if (__pyx_t_2) { + + /* "asyncpg/protocol/coreproto.pyx":114 + * finally: + * if self._skip_discard: + * self._skip_discard = False # <<<<<<<<<<<<<< + * else: + * self.buffer.discard_message() + */ + __pyx_v_self->_skip_discard = 0; + + /* "asyncpg/protocol/coreproto.pyx":113 + * + * finally: + * if self._skip_discard: # <<<<<<<<<<<<<< + * self._skip_discard = False + * else: + */ + goto __pyx_L32; + } + + /* "asyncpg/protocol/coreproto.pyx":116 + * self._skip_discard = False + * else: + * self.buffer.discard_message() # <<<<<<<<<<<<<< + * + * cdef _process__auth(self, char mtype): + */ + /*else*/ { + __pyx_t_11 = __pyx_f_7asyncpg_8protocol_8protocol_10ReadBuffer_discard_message(__pyx_v_self->buffer); if (unlikely(!__pyx_t_11)) __PYX_ERR(4, 116, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_11); + __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0; + } + __pyx_L32:; + goto __pyx_L9; + } + /*exception exit:*/{ + __Pyx_PyThreadState_declare + __pyx_L8_error:; + __pyx_t_6 = 0; __pyx_t_5 = 0; __pyx_t_4 = 0; __pyx_t_20 = 0; __pyx_t_19 = 0; __pyx_t_18 = 0; + __Pyx_PyThreadState_assign + __Pyx_XDECREF(__pyx_t_10); __pyx_t_10 = 0; + __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0; + __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; + __Pyx_XDECREF(__pyx_t_11); __pyx_t_11 = 0; + if (PY_MAJOR_VERSION >= 3) __Pyx_ExceptionSwap(&__pyx_t_20, &__pyx_t_19, &__pyx_t_18); + if ((PY_MAJOR_VERSION < 3) || unlikely(__Pyx_GetException(&__pyx_t_6, &__pyx_t_5, &__pyx_t_4) < 0)) __Pyx_ErrFetch(&__pyx_t_6, &__pyx_t_5, &__pyx_t_4); + __Pyx_XGOTREF(__pyx_t_6); + __Pyx_XGOTREF(__pyx_t_5); + __Pyx_XGOTREF(__pyx_t_4); + __Pyx_XGOTREF(__pyx_t_20); + __Pyx_XGOTREF(__pyx_t_19); + __Pyx_XGOTREF(__pyx_t_18); + __pyx_t_13 = __pyx_lineno; __pyx_t_12 = __pyx_clineno; __pyx_t_21 = __pyx_filename; + { + + /* "asyncpg/protocol/coreproto.pyx":113 + * + * finally: + * if self._skip_discard: # <<<<<<<<<<<<<< + * self._skip_discard = False + * else: + */ + __pyx_t_2 = (__pyx_v_self->_skip_discard != 0); + if (__pyx_t_2) { + + /* "asyncpg/protocol/coreproto.pyx":114 + * finally: + * if self._skip_discard: + * self._skip_discard = False # <<<<<<<<<<<<<< + * else: + * self.buffer.discard_message() + */ + __pyx_v_self->_skip_discard = 0; + + /* "asyncpg/protocol/coreproto.pyx":113 + * + * finally: + * if self._skip_discard: # <<<<<<<<<<<<<< + * self._skip_discard = False + * else: + */ + goto __pyx_L37; + } + + /* "asyncpg/protocol/coreproto.pyx":116 + * self._skip_discard = False + * else: + * self.buffer.discard_message() # <<<<<<<<<<<<<< + * + * cdef _process__auth(self, char mtype): + */ + /*else*/ { + __pyx_t_11 = __pyx_f_7asyncpg_8protocol_8protocol_10ReadBuffer_discard_message(__pyx_v_self->buffer); if (unlikely(!__pyx_t_11)) __PYX_ERR(4, 116, __pyx_L36_error) + __Pyx_GOTREF(__pyx_t_11); + __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0; + } + __pyx_L37:; + } + __Pyx_PyThreadState_assign + if (PY_MAJOR_VERSION >= 3) { + __Pyx_XGIVEREF(__pyx_t_20); + __Pyx_XGIVEREF(__pyx_t_19); + __Pyx_XGIVEREF(__pyx_t_18); + __Pyx_ExceptionReset(__pyx_t_20, __pyx_t_19, __pyx_t_18); + } + __Pyx_XGIVEREF(__pyx_t_6); + __Pyx_XGIVEREF(__pyx_t_5); + __Pyx_XGIVEREF(__pyx_t_4); + __Pyx_ErrRestore(__pyx_t_6, __pyx_t_5, __pyx_t_4); + __pyx_t_6 = 0; __pyx_t_5 = 0; __pyx_t_4 = 0; __pyx_t_20 = 0; __pyx_t_19 = 0; __pyx_t_18 = 0; + __pyx_lineno = __pyx_t_13; __pyx_clineno = __pyx_t_12; __pyx_filename = __pyx_t_21; + goto __pyx_L1_error; + __pyx_L36_error:; + __Pyx_PyThreadState_assign + if (PY_MAJOR_VERSION >= 3) { + __Pyx_XGIVEREF(__pyx_t_20); + __Pyx_XGIVEREF(__pyx_t_19); + __Pyx_XGIVEREF(__pyx_t_18); + __Pyx_ExceptionReset(__pyx_t_20, __pyx_t_19, __pyx_t_18); + } + __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_20 = 0; __pyx_t_19 = 0; __pyx_t_18 = 0; + goto __pyx_L1_error; + } + __pyx_L5_continue: { + + /* "asyncpg/protocol/coreproto.pyx":113 + * + * finally: + * if self._skip_discard: # <<<<<<<<<<<<<< + * self._skip_discard = False + * else: + */ + __pyx_t_2 = (__pyx_v_self->_skip_discard != 0); + if (__pyx_t_2) { + + /* "asyncpg/protocol/coreproto.pyx":114 + * finally: + * if self._skip_discard: + * self._skip_discard = False # <<<<<<<<<<<<<< + * else: + * self.buffer.discard_message() + */ + __pyx_v_self->_skip_discard = 0; + + /* "asyncpg/protocol/coreproto.pyx":113 + * + * finally: + * if self._skip_discard: # <<<<<<<<<<<<<< + * self._skip_discard = False + * else: + */ + goto __pyx_L38; + } + + /* "asyncpg/protocol/coreproto.pyx":116 + * self._skip_discard = False + * else: + * self.buffer.discard_message() # <<<<<<<<<<<<<< + * + * cdef _process__auth(self, char mtype): + */ + /*else*/ { + __pyx_t_11 = __pyx_f_7asyncpg_8protocol_8protocol_10ReadBuffer_discard_message(__pyx_v_self->buffer); if (unlikely(!__pyx_t_11)) __PYX_ERR(4, 116, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_11); + __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0; + } + __pyx_L38:; + goto __pyx_L3_continue; + } + __pyx_L9:; + } + __pyx_L3_continue:; + } + + /* "asyncpg/protocol/coreproto.pyx":40 + * self.transport.write(SYNC_MESSAGE) + * + * cdef _read_server_messages(self): # <<<<<<<<<<<<<< + * cdef: + * char mtype + */ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_7); + __Pyx_XDECREF(__pyx_t_8); + __Pyx_XDECREF(__pyx_t_9); + __Pyx_XDECREF(__pyx_t_10); + __Pyx_XDECREF(__pyx_t_11); + __Pyx_AddTraceback("asyncpg.protocol.protocol.CoreProtocol._read_server_messages", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XDECREF(__pyx_v_ex); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "asyncpg/protocol/coreproto.pyx":118 + * self.buffer.discard_message() + * + * cdef _process__auth(self, char mtype): # <<<<<<<<<<<<<< + * if mtype == b'R': + * # Authentication... + */ + +static PyObject *__pyx_f_7asyncpg_8protocol_8protocol_12CoreProtocol__process__auth(struct __pyx_obj_7asyncpg_8protocol_8protocol_CoreProtocol *__pyx_v_self, char __pyx_v_mtype) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_t_2; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + int __pyx_t_5; + __Pyx_RefNannySetupContext("_process__auth", 0); + + /* "asyncpg/protocol/coreproto.pyx":119 + * + * cdef _process__auth(self, char mtype): + * if mtype == b'R': # <<<<<<<<<<<<<< + * # Authentication... + * self._parse_msg_authentication() + */ + switch (__pyx_v_mtype) { + case 'R': + + /* "asyncpg/protocol/coreproto.pyx":121 + * if mtype == b'R': + * # Authentication... + * self._parse_msg_authentication() # <<<<<<<<<<<<<< + * if self.result_type != RESULT_OK: + * self.con_status = CONNECTION_BAD + */ + __pyx_t_1 = ((struct __pyx_vtabstruct_7asyncpg_8protocol_8protocol_CoreProtocol *)__pyx_v_self->__pyx_vtab)->_parse_msg_authentication(__pyx_v_self); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 121, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "asyncpg/protocol/coreproto.pyx":122 + * # Authentication... + * self._parse_msg_authentication() + * if self.result_type != RESULT_OK: # <<<<<<<<<<<<<< + * self.con_status = CONNECTION_BAD + * self._push_result() + */ + __pyx_t_2 = ((__pyx_v_self->result_type != __pyx_e_7asyncpg_8protocol_8protocol_RESULT_OK) != 0); + if (__pyx_t_2) { + + /* "asyncpg/protocol/coreproto.pyx":123 + * self._parse_msg_authentication() + * if self.result_type != RESULT_OK: + * self.con_status = CONNECTION_BAD # <<<<<<<<<<<<<< + * self._push_result() + * self.transport.close() + */ + __pyx_v_self->con_status = __pyx_e_7asyncpg_8protocol_8protocol_CONNECTION_BAD; + + /* "asyncpg/protocol/coreproto.pyx":124 + * if self.result_type != RESULT_OK: + * self.con_status = CONNECTION_BAD + * self._push_result() # <<<<<<<<<<<<<< + * self.transport.close() + * + */ + __pyx_t_1 = ((struct __pyx_vtabstruct_7asyncpg_8protocol_8protocol_CoreProtocol *)__pyx_v_self->__pyx_vtab)->_push_result(__pyx_v_self); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 124, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "asyncpg/protocol/coreproto.pyx":125 + * self.con_status = CONNECTION_BAD + * self._push_result() + * self.transport.close() # <<<<<<<<<<<<<< + * + * elif self.auth_msg is not None: + */ + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_self->transport, __pyx_n_s_close); if (unlikely(!__pyx_t_3)) __PYX_ERR(4, 125, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = NULL; + if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_3))) { + __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_3); + if (likely(__pyx_t_4)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); + __Pyx_INCREF(__pyx_t_4); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_3, function); + } + } + if (__pyx_t_4) { + __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_4); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 125, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + } else { + __pyx_t_1 = __Pyx_PyObject_CallNoArg(__pyx_t_3); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 125, __pyx_L1_error) + } + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "asyncpg/protocol/coreproto.pyx":122 + * # Authentication... + * self._parse_msg_authentication() + * if self.result_type != RESULT_OK: # <<<<<<<<<<<<<< + * self.con_status = CONNECTION_BAD + * self._push_result() + */ + goto __pyx_L3; + } + + /* "asyncpg/protocol/coreproto.pyx":127 + * self.transport.close() + * + * elif self.auth_msg is not None: # <<<<<<<<<<<<<< + * # Server wants us to send auth data, so do that. + * self._write(self.auth_msg) + */ + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_auth_msg); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 127, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = (__pyx_t_1 != Py_None); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_5 = (__pyx_t_2 != 0); + if (__pyx_t_5) { + + /* "asyncpg/protocol/coreproto.pyx":129 + * elif self.auth_msg is not None: + * # Server wants us to send auth data, so do that. + * self._write(self.auth_msg) # <<<<<<<<<<<<<< + * self.auth_msg = None + * + */ + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_auth_msg); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 129, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_3 = ((struct __pyx_vtabstruct_7asyncpg_8protocol_8protocol_CoreProtocol *)__pyx_v_self->__pyx_vtab)->_write(__pyx_v_self, __pyx_t_1); if (unlikely(!__pyx_t_3)) __PYX_ERR(4, 129, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + + /* "asyncpg/protocol/coreproto.pyx":130 + * # Server wants us to send auth data, so do that. + * self._write(self.auth_msg) + * self.auth_msg = None # <<<<<<<<<<<<<< + * + * elif mtype == b'K': + */ + if (__Pyx_PyObject_SetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_auth_msg, Py_None) < 0) __PYX_ERR(4, 130, __pyx_L1_error) + + /* "asyncpg/protocol/coreproto.pyx":127 + * self.transport.close() + * + * elif self.auth_msg is not None: # <<<<<<<<<<<<<< + * # Server wants us to send auth data, so do that. + * self._write(self.auth_msg) + */ + } + __pyx_L3:; + + /* "asyncpg/protocol/coreproto.pyx":119 + * + * cdef _process__auth(self, char mtype): + * if mtype == b'R': # <<<<<<<<<<<<<< + * # Authentication... + * self._parse_msg_authentication() + */ + break; + + /* "asyncpg/protocol/coreproto.pyx":132 + * self.auth_msg = None + * + * elif mtype == b'K': # <<<<<<<<<<<<<< + * # BackendKeyData + * self._parse_msg_backend_key_data() + */ + case 'K': + + /* "asyncpg/protocol/coreproto.pyx":134 + * elif mtype == b'K': + * # BackendKeyData + * self._parse_msg_backend_key_data() # <<<<<<<<<<<<<< + * + * elif mtype == b'E': + */ + __pyx_t_3 = ((struct __pyx_vtabstruct_7asyncpg_8protocol_8protocol_CoreProtocol *)__pyx_v_self->__pyx_vtab)->_parse_msg_backend_key_data(__pyx_v_self); if (unlikely(!__pyx_t_3)) __PYX_ERR(4, 134, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + + /* "asyncpg/protocol/coreproto.pyx":132 + * self.auth_msg = None + * + * elif mtype == b'K': # <<<<<<<<<<<<<< + * # BackendKeyData + * self._parse_msg_backend_key_data() + */ + break; + + /* "asyncpg/protocol/coreproto.pyx":136 + * self._parse_msg_backend_key_data() + * + * elif mtype == b'E': # <<<<<<<<<<<<<< + * # ErrorResponse + * self.con_status = CONNECTION_BAD + */ + case 'E': + + /* "asyncpg/protocol/coreproto.pyx":138 + * elif mtype == b'E': + * # ErrorResponse + * self.con_status = CONNECTION_BAD # <<<<<<<<<<<<<< + * self._parse_msg_error_response(True) + * self._push_result() + */ + __pyx_v_self->con_status = __pyx_e_7asyncpg_8protocol_8protocol_CONNECTION_BAD; + + /* "asyncpg/protocol/coreproto.pyx":139 + * # ErrorResponse + * self.con_status = CONNECTION_BAD + * self._parse_msg_error_response(True) # <<<<<<<<<<<<<< + * self._push_result() + * + */ + __pyx_t_3 = ((struct __pyx_vtabstruct_7asyncpg_8protocol_8protocol_CoreProtocol *)__pyx_v_self->__pyx_vtab)->_parse_msg_error_response(__pyx_v_self, Py_True); if (unlikely(!__pyx_t_3)) __PYX_ERR(4, 139, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + + /* "asyncpg/protocol/coreproto.pyx":140 + * self.con_status = CONNECTION_BAD + * self._parse_msg_error_response(True) + * self._push_result() # <<<<<<<<<<<<<< + * + * elif mtype == b'Z': + */ + __pyx_t_3 = ((struct __pyx_vtabstruct_7asyncpg_8protocol_8protocol_CoreProtocol *)__pyx_v_self->__pyx_vtab)->_push_result(__pyx_v_self); if (unlikely(!__pyx_t_3)) __PYX_ERR(4, 140, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + + /* "asyncpg/protocol/coreproto.pyx":136 + * self._parse_msg_backend_key_data() + * + * elif mtype == b'E': # <<<<<<<<<<<<<< + * # ErrorResponse + * self.con_status = CONNECTION_BAD + */ + break; + + /* "asyncpg/protocol/coreproto.pyx":142 + * self._push_result() + * + * elif mtype == b'Z': # <<<<<<<<<<<<<< + * # ReadyForQuery + * self._parse_msg_ready_for_query() + */ + case 'Z': + + /* "asyncpg/protocol/coreproto.pyx":144 + * elif mtype == b'Z': + * # ReadyForQuery + * self._parse_msg_ready_for_query() # <<<<<<<<<<<<<< + * self.con_status = CONNECTION_OK + * self._push_result() + */ + __pyx_t_3 = ((struct __pyx_vtabstruct_7asyncpg_8protocol_8protocol_CoreProtocol *)__pyx_v_self->__pyx_vtab)->_parse_msg_ready_for_query(__pyx_v_self); if (unlikely(!__pyx_t_3)) __PYX_ERR(4, 144, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + + /* "asyncpg/protocol/coreproto.pyx":145 + * # ReadyForQuery + * self._parse_msg_ready_for_query() + * self.con_status = CONNECTION_OK # <<<<<<<<<<<<<< + * self._push_result() + * + */ + __pyx_v_self->con_status = __pyx_e_7asyncpg_8protocol_8protocol_CONNECTION_OK; + + /* "asyncpg/protocol/coreproto.pyx":146 + * self._parse_msg_ready_for_query() + * self.con_status = CONNECTION_OK + * self._push_result() # <<<<<<<<<<<<<< + * + * cdef _process__prepare(self, char mtype): + */ + __pyx_t_3 = ((struct __pyx_vtabstruct_7asyncpg_8protocol_8protocol_CoreProtocol *)__pyx_v_self->__pyx_vtab)->_push_result(__pyx_v_self); if (unlikely(!__pyx_t_3)) __PYX_ERR(4, 146, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + + /* "asyncpg/protocol/coreproto.pyx":142 + * self._push_result() + * + * elif mtype == b'Z': # <<<<<<<<<<<<<< + * # ReadyForQuery + * self._parse_msg_ready_for_query() + */ + break; + default: break; + } + + /* "asyncpg/protocol/coreproto.pyx":118 + * self.buffer.discard_message() + * + * cdef _process__auth(self, char mtype): # <<<<<<<<<<<<<< + * if mtype == b'R': + * # Authentication... + */ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_AddTraceback("asyncpg.protocol.protocol.CoreProtocol._process__auth", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "asyncpg/protocol/coreproto.pyx":148 + * self._push_result() + * + * cdef _process__prepare(self, char mtype): # <<<<<<<<<<<<<< + * if mtype == b't': + * # Parameters description + */ + +static PyObject *__pyx_f_7asyncpg_8protocol_8protocol_12CoreProtocol__process__prepare(struct __pyx_obj_7asyncpg_8protocol_8protocol_CoreProtocol *__pyx_v_self, char __pyx_v_mtype) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + __Pyx_RefNannySetupContext("_process__prepare", 0); + + /* "asyncpg/protocol/coreproto.pyx":149 + * + * cdef _process__prepare(self, char mtype): + * if mtype == b't': # <<<<<<<<<<<<<< + * # Parameters description + * self.result_param_desc = self.buffer.consume_message().as_bytes() + */ + switch (__pyx_v_mtype) { + case 't': + + /* "asyncpg/protocol/coreproto.pyx":151 + * if mtype == b't': + * # Parameters description + * self.result_param_desc = self.buffer.consume_message().as_bytes() # <<<<<<<<<<<<<< + * + * elif mtype == b'1': + */ + __pyx_t_1 = ((PyObject *)__pyx_f_7asyncpg_8protocol_8protocol_10ReadBuffer_consume_message(__pyx_v_self->buffer)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 151, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = __pyx_f_7asyncpg_8protocol_8protocol_6Memory_as_bytes(((struct __pyx_obj_7asyncpg_8protocol_8protocol_Memory *)__pyx_t_1)); if (unlikely(!__pyx_t_2)) __PYX_ERR(4, 151, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + if (!(likely(PyBytes_CheckExact(__pyx_t_2))||((__pyx_t_2) == Py_None)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "bytes", Py_TYPE(__pyx_t_2)->tp_name), 0))) __PYX_ERR(4, 151, __pyx_L1_error) + __Pyx_GIVEREF(__pyx_t_2); + __Pyx_GOTREF(__pyx_v_self->result_param_desc); + __Pyx_DECREF(__pyx_v_self->result_param_desc); + __pyx_v_self->result_param_desc = ((PyObject*)__pyx_t_2); + __pyx_t_2 = 0; + + /* "asyncpg/protocol/coreproto.pyx":149 + * + * cdef _process__prepare(self, char mtype): + * if mtype == b't': # <<<<<<<<<<<<<< + * # Parameters description + * self.result_param_desc = self.buffer.consume_message().as_bytes() + */ + break; + + /* "asyncpg/protocol/coreproto.pyx":153 + * self.result_param_desc = self.buffer.consume_message().as_bytes() + * + * elif mtype == b'1': # <<<<<<<<<<<<<< + * # ParseComplete + * self.buffer.consume_message() + */ + case '1': + + /* "asyncpg/protocol/coreproto.pyx":155 + * elif mtype == b'1': + * # ParseComplete + * self.buffer.consume_message() # <<<<<<<<<<<<<< + * + * elif mtype == b'T': + */ + __pyx_t_2 = ((PyObject *)__pyx_f_7asyncpg_8protocol_8protocol_10ReadBuffer_consume_message(__pyx_v_self->buffer)); if (unlikely(!__pyx_t_2)) __PYX_ERR(4, 155, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "asyncpg/protocol/coreproto.pyx":153 + * self.result_param_desc = self.buffer.consume_message().as_bytes() + * + * elif mtype == b'1': # <<<<<<<<<<<<<< + * # ParseComplete + * self.buffer.consume_message() + */ + break; + + /* "asyncpg/protocol/coreproto.pyx":157 + * self.buffer.consume_message() + * + * elif mtype == b'T': # <<<<<<<<<<<<<< + * # Row description + * self.result_row_desc = self.buffer.consume_message().as_bytes() + */ + case 'T': + + /* "asyncpg/protocol/coreproto.pyx":159 + * elif mtype == b'T': + * # Row description + * self.result_row_desc = self.buffer.consume_message().as_bytes() # <<<<<<<<<<<<<< + * + * elif mtype == b'E': + */ + __pyx_t_2 = ((PyObject *)__pyx_f_7asyncpg_8protocol_8protocol_10ReadBuffer_consume_message(__pyx_v_self->buffer)); if (unlikely(!__pyx_t_2)) __PYX_ERR(4, 159, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_1 = __pyx_f_7asyncpg_8protocol_8protocol_6Memory_as_bytes(((struct __pyx_obj_7asyncpg_8protocol_8protocol_Memory *)__pyx_t_2)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 159, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + if (!(likely(PyBytes_CheckExact(__pyx_t_1))||((__pyx_t_1) == Py_None)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "bytes", Py_TYPE(__pyx_t_1)->tp_name), 0))) __PYX_ERR(4, 159, __pyx_L1_error) + __Pyx_GIVEREF(__pyx_t_1); + __Pyx_GOTREF(__pyx_v_self->result_row_desc); + __Pyx_DECREF(__pyx_v_self->result_row_desc); + __pyx_v_self->result_row_desc = ((PyObject*)__pyx_t_1); + __pyx_t_1 = 0; + + /* "asyncpg/protocol/coreproto.pyx":157 + * self.buffer.consume_message() + * + * elif mtype == b'T': # <<<<<<<<<<<<<< + * # Row description + * self.result_row_desc = self.buffer.consume_message().as_bytes() + */ + break; + + /* "asyncpg/protocol/coreproto.pyx":161 + * self.result_row_desc = self.buffer.consume_message().as_bytes() + * + * elif mtype == b'E': # <<<<<<<<<<<<<< + * # ErrorResponse + * self._parse_msg_error_response(True) + */ + case 'E': + + /* "asyncpg/protocol/coreproto.pyx":163 + * elif mtype == b'E': + * # ErrorResponse + * self._parse_msg_error_response(True) # <<<<<<<<<<<<<< + * + * elif mtype == b'Z': + */ + __pyx_t_1 = ((struct __pyx_vtabstruct_7asyncpg_8protocol_8protocol_CoreProtocol *)__pyx_v_self->__pyx_vtab)->_parse_msg_error_response(__pyx_v_self, Py_True); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 163, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "asyncpg/protocol/coreproto.pyx":161 + * self.result_row_desc = self.buffer.consume_message().as_bytes() + * + * elif mtype == b'E': # <<<<<<<<<<<<<< + * # ErrorResponse + * self._parse_msg_error_response(True) + */ + break; + + /* "asyncpg/protocol/coreproto.pyx":165 + * self._parse_msg_error_response(True) + * + * elif mtype == b'Z': # <<<<<<<<<<<<<< + * # ReadyForQuery + * self._parse_msg_ready_for_query() + */ + case 'Z': + + /* "asyncpg/protocol/coreproto.pyx":167 + * elif mtype == b'Z': + * # ReadyForQuery + * self._parse_msg_ready_for_query() # <<<<<<<<<<<<<< + * self._push_result() + * + */ + __pyx_t_1 = ((struct __pyx_vtabstruct_7asyncpg_8protocol_8protocol_CoreProtocol *)__pyx_v_self->__pyx_vtab)->_parse_msg_ready_for_query(__pyx_v_self); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 167, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "asyncpg/protocol/coreproto.pyx":168 + * # ReadyForQuery + * self._parse_msg_ready_for_query() + * self._push_result() # <<<<<<<<<<<<<< + * + * elif mtype == b'n': + */ + __pyx_t_1 = ((struct __pyx_vtabstruct_7asyncpg_8protocol_8protocol_CoreProtocol *)__pyx_v_self->__pyx_vtab)->_push_result(__pyx_v_self); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 168, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "asyncpg/protocol/coreproto.pyx":165 + * self._parse_msg_error_response(True) + * + * elif mtype == b'Z': # <<<<<<<<<<<<<< + * # ReadyForQuery + * self._parse_msg_ready_for_query() + */ + break; + + /* "asyncpg/protocol/coreproto.pyx":170 + * self._push_result() + * + * elif mtype == b'n': # <<<<<<<<<<<<<< + * # NoData + * self.buffer.consume_message() + */ + case 'n': + + /* "asyncpg/protocol/coreproto.pyx":172 + * elif mtype == b'n': + * # NoData + * self.buffer.consume_message() # <<<<<<<<<<<<<< + * + * cdef _process__bind_execute(self, char mtype): + */ + __pyx_t_1 = ((PyObject *)__pyx_f_7asyncpg_8protocol_8protocol_10ReadBuffer_consume_message(__pyx_v_self->buffer)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 172, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "asyncpg/protocol/coreproto.pyx":170 + * self._push_result() + * + * elif mtype == b'n': # <<<<<<<<<<<<<< + * # NoData + * self.buffer.consume_message() + */ + break; + default: break; + } + + /* "asyncpg/protocol/coreproto.pyx":148 + * self._push_result() + * + * cdef _process__prepare(self, char mtype): # <<<<<<<<<<<<<< + * if mtype == b't': + * # Parameters description + */ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_AddTraceback("asyncpg.protocol.protocol.CoreProtocol._process__prepare", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "asyncpg/protocol/coreproto.pyx":174 + * self.buffer.consume_message() + * + * cdef _process__bind_execute(self, char mtype): # <<<<<<<<<<<<<< + * if mtype == b'D': + * # DataRow + */ + +static PyObject *__pyx_f_7asyncpg_8protocol_8protocol_12CoreProtocol__process__bind_execute(struct __pyx_obj_7asyncpg_8protocol_8protocol_CoreProtocol *__pyx_v_self, char __pyx_v_mtype) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + __Pyx_RefNannySetupContext("_process__bind_execute", 0); + + /* "asyncpg/protocol/coreproto.pyx":175 + * + * cdef _process__bind_execute(self, char mtype): + * if mtype == b'D': # <<<<<<<<<<<<<< + * # DataRow + * self._parse_data_msgs() + */ + switch (__pyx_v_mtype) { + case 'D': + + /* "asyncpg/protocol/coreproto.pyx":177 + * if mtype == b'D': + * # DataRow + * self._parse_data_msgs() # <<<<<<<<<<<<<< + * + * elif mtype == b's': + */ + __pyx_t_1 = ((struct __pyx_vtabstruct_7asyncpg_8protocol_8protocol_CoreProtocol *)__pyx_v_self->__pyx_vtab)->_parse_data_msgs(__pyx_v_self); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 177, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "asyncpg/protocol/coreproto.pyx":175 + * + * cdef _process__bind_execute(self, char mtype): + * if mtype == b'D': # <<<<<<<<<<<<<< + * # DataRow + * self._parse_data_msgs() + */ + break; + + /* "asyncpg/protocol/coreproto.pyx":179 + * self._parse_data_msgs() + * + * elif mtype == b's': # <<<<<<<<<<<<<< + * # PortalSuspended + * self.buffer.consume_message() + */ + case 's': + + /* "asyncpg/protocol/coreproto.pyx":181 + * elif mtype == b's': + * # PortalSuspended + * self.buffer.consume_message() # <<<<<<<<<<<<<< + * + * elif mtype == b'C': + */ + __pyx_t_1 = ((PyObject *)__pyx_f_7asyncpg_8protocol_8protocol_10ReadBuffer_consume_message(__pyx_v_self->buffer)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 181, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "asyncpg/protocol/coreproto.pyx":179 + * self._parse_data_msgs() + * + * elif mtype == b's': # <<<<<<<<<<<<<< + * # PortalSuspended + * self.buffer.consume_message() + */ + break; + + /* "asyncpg/protocol/coreproto.pyx":183 + * self.buffer.consume_message() + * + * elif mtype == b'C': # <<<<<<<<<<<<<< + * # CommandComplete + * self.result_execute_completed = True + */ + case 'C': + + /* "asyncpg/protocol/coreproto.pyx":185 + * elif mtype == b'C': + * # CommandComplete + * self.result_execute_completed = True # <<<<<<<<<<<<<< + * self._parse_msg_command_complete() + * + */ + __pyx_v_self->result_execute_completed = 1; + + /* "asyncpg/protocol/coreproto.pyx":186 + * # CommandComplete + * self.result_execute_completed = True + * self._parse_msg_command_complete() # <<<<<<<<<<<<<< + * + * elif mtype == b'E': + */ + __pyx_t_1 = ((struct __pyx_vtabstruct_7asyncpg_8protocol_8protocol_CoreProtocol *)__pyx_v_self->__pyx_vtab)->_parse_msg_command_complete(__pyx_v_self); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 186, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "asyncpg/protocol/coreproto.pyx":183 + * self.buffer.consume_message() + * + * elif mtype == b'C': # <<<<<<<<<<<<<< + * # CommandComplete + * self.result_execute_completed = True + */ + break; + + /* "asyncpg/protocol/coreproto.pyx":188 + * self._parse_msg_command_complete() + * + * elif mtype == b'E': # <<<<<<<<<<<<<< + * # ErrorResponse + * self._parse_msg_error_response(True) + */ + case 'E': + + /* "asyncpg/protocol/coreproto.pyx":190 + * elif mtype == b'E': + * # ErrorResponse + * self._parse_msg_error_response(True) # <<<<<<<<<<<<<< + * + * elif mtype == b'2': + */ + __pyx_t_1 = ((struct __pyx_vtabstruct_7asyncpg_8protocol_8protocol_CoreProtocol *)__pyx_v_self->__pyx_vtab)->_parse_msg_error_response(__pyx_v_self, Py_True); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 190, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "asyncpg/protocol/coreproto.pyx":188 + * self._parse_msg_command_complete() + * + * elif mtype == b'E': # <<<<<<<<<<<<<< + * # ErrorResponse + * self._parse_msg_error_response(True) + */ + break; + + /* "asyncpg/protocol/coreproto.pyx":192 + * self._parse_msg_error_response(True) + * + * elif mtype == b'2': # <<<<<<<<<<<<<< + * # BindComplete + * self.buffer.consume_message() + */ + case '2': + + /* "asyncpg/protocol/coreproto.pyx":194 + * elif mtype == b'2': + * # BindComplete + * self.buffer.consume_message() # <<<<<<<<<<<<<< + * + * elif mtype == b'Z': + */ + __pyx_t_1 = ((PyObject *)__pyx_f_7asyncpg_8protocol_8protocol_10ReadBuffer_consume_message(__pyx_v_self->buffer)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 194, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "asyncpg/protocol/coreproto.pyx":192 + * self._parse_msg_error_response(True) + * + * elif mtype == b'2': # <<<<<<<<<<<<<< + * # BindComplete + * self.buffer.consume_message() + */ + break; + + /* "asyncpg/protocol/coreproto.pyx":196 + * self.buffer.consume_message() + * + * elif mtype == b'Z': # <<<<<<<<<<<<<< + * # ReadyForQuery + * self._parse_msg_ready_for_query() + */ + case 'Z': + + /* "asyncpg/protocol/coreproto.pyx":198 + * elif mtype == b'Z': + * # ReadyForQuery + * self._parse_msg_ready_for_query() # <<<<<<<<<<<<<< + * self._push_result() + * + */ + __pyx_t_1 = ((struct __pyx_vtabstruct_7asyncpg_8protocol_8protocol_CoreProtocol *)__pyx_v_self->__pyx_vtab)->_parse_msg_ready_for_query(__pyx_v_self); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 198, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "asyncpg/protocol/coreproto.pyx":199 + * # ReadyForQuery + * self._parse_msg_ready_for_query() + * self._push_result() # <<<<<<<<<<<<<< + * + * elif mtype == b'I': + */ + __pyx_t_1 = ((struct __pyx_vtabstruct_7asyncpg_8protocol_8protocol_CoreProtocol *)__pyx_v_self->__pyx_vtab)->_push_result(__pyx_v_self); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 199, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "asyncpg/protocol/coreproto.pyx":196 + * self.buffer.consume_message() + * + * elif mtype == b'Z': # <<<<<<<<<<<<<< + * # ReadyForQuery + * self._parse_msg_ready_for_query() + */ + break; + + /* "asyncpg/protocol/coreproto.pyx":201 + * self._push_result() + * + * elif mtype == b'I': # <<<<<<<<<<<<<< + * # EmptyQueryResponse + * self.buffer.consume_message() + */ + case 'I': + + /* "asyncpg/protocol/coreproto.pyx":203 + * elif mtype == b'I': + * # EmptyQueryResponse + * self.buffer.consume_message() # <<<<<<<<<<<<<< + * + * cdef _process__bind_execute_many(self, char mtype): + */ + __pyx_t_1 = ((PyObject *)__pyx_f_7asyncpg_8protocol_8protocol_10ReadBuffer_consume_message(__pyx_v_self->buffer)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 203, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "asyncpg/protocol/coreproto.pyx":201 + * self._push_result() + * + * elif mtype == b'I': # <<<<<<<<<<<<<< + * # EmptyQueryResponse + * self.buffer.consume_message() + */ + break; + default: break; + } + + /* "asyncpg/protocol/coreproto.pyx":174 + * self.buffer.consume_message() + * + * cdef _process__bind_execute(self, char mtype): # <<<<<<<<<<<<<< + * if mtype == b'D': + * # DataRow + */ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("asyncpg.protocol.protocol.CoreProtocol._process__bind_execute", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "asyncpg/protocol/coreproto.pyx":205 + * self.buffer.consume_message() + * + * cdef _process__bind_execute_many(self, char mtype): # <<<<<<<<<<<<<< + * cdef WriteBuffer buf + * + */ + +static PyObject *__pyx_f_7asyncpg_8protocol_8protocol_12CoreProtocol__process__bind_execute_many(struct __pyx_obj_7asyncpg_8protocol_8protocol_CoreProtocol *__pyx_v_self, char __pyx_v_mtype) { + struct __pyx_obj_7asyncpg_8protocol_8protocol_WriteBuffer *__pyx_v_buf = 0; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_t_2; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + PyObject *__pyx_t_5 = NULL; + PyObject *__pyx_t_6 = NULL; + PyObject *__pyx_t_7 = NULL; + int __pyx_t_8; + PyObject *__pyx_t_9 = NULL; + __Pyx_RefNannySetupContext("_process__bind_execute_many", 0); + + /* "asyncpg/protocol/coreproto.pyx":208 + * cdef WriteBuffer buf + * + * if mtype == b'D': # <<<<<<<<<<<<<< + * # DataRow + * self._parse_data_msgs() + */ + switch (__pyx_v_mtype) { + case 'D': + + /* "asyncpg/protocol/coreproto.pyx":210 + * if mtype == b'D': + * # DataRow + * self._parse_data_msgs() # <<<<<<<<<<<<<< + * + * elif mtype == b's': + */ + __pyx_t_1 = ((struct __pyx_vtabstruct_7asyncpg_8protocol_8protocol_CoreProtocol *)__pyx_v_self->__pyx_vtab)->_parse_data_msgs(__pyx_v_self); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 210, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "asyncpg/protocol/coreproto.pyx":208 + * cdef WriteBuffer buf + * + * if mtype == b'D': # <<<<<<<<<<<<<< + * # DataRow + * self._parse_data_msgs() + */ + break; + + /* "asyncpg/protocol/coreproto.pyx":212 + * self._parse_data_msgs() + * + * elif mtype == b's': # <<<<<<<<<<<<<< + * # PortalSuspended + * self.buffer.consume_message() + */ + case 's': + + /* "asyncpg/protocol/coreproto.pyx":214 + * elif mtype == b's': + * # PortalSuspended + * self.buffer.consume_message() # <<<<<<<<<<<<<< + * + * elif mtype == b'C': + */ + __pyx_t_1 = ((PyObject *)__pyx_f_7asyncpg_8protocol_8protocol_10ReadBuffer_consume_message(__pyx_v_self->buffer)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 214, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "asyncpg/protocol/coreproto.pyx":212 + * self._parse_data_msgs() + * + * elif mtype == b's': # <<<<<<<<<<<<<< + * # PortalSuspended + * self.buffer.consume_message() + */ + break; + + /* "asyncpg/protocol/coreproto.pyx":216 + * self.buffer.consume_message() + * + * elif mtype == b'C': # <<<<<<<<<<<<<< + * # CommandComplete + * self._parse_msg_command_complete() + */ + case 'C': + + /* "asyncpg/protocol/coreproto.pyx":218 + * elif mtype == b'C': + * # CommandComplete + * self._parse_msg_command_complete() # <<<<<<<<<<<<<< + * + * elif mtype == b'E': + */ + __pyx_t_1 = ((struct __pyx_vtabstruct_7asyncpg_8protocol_8protocol_CoreProtocol *)__pyx_v_self->__pyx_vtab)->_parse_msg_command_complete(__pyx_v_self); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 218, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "asyncpg/protocol/coreproto.pyx":216 + * self.buffer.consume_message() + * + * elif mtype == b'C': # <<<<<<<<<<<<<< + * # CommandComplete + * self._parse_msg_command_complete() + */ + break; + + /* "asyncpg/protocol/coreproto.pyx":220 + * self._parse_msg_command_complete() + * + * elif mtype == b'E': # <<<<<<<<<<<<<< + * # ErrorResponse + * self._parse_msg_error_response(True) + */ + case 'E': + + /* "asyncpg/protocol/coreproto.pyx":222 + * elif mtype == b'E': + * # ErrorResponse + * self._parse_msg_error_response(True) # <<<<<<<<<<<<<< + * + * elif mtype == b'2': + */ + __pyx_t_1 = ((struct __pyx_vtabstruct_7asyncpg_8protocol_8protocol_CoreProtocol *)__pyx_v_self->__pyx_vtab)->_parse_msg_error_response(__pyx_v_self, Py_True); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 222, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "asyncpg/protocol/coreproto.pyx":220 + * self._parse_msg_command_complete() + * + * elif mtype == b'E': # <<<<<<<<<<<<<< + * # ErrorResponse + * self._parse_msg_error_response(True) + */ + break; + + /* "asyncpg/protocol/coreproto.pyx":224 + * self._parse_msg_error_response(True) + * + * elif mtype == b'2': # <<<<<<<<<<<<<< + * # BindComplete + * self.buffer.consume_message() + */ + case '2': + + /* "asyncpg/protocol/coreproto.pyx":226 + * elif mtype == b'2': + * # BindComplete + * self.buffer.consume_message() # <<<<<<<<<<<<<< + * + * elif mtype == b'Z': + */ + __pyx_t_1 = ((PyObject *)__pyx_f_7asyncpg_8protocol_8protocol_10ReadBuffer_consume_message(__pyx_v_self->buffer)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 226, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "asyncpg/protocol/coreproto.pyx":224 + * self._parse_msg_error_response(True) + * + * elif mtype == b'2': # <<<<<<<<<<<<<< + * # BindComplete + * self.buffer.consume_message() + */ + break; + + /* "asyncpg/protocol/coreproto.pyx":228 + * self.buffer.consume_message() + * + * elif mtype == b'Z': # <<<<<<<<<<<<<< + * # ReadyForQuery + * self._parse_msg_ready_for_query() + */ + case 'Z': + + /* "asyncpg/protocol/coreproto.pyx":230 + * elif mtype == b'Z': + * # ReadyForQuery + * self._parse_msg_ready_for_query() # <<<<<<<<<<<<<< + * if self.result_type == RESULT_FAILED: + * self._push_result() + */ + __pyx_t_1 = ((struct __pyx_vtabstruct_7asyncpg_8protocol_8protocol_CoreProtocol *)__pyx_v_self->__pyx_vtab)->_parse_msg_ready_for_query(__pyx_v_self); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 230, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "asyncpg/protocol/coreproto.pyx":231 + * # ReadyForQuery + * self._parse_msg_ready_for_query() + * if self.result_type == RESULT_FAILED: # <<<<<<<<<<<<<< + * self._push_result() + * else: + */ + __pyx_t_2 = ((__pyx_v_self->result_type == __pyx_e_7asyncpg_8protocol_8protocol_RESULT_FAILED) != 0); + if (__pyx_t_2) { + + /* "asyncpg/protocol/coreproto.pyx":232 + * self._parse_msg_ready_for_query() + * if self.result_type == RESULT_FAILED: + * self._push_result() # <<<<<<<<<<<<<< + * else: + * try: + */ + __pyx_t_1 = ((struct __pyx_vtabstruct_7asyncpg_8protocol_8protocol_CoreProtocol *)__pyx_v_self->__pyx_vtab)->_push_result(__pyx_v_self); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 232, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "asyncpg/protocol/coreproto.pyx":231 + * # ReadyForQuery + * self._parse_msg_ready_for_query() + * if self.result_type == RESULT_FAILED: # <<<<<<<<<<<<<< + * self._push_result() + * else: + */ + goto __pyx_L3; + } + + /* "asyncpg/protocol/coreproto.pyx":234 + * self._push_result() + * else: + * try: # <<<<<<<<<<<<<< + * buf = next(self._execute_iter) + * except StopIteration: + */ + /*else*/ { + { + __Pyx_PyThreadState_declare + __Pyx_PyThreadState_assign + __Pyx_ExceptionSave(&__pyx_t_3, &__pyx_t_4, &__pyx_t_5); + __Pyx_XGOTREF(__pyx_t_3); + __Pyx_XGOTREF(__pyx_t_4); + __Pyx_XGOTREF(__pyx_t_5); + /*try:*/ { + + /* "asyncpg/protocol/coreproto.pyx":235 + * else: + * try: + * buf = next(self._execute_iter) # <<<<<<<<<<<<<< + * except StopIteration: + * self._push_result() + */ + __pyx_t_1 = __pyx_v_self->_execute_iter; + __Pyx_INCREF(__pyx_t_1); + __pyx_t_6 = __Pyx_PyIter_Next(__pyx_t_1); if (unlikely(!__pyx_t_6)) __PYX_ERR(4, 235, __pyx_L4_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_1 = __pyx_t_6; + __Pyx_INCREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __pyx_v_buf = ((struct __pyx_obj_7asyncpg_8protocol_8protocol_WriteBuffer *)__pyx_t_1); + __pyx_t_1 = 0; + + /* "asyncpg/protocol/coreproto.pyx":234 + * self._push_result() + * else: + * try: # <<<<<<<<<<<<<< + * buf = next(self._execute_iter) + * except StopIteration: + */ + } + + /* "asyncpg/protocol/coreproto.pyx":240 + * else: + * # Next iteration over the executemany() arg sequence + * self._send_bind_message( # <<<<<<<<<<<<<< + * self._execute_portal_name, self._execute_stmt_name, + * buf, 0) + */ + /*else:*/ { + + /* "asyncpg/protocol/coreproto.pyx":241 + * # Next iteration over the executemany() arg sequence + * self._send_bind_message( + * self._execute_portal_name, self._execute_stmt_name, # <<<<<<<<<<<<<< + * buf, 0) + * + */ + __pyx_t_1 = __pyx_v_self->_execute_portal_name; + __Pyx_INCREF(__pyx_t_1); + __pyx_t_6 = __pyx_v_self->_execute_stmt_name; + __Pyx_INCREF(__pyx_t_6); + + /* "asyncpg/protocol/coreproto.pyx":240 + * else: + * # Next iteration over the executemany() arg sequence + * self._send_bind_message( # <<<<<<<<<<<<<< + * self._execute_portal_name, self._execute_stmt_name, + * buf, 0) + */ + __pyx_t_7 = ((struct __pyx_vtabstruct_7asyncpg_8protocol_8protocol_CoreProtocol *)__pyx_v_self->__pyx_vtab)->_send_bind_message(__pyx_v_self, ((PyObject*)__pyx_t_1), ((PyObject*)__pyx_t_6), __pyx_v_buf, 0); if (unlikely(!__pyx_t_7)) __PYX_ERR(4, 240, __pyx_L6_except_error) + __Pyx_GOTREF(__pyx_t_7); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + } + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; + goto __pyx_L11_try_end; + __pyx_L4_error:; + __Pyx_PyThreadState_assign + __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "asyncpg/protocol/coreproto.pyx":236 + * try: + * buf = next(self._execute_iter) + * except StopIteration: # <<<<<<<<<<<<<< + * self._push_result() + * else: + */ + __pyx_t_8 = __Pyx_PyErr_ExceptionMatches(__pyx_builtin_StopIteration); + if (__pyx_t_8) { + __Pyx_AddTraceback("asyncpg.protocol.protocol.CoreProtocol._process__bind_execute_many", __pyx_clineno, __pyx_lineno, __pyx_filename); + if (__Pyx_GetException(&__pyx_t_7, &__pyx_t_6, &__pyx_t_1) < 0) __PYX_ERR(4, 236, __pyx_L6_except_error) + __Pyx_GOTREF(__pyx_t_7); + __Pyx_GOTREF(__pyx_t_6); + __Pyx_GOTREF(__pyx_t_1); + + /* "asyncpg/protocol/coreproto.pyx":237 + * buf = next(self._execute_iter) + * except StopIteration: + * self._push_result() # <<<<<<<<<<<<<< + * else: + * # Next iteration over the executemany() arg sequence + */ + __pyx_t_9 = ((struct __pyx_vtabstruct_7asyncpg_8protocol_8protocol_CoreProtocol *)__pyx_v_self->__pyx_vtab)->_push_result(__pyx_v_self); if (unlikely(!__pyx_t_9)) __PYX_ERR(4, 237, __pyx_L6_except_error) + __Pyx_GOTREF(__pyx_t_9); + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + goto __pyx_L5_exception_handled; + } + goto __pyx_L6_except_error; + __pyx_L6_except_error:; + + /* "asyncpg/protocol/coreproto.pyx":234 + * self._push_result() + * else: + * try: # <<<<<<<<<<<<<< + * buf = next(self._execute_iter) + * except StopIteration: + */ + __Pyx_PyThreadState_assign + __Pyx_XGIVEREF(__pyx_t_3); + __Pyx_XGIVEREF(__pyx_t_4); + __Pyx_XGIVEREF(__pyx_t_5); + __Pyx_ExceptionReset(__pyx_t_3, __pyx_t_4, __pyx_t_5); + goto __pyx_L1_error; + __pyx_L5_exception_handled:; + __Pyx_PyThreadState_assign + __Pyx_XGIVEREF(__pyx_t_3); + __Pyx_XGIVEREF(__pyx_t_4); + __Pyx_XGIVEREF(__pyx_t_5); + __Pyx_ExceptionReset(__pyx_t_3, __pyx_t_4, __pyx_t_5); + __pyx_L11_try_end:; + } + } + __pyx_L3:; + + /* "asyncpg/protocol/coreproto.pyx":228 + * self.buffer.consume_message() + * + * elif mtype == b'Z': # <<<<<<<<<<<<<< + * # ReadyForQuery + * self._parse_msg_ready_for_query() + */ + break; + + /* "asyncpg/protocol/coreproto.pyx":244 + * buf, 0) + * + * elif mtype == b'I': # <<<<<<<<<<<<<< + * # EmptyQueryResponse + * self.buffer.consume_message() + */ + case 'I': + + /* "asyncpg/protocol/coreproto.pyx":246 + * elif mtype == b'I': + * # EmptyQueryResponse + * self.buffer.consume_message() # <<<<<<<<<<<<<< + * + * cdef _process__bind(self, char mtype): + */ + __pyx_t_1 = ((PyObject *)__pyx_f_7asyncpg_8protocol_8protocol_10ReadBuffer_consume_message(__pyx_v_self->buffer)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 246, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "asyncpg/protocol/coreproto.pyx":244 + * buf, 0) + * + * elif mtype == b'I': # <<<<<<<<<<<<<< + * # EmptyQueryResponse + * self.buffer.consume_message() + */ + break; + default: break; + } + + /* "asyncpg/protocol/coreproto.pyx":205 + * self.buffer.consume_message() + * + * cdef _process__bind_execute_many(self, char mtype): # <<<<<<<<<<<<<< + * cdef WriteBuffer buf + * + */ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_6); + __Pyx_XDECREF(__pyx_t_7); + __Pyx_XDECREF(__pyx_t_9); + __Pyx_AddTraceback("asyncpg.protocol.protocol.CoreProtocol._process__bind_execute_many", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XDECREF((PyObject *)__pyx_v_buf); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "asyncpg/protocol/coreproto.pyx":248 + * self.buffer.consume_message() + * + * cdef _process__bind(self, char mtype): # <<<<<<<<<<<<<< + * if mtype == b'E': + * # ErrorResponse + */ + +static PyObject *__pyx_f_7asyncpg_8protocol_8protocol_12CoreProtocol__process__bind(struct __pyx_obj_7asyncpg_8protocol_8protocol_CoreProtocol *__pyx_v_self, char __pyx_v_mtype) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + __Pyx_RefNannySetupContext("_process__bind", 0); + + /* "asyncpg/protocol/coreproto.pyx":249 + * + * cdef _process__bind(self, char mtype): + * if mtype == b'E': # <<<<<<<<<<<<<< + * # ErrorResponse + * self._parse_msg_error_response(True) + */ + switch (__pyx_v_mtype) { + case 'E': + + /* "asyncpg/protocol/coreproto.pyx":251 + * if mtype == b'E': + * # ErrorResponse + * self._parse_msg_error_response(True) # <<<<<<<<<<<<<< + * + * elif mtype == b'2': + */ + __pyx_t_1 = ((struct __pyx_vtabstruct_7asyncpg_8protocol_8protocol_CoreProtocol *)__pyx_v_self->__pyx_vtab)->_parse_msg_error_response(__pyx_v_self, Py_True); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 251, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "asyncpg/protocol/coreproto.pyx":249 + * + * cdef _process__bind(self, char mtype): + * if mtype == b'E': # <<<<<<<<<<<<<< + * # ErrorResponse + * self._parse_msg_error_response(True) + */ + break; + + /* "asyncpg/protocol/coreproto.pyx":253 + * self._parse_msg_error_response(True) + * + * elif mtype == b'2': # <<<<<<<<<<<<<< + * # BindComplete + * self.buffer.consume_message() + */ + case '2': + + /* "asyncpg/protocol/coreproto.pyx":255 + * elif mtype == b'2': + * # BindComplete + * self.buffer.consume_message() # <<<<<<<<<<<<<< + * + * elif mtype == b'Z': + */ + __pyx_t_1 = ((PyObject *)__pyx_f_7asyncpg_8protocol_8protocol_10ReadBuffer_consume_message(__pyx_v_self->buffer)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 255, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "asyncpg/protocol/coreproto.pyx":253 + * self._parse_msg_error_response(True) + * + * elif mtype == b'2': # <<<<<<<<<<<<<< + * # BindComplete + * self.buffer.consume_message() + */ + break; + + /* "asyncpg/protocol/coreproto.pyx":257 + * self.buffer.consume_message() + * + * elif mtype == b'Z': # <<<<<<<<<<<<<< + * # ReadyForQuery + * self._parse_msg_ready_for_query() + */ + case 'Z': + + /* "asyncpg/protocol/coreproto.pyx":259 + * elif mtype == b'Z': + * # ReadyForQuery + * self._parse_msg_ready_for_query() # <<<<<<<<<<<<<< + * self._push_result() + * + */ + __pyx_t_1 = ((struct __pyx_vtabstruct_7asyncpg_8protocol_8protocol_CoreProtocol *)__pyx_v_self->__pyx_vtab)->_parse_msg_ready_for_query(__pyx_v_self); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 259, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "asyncpg/protocol/coreproto.pyx":260 + * # ReadyForQuery + * self._parse_msg_ready_for_query() + * self._push_result() # <<<<<<<<<<<<<< + * + * cdef _process__close_stmt_portal(self, char mtype): + */ + __pyx_t_1 = ((struct __pyx_vtabstruct_7asyncpg_8protocol_8protocol_CoreProtocol *)__pyx_v_self->__pyx_vtab)->_push_result(__pyx_v_self); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 260, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "asyncpg/protocol/coreproto.pyx":257 + * self.buffer.consume_message() + * + * elif mtype == b'Z': # <<<<<<<<<<<<<< + * # ReadyForQuery + * self._parse_msg_ready_for_query() + */ + break; + default: break; + } + + /* "asyncpg/protocol/coreproto.pyx":248 + * self.buffer.consume_message() + * + * cdef _process__bind(self, char mtype): # <<<<<<<<<<<<<< + * if mtype == b'E': + * # ErrorResponse + */ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("asyncpg.protocol.protocol.CoreProtocol._process__bind", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "asyncpg/protocol/coreproto.pyx":262 + * self._push_result() + * + * cdef _process__close_stmt_portal(self, char mtype): # <<<<<<<<<<<<<< + * if mtype == b'E': + * # ErrorResponse + */ + +static PyObject *__pyx_f_7asyncpg_8protocol_8protocol_12CoreProtocol__process__close_stmt_portal(struct __pyx_obj_7asyncpg_8protocol_8protocol_CoreProtocol *__pyx_v_self, char __pyx_v_mtype) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + __Pyx_RefNannySetupContext("_process__close_stmt_portal", 0); + + /* "asyncpg/protocol/coreproto.pyx":263 + * + * cdef _process__close_stmt_portal(self, char mtype): + * if mtype == b'E': # <<<<<<<<<<<<<< + * # ErrorResponse + * self._parse_msg_error_response(True) + */ + switch (__pyx_v_mtype) { + case 'E': + + /* "asyncpg/protocol/coreproto.pyx":265 + * if mtype == b'E': + * # ErrorResponse + * self._parse_msg_error_response(True) # <<<<<<<<<<<<<< + * + * elif mtype == b'3': + */ + __pyx_t_1 = ((struct __pyx_vtabstruct_7asyncpg_8protocol_8protocol_CoreProtocol *)__pyx_v_self->__pyx_vtab)->_parse_msg_error_response(__pyx_v_self, Py_True); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 265, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "asyncpg/protocol/coreproto.pyx":263 + * + * cdef _process__close_stmt_portal(self, char mtype): + * if mtype == b'E': # <<<<<<<<<<<<<< + * # ErrorResponse + * self._parse_msg_error_response(True) + */ + break; + + /* "asyncpg/protocol/coreproto.pyx":267 + * self._parse_msg_error_response(True) + * + * elif mtype == b'3': # <<<<<<<<<<<<<< + * # CloseComplete + * self.buffer.consume_message() + */ + case '3': + + /* "asyncpg/protocol/coreproto.pyx":269 + * elif mtype == b'3': + * # CloseComplete + * self.buffer.consume_message() # <<<<<<<<<<<<<< + * + * elif mtype == b'Z': + */ + __pyx_t_1 = ((PyObject *)__pyx_f_7asyncpg_8protocol_8protocol_10ReadBuffer_consume_message(__pyx_v_self->buffer)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 269, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "asyncpg/protocol/coreproto.pyx":267 + * self._parse_msg_error_response(True) + * + * elif mtype == b'3': # <<<<<<<<<<<<<< + * # CloseComplete + * self.buffer.consume_message() + */ + break; + + /* "asyncpg/protocol/coreproto.pyx":271 + * self.buffer.consume_message() + * + * elif mtype == b'Z': # <<<<<<<<<<<<<< + * # ReadyForQuery + * self._parse_msg_ready_for_query() + */ + case 'Z': + + /* "asyncpg/protocol/coreproto.pyx":273 + * elif mtype == b'Z': + * # ReadyForQuery + * self._parse_msg_ready_for_query() # <<<<<<<<<<<<<< + * self._push_result() + * + */ + __pyx_t_1 = ((struct __pyx_vtabstruct_7asyncpg_8protocol_8protocol_CoreProtocol *)__pyx_v_self->__pyx_vtab)->_parse_msg_ready_for_query(__pyx_v_self); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 273, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "asyncpg/protocol/coreproto.pyx":274 + * # ReadyForQuery + * self._parse_msg_ready_for_query() + * self._push_result() # <<<<<<<<<<<<<< + * + * cdef _process__simple_query(self, char mtype): + */ + __pyx_t_1 = ((struct __pyx_vtabstruct_7asyncpg_8protocol_8protocol_CoreProtocol *)__pyx_v_self->__pyx_vtab)->_push_result(__pyx_v_self); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 274, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "asyncpg/protocol/coreproto.pyx":271 + * self.buffer.consume_message() + * + * elif mtype == b'Z': # <<<<<<<<<<<<<< + * # ReadyForQuery + * self._parse_msg_ready_for_query() + */ + break; + default: break; + } + + /* "asyncpg/protocol/coreproto.pyx":262 + * self._push_result() + * + * cdef _process__close_stmt_portal(self, char mtype): # <<<<<<<<<<<<<< + * if mtype == b'E': + * # ErrorResponse + */ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("asyncpg.protocol.protocol.CoreProtocol._process__close_stmt_portal", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "asyncpg/protocol/coreproto.pyx":276 + * self._push_result() + * + * cdef _process__simple_query(self, char mtype): # <<<<<<<<<<<<<< + * if mtype in {b'D', b'I', b'N', b'T'}: + * # 'D' - DataRow + */ + +static PyObject *__pyx_f_7asyncpg_8protocol_8protocol_12CoreProtocol__process__simple_query(struct __pyx_obj_7asyncpg_8protocol_8protocol_CoreProtocol *__pyx_v_self, char __pyx_v_mtype) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + __Pyx_RefNannySetupContext("_process__simple_query", 0); + + /* "asyncpg/protocol/coreproto.pyx":277 + * + * cdef _process__simple_query(self, char mtype): + * if mtype in {b'D', b'I', b'N', b'T'}: # <<<<<<<<<<<<<< + * # 'D' - DataRow + * # 'I' - EmptyQueryResponse + */ + switch (__pyx_v_mtype) { + case 'D': + case 'I': + case 'N': + case 'T': + + /* "asyncpg/protocol/coreproto.pyx":282 + * # 'N' - NoticeResponse + * # 'T' - RowDescription + * self.buffer.consume_message() # <<<<<<<<<<<<<< + * + * elif mtype == b'E': + */ + __pyx_t_1 = ((PyObject *)__pyx_f_7asyncpg_8protocol_8protocol_10ReadBuffer_consume_message(__pyx_v_self->buffer)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 282, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "asyncpg/protocol/coreproto.pyx":277 + * + * cdef _process__simple_query(self, char mtype): + * if mtype in {b'D', b'I', b'N', b'T'}: # <<<<<<<<<<<<<< + * # 'D' - DataRow + * # 'I' - EmptyQueryResponse + */ + break; + + /* "asyncpg/protocol/coreproto.pyx":284 + * self.buffer.consume_message() + * + * elif mtype == b'E': # <<<<<<<<<<<<<< + * # ErrorResponse + * self._parse_msg_error_response(True) + */ + case 'E': + + /* "asyncpg/protocol/coreproto.pyx":286 + * elif mtype == b'E': + * # ErrorResponse + * self._parse_msg_error_response(True) # <<<<<<<<<<<<<< + * + * elif mtype == b'Z': + */ + __pyx_t_1 = ((struct __pyx_vtabstruct_7asyncpg_8protocol_8protocol_CoreProtocol *)__pyx_v_self->__pyx_vtab)->_parse_msg_error_response(__pyx_v_self, Py_True); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 286, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "asyncpg/protocol/coreproto.pyx":284 + * self.buffer.consume_message() + * + * elif mtype == b'E': # <<<<<<<<<<<<<< + * # ErrorResponse + * self._parse_msg_error_response(True) + */ + break; + + /* "asyncpg/protocol/coreproto.pyx":288 + * self._parse_msg_error_response(True) + * + * elif mtype == b'Z': # <<<<<<<<<<<<<< + * # ReadyForQuery + * self._parse_msg_ready_for_query() + */ + case 'Z': + + /* "asyncpg/protocol/coreproto.pyx":290 + * elif mtype == b'Z': + * # ReadyForQuery + * self._parse_msg_ready_for_query() # <<<<<<<<<<<<<< + * self._push_result() + * + */ + __pyx_t_1 = ((struct __pyx_vtabstruct_7asyncpg_8protocol_8protocol_CoreProtocol *)__pyx_v_self->__pyx_vtab)->_parse_msg_ready_for_query(__pyx_v_self); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 290, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "asyncpg/protocol/coreproto.pyx":291 + * # ReadyForQuery + * self._parse_msg_ready_for_query() + * self._push_result() # <<<<<<<<<<<<<< + * + * elif mtype == b'C': + */ + __pyx_t_1 = ((struct __pyx_vtabstruct_7asyncpg_8protocol_8protocol_CoreProtocol *)__pyx_v_self->__pyx_vtab)->_push_result(__pyx_v_self); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 291, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "asyncpg/protocol/coreproto.pyx":288 + * self._parse_msg_error_response(True) + * + * elif mtype == b'Z': # <<<<<<<<<<<<<< + * # ReadyForQuery + * self._parse_msg_ready_for_query() + */ + break; + + /* "asyncpg/protocol/coreproto.pyx":293 + * self._push_result() + * + * elif mtype == b'C': # <<<<<<<<<<<<<< + * # CommandComplete + * self._parse_msg_command_complete() + */ + case 'C': + + /* "asyncpg/protocol/coreproto.pyx":295 + * elif mtype == b'C': + * # CommandComplete + * self._parse_msg_command_complete() # <<<<<<<<<<<<<< + * + * else: + */ + __pyx_t_1 = ((struct __pyx_vtabstruct_7asyncpg_8protocol_8protocol_CoreProtocol *)__pyx_v_self->__pyx_vtab)->_parse_msg_command_complete(__pyx_v_self); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 295, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "asyncpg/protocol/coreproto.pyx":293 + * self._push_result() + * + * elif mtype == b'C': # <<<<<<<<<<<<<< + * # CommandComplete + * self._parse_msg_command_complete() + */ + break; + default: + + /* "asyncpg/protocol/coreproto.pyx":299 + * else: + * # We don't really care about COPY IN etc + * self.buffer.consume_message() # <<<<<<<<<<<<<< + * + * cdef _parse_msg_command_complete(self): + */ + __pyx_t_1 = ((PyObject *)__pyx_f_7asyncpg_8protocol_8protocol_10ReadBuffer_consume_message(__pyx_v_self->buffer)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 299, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + break; + } + + /* "asyncpg/protocol/coreproto.pyx":276 + * self._push_result() + * + * cdef _process__simple_query(self, char mtype): # <<<<<<<<<<<<<< + * if mtype in {b'D', b'I', b'N', b'T'}: + * # 'D' - DataRow + */ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("asyncpg.protocol.protocol.CoreProtocol._process__simple_query", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "asyncpg/protocol/coreproto.pyx":301 + * self.buffer.consume_message() + * + * cdef _parse_msg_command_complete(self): # <<<<<<<<<<<<<< + * cdef: + * char* cbuf + */ + +static PyObject *__pyx_f_7asyncpg_8protocol_8protocol_12CoreProtocol__parse_msg_command_complete(struct __pyx_obj_7asyncpg_8protocol_8protocol_CoreProtocol *__pyx_v_self) { + char *__pyx_v_cbuf; + Py_ssize_t __pyx_v_cbuf_len; + PyObject *__pyx_v_msg = NULL; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + int __pyx_t_2; + PyObject *__pyx_t_3 = NULL; + __Pyx_RefNannySetupContext("_parse_msg_command_complete", 0); + + /* "asyncpg/protocol/coreproto.pyx":306 + * ssize_t cbuf_len + * + * cbuf = self.buffer.try_consume_message(&cbuf_len) # <<<<<<<<<<<<<< + * if cbuf != NULL and cbuf_len > 0: + * msg = cpython.PyBytes_FromStringAndSize(cbuf, cbuf_len - 1) + */ + __pyx_v_cbuf = __pyx_f_7asyncpg_8protocol_8protocol_10ReadBuffer_try_consume_message(__pyx_v_self->buffer, (&__pyx_v_cbuf_len)); + + /* "asyncpg/protocol/coreproto.pyx":307 + * + * cbuf = self.buffer.try_consume_message(&cbuf_len) + * if cbuf != NULL and cbuf_len > 0: # <<<<<<<<<<<<<< + * msg = cpython.PyBytes_FromStringAndSize(cbuf, cbuf_len - 1) + * else: + */ + __pyx_t_2 = ((__pyx_v_cbuf != NULL) != 0); + if (__pyx_t_2) { + } else { + __pyx_t_1 = __pyx_t_2; + goto __pyx_L4_bool_binop_done; + } + __pyx_t_2 = ((__pyx_v_cbuf_len > 0) != 0); + __pyx_t_1 = __pyx_t_2; + __pyx_L4_bool_binop_done:; + if (__pyx_t_1) { + + /* "asyncpg/protocol/coreproto.pyx":308 + * cbuf = self.buffer.try_consume_message(&cbuf_len) + * if cbuf != NULL and cbuf_len > 0: + * msg = cpython.PyBytes_FromStringAndSize(cbuf, cbuf_len - 1) # <<<<<<<<<<<<<< + * else: + * msg = self.buffer.read_cstr() + */ + __pyx_t_3 = PyBytes_FromStringAndSize(__pyx_v_cbuf, (__pyx_v_cbuf_len - 1)); if (unlikely(!__pyx_t_3)) __PYX_ERR(4, 308, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_v_msg = __pyx_t_3; + __pyx_t_3 = 0; + + /* "asyncpg/protocol/coreproto.pyx":307 + * + * cbuf = self.buffer.try_consume_message(&cbuf_len) + * if cbuf != NULL and cbuf_len > 0: # <<<<<<<<<<<<<< + * msg = cpython.PyBytes_FromStringAndSize(cbuf, cbuf_len - 1) + * else: + */ + goto __pyx_L3; + } + + /* "asyncpg/protocol/coreproto.pyx":310 + * msg = cpython.PyBytes_FromStringAndSize(cbuf, cbuf_len - 1) + * else: + * msg = self.buffer.read_cstr() # <<<<<<<<<<<<<< + * self.result_status_msg = msg + * + */ + /*else*/ { + __pyx_t_3 = __pyx_f_7asyncpg_8protocol_8protocol_10ReadBuffer_read_cstr(__pyx_v_self->buffer); if (unlikely(!__pyx_t_3)) __PYX_ERR(4, 310, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_v_msg = __pyx_t_3; + __pyx_t_3 = 0; + } + __pyx_L3:; + + /* "asyncpg/protocol/coreproto.pyx":311 + * else: + * msg = self.buffer.read_cstr() + * self.result_status_msg = msg # <<<<<<<<<<<<<< + * + * cdef _parse_data_msgs(self): + */ + if (!(likely(PyBytes_CheckExact(__pyx_v_msg))||((__pyx_v_msg) == Py_None)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "bytes", Py_TYPE(__pyx_v_msg)->tp_name), 0))) __PYX_ERR(4, 311, __pyx_L1_error) + __pyx_t_3 = __pyx_v_msg; + __Pyx_INCREF(__pyx_t_3); + __Pyx_GIVEREF(__pyx_t_3); + __Pyx_GOTREF(__pyx_v_self->result_status_msg); + __Pyx_DECREF(__pyx_v_self->result_status_msg); + __pyx_v_self->result_status_msg = ((PyObject*)__pyx_t_3); + __pyx_t_3 = 0; + + /* "asyncpg/protocol/coreproto.pyx":301 + * self.buffer.consume_message() + * + * cdef _parse_msg_command_complete(self): # <<<<<<<<<<<<<< + * cdef: + * char* cbuf + */ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_3); + __Pyx_AddTraceback("asyncpg.protocol.protocol.CoreProtocol._parse_msg_command_complete", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XDECREF(__pyx_v_msg); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "asyncpg/protocol/coreproto.pyx":313 + * self.result_status_msg = msg + * + * cdef _parse_data_msgs(self): # <<<<<<<<<<<<<< + * cdef: + * ReadBuffer buf = self.buffer + */ + +static PyObject *__pyx_f_7asyncpg_8protocol_8protocol_12CoreProtocol__parse_data_msgs(struct __pyx_obj_7asyncpg_8protocol_8protocol_CoreProtocol *__pyx_v_self) { + struct __pyx_obj_7asyncpg_8protocol_8protocol_ReadBuffer *__pyx_v_buf = 0; + PyObject *__pyx_v_rows = 0; + __pyx_t_7asyncpg_8protocol_8protocol_decode_row_method __pyx_v_decoder; + char *__pyx_v_cbuf; + Py_ssize_t __pyx_v_cbuf_len; + PyObject *__pyx_v_row = 0; + struct __pyx_obj_7asyncpg_8protocol_8protocol_Memory *__pyx_v_mem = 0; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_t_2; + int32_t __pyx_t_3; + int __pyx_t_4; + PyObject *__pyx_t_5 = NULL; + PyObject *__pyx_t_6 = NULL; + PyObject *__pyx_t_7 = NULL; + int __pyx_t_8; + __Pyx_RefNannySetupContext("_parse_data_msgs", 0); + + /* "asyncpg/protocol/coreproto.pyx":315 + * cdef _parse_data_msgs(self): + * cdef: + * ReadBuffer buf = self.buffer # <<<<<<<<<<<<<< + * list rows + * decode_row_method decoder = self._decode_row + */ + __pyx_t_1 = ((PyObject *)__pyx_v_self->buffer); + __Pyx_INCREF(__pyx_t_1); + __pyx_v_buf = ((struct __pyx_obj_7asyncpg_8protocol_8protocol_ReadBuffer *)__pyx_t_1); + __pyx_t_1 = 0; + + /* "asyncpg/protocol/coreproto.pyx":317 + * ReadBuffer buf = self.buffer + * list rows + * decode_row_method decoder = self._decode_row # <<<<<<<<<<<<<< + * + * char* cbuf + */ + __pyx_v_decoder = ((__pyx_t_7asyncpg_8protocol_8protocol_decode_row_method)((struct __pyx_vtabstruct_7asyncpg_8protocol_8protocol_CoreProtocol *)__pyx_v_self->__pyx_vtab)->_decode_row); + + /* "asyncpg/protocol/coreproto.pyx":324 + * Memory mem + * + * if ASYNCPG_DEBUG: # <<<<<<<<<<<<<< + * if buf.get_message_type() != b'D': + * raise RuntimeError( + */ + __pyx_t_2 = (ASYNCPG_DEBUG != 0); + if (__pyx_t_2) { + + /* "asyncpg/protocol/coreproto.pyx":325 + * + * if ASYNCPG_DEBUG: + * if buf.get_message_type() != b'D': # <<<<<<<<<<<<<< + * raise RuntimeError( + * '_parse_data_msgs: first message is not "D"') + */ + __pyx_t_2 = ((__pyx_f_7asyncpg_8protocol_8protocol_10ReadBuffer_get_message_type(__pyx_v_buf) != 'D') != 0); + if (__pyx_t_2) { + + /* "asyncpg/protocol/coreproto.pyx":326 + * if ASYNCPG_DEBUG: + * if buf.get_message_type() != b'D': + * raise RuntimeError( # <<<<<<<<<<<<<< + * '_parse_data_msgs: first message is not "D"') + * + */ + __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_RuntimeError, __pyx_tuple__57, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 326, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_Raise(__pyx_t_1, 0, 0, 0); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __PYX_ERR(4, 326, __pyx_L1_error) + + /* "asyncpg/protocol/coreproto.pyx":325 + * + * if ASYNCPG_DEBUG: + * if buf.get_message_type() != b'D': # <<<<<<<<<<<<<< + * raise RuntimeError( + * '_parse_data_msgs: first message is not "D"') + */ + } + + /* "asyncpg/protocol/coreproto.pyx":324 + * Memory mem + * + * if ASYNCPG_DEBUG: # <<<<<<<<<<<<<< + * if buf.get_message_type() != b'D': + * raise RuntimeError( + */ + } + + /* "asyncpg/protocol/coreproto.pyx":329 + * '_parse_data_msgs: first message is not "D"') + * + * if self._discard_data: # <<<<<<<<<<<<<< + * while True: + * buf.consume_message() + */ + __pyx_t_2 = (__pyx_v_self->_discard_data != 0); + if (__pyx_t_2) { + + /* "asyncpg/protocol/coreproto.pyx":330 + * + * if self._discard_data: + * while True: # <<<<<<<<<<<<<< + * buf.consume_message() + * if not buf.has_message() or buf.get_message_type() != b'D': + */ + while (1) { + + /* "asyncpg/protocol/coreproto.pyx":331 + * if self._discard_data: + * while True: + * buf.consume_message() # <<<<<<<<<<<<<< + * if not buf.has_message() or buf.get_message_type() != b'D': + * self._skip_discard = True + */ + __pyx_t_1 = ((PyObject *)__pyx_f_7asyncpg_8protocol_8protocol_10ReadBuffer_consume_message(__pyx_v_buf)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 331, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "asyncpg/protocol/coreproto.pyx":332 + * while True: + * buf.consume_message() + * if not buf.has_message() or buf.get_message_type() != b'D': # <<<<<<<<<<<<<< + * self._skip_discard = True + * return + */ + __pyx_t_3 = __pyx_f_7asyncpg_8protocol_8protocol_10ReadBuffer_has_message(__pyx_v_buf); if (unlikely(__pyx_t_3 == -1)) __PYX_ERR(4, 332, __pyx_L1_error) + __pyx_t_4 = ((!(__pyx_t_3 != 0)) != 0); + if (!__pyx_t_4) { + } else { + __pyx_t_2 = __pyx_t_4; + goto __pyx_L9_bool_binop_done; + } + __pyx_t_4 = ((__pyx_f_7asyncpg_8protocol_8protocol_10ReadBuffer_get_message_type(__pyx_v_buf) != 'D') != 0); + __pyx_t_2 = __pyx_t_4; + __pyx_L9_bool_binop_done:; + if (__pyx_t_2) { + + /* "asyncpg/protocol/coreproto.pyx":333 + * buf.consume_message() + * if not buf.has_message() or buf.get_message_type() != b'D': + * self._skip_discard = True # <<<<<<<<<<<<<< + * return + * + */ + __pyx_v_self->_skip_discard = 1; + + /* "asyncpg/protocol/coreproto.pyx":334 + * if not buf.has_message() or buf.get_message_type() != b'D': + * self._skip_discard = True + * return # <<<<<<<<<<<<<< + * + * if ASYNCPG_DEBUG: + */ + __Pyx_XDECREF(__pyx_r); + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + + /* "asyncpg/protocol/coreproto.pyx":332 + * while True: + * buf.consume_message() + * if not buf.has_message() or buf.get_message_type() != b'D': # <<<<<<<<<<<<<< + * self._skip_discard = True + * return + */ + } + } + + /* "asyncpg/protocol/coreproto.pyx":329 + * '_parse_data_msgs: first message is not "D"') + * + * if self._discard_data: # <<<<<<<<<<<<<< + * while True: + * buf.consume_message() + */ + } + + /* "asyncpg/protocol/coreproto.pyx":336 + * return + * + * if ASYNCPG_DEBUG: # <<<<<<<<<<<<<< + * if type(self.result) is not list: + * raise RuntimeError( + */ + __pyx_t_2 = (ASYNCPG_DEBUG != 0); + if (__pyx_t_2) { + + /* "asyncpg/protocol/coreproto.pyx":337 + * + * if ASYNCPG_DEBUG: + * if type(self.result) is not list: # <<<<<<<<<<<<<< + * raise RuntimeError( + * '_parse_data_msgs: result is not a list, but {!r}'. + */ + __pyx_t_2 = (((PyObject *)Py_TYPE(__pyx_v_self->result)) != ((PyObject *)(&PyList_Type))); + __pyx_t_4 = (__pyx_t_2 != 0); + if (__pyx_t_4) { + + /* "asyncpg/protocol/coreproto.pyx":339 + * if type(self.result) is not list: + * raise RuntimeError( + * '_parse_data_msgs: result is not a list, but {!r}'. # <<<<<<<<<<<<<< + * format(self.result)) + * + */ + __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_kp_u_parse_data_msgs_result_is_not_a, __pyx_n_s_format); if (unlikely(!__pyx_t_5)) __PYX_ERR(4, 339, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + + /* "asyncpg/protocol/coreproto.pyx":340 + * raise RuntimeError( + * '_parse_data_msgs: result is not a list, but {!r}'. + * format(self.result)) # <<<<<<<<<<<<<< + * + * rows = self.result + */ + __pyx_t_6 = NULL; + if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_5))) { + __pyx_t_6 = PyMethod_GET_SELF(__pyx_t_5); + if (likely(__pyx_t_6)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_5); + __Pyx_INCREF(__pyx_t_6); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_5, function); + } + } + if (!__pyx_t_6) { + __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_t_5, __pyx_v_self->result); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 340, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + } else { + #if CYTHON_FAST_PYCALL + if (PyFunction_Check(__pyx_t_5)) { + PyObject *__pyx_temp[2] = {__pyx_t_6, __pyx_v_self->result}; + __pyx_t_1 = __Pyx_PyFunction_FastCall(__pyx_t_5, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 340, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_GOTREF(__pyx_t_1); + } else + #endif + #if CYTHON_FAST_PYCCALL + if (__Pyx_PyFastCFunction_Check(__pyx_t_5)) { + PyObject *__pyx_temp[2] = {__pyx_t_6, __pyx_v_self->result}; + __pyx_t_1 = __Pyx_PyCFunction_FastCall(__pyx_t_5, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 340, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_GOTREF(__pyx_t_1); + } else + #endif + { + __pyx_t_7 = PyTuple_New(1+1); if (unlikely(!__pyx_t_7)) __PYX_ERR(4, 340, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __Pyx_GIVEREF(__pyx_t_6); PyTuple_SET_ITEM(__pyx_t_7, 0, __pyx_t_6); __pyx_t_6 = NULL; + __Pyx_INCREF(__pyx_v_self->result); + __Pyx_GIVEREF(__pyx_v_self->result); + PyTuple_SET_ITEM(__pyx_t_7, 0+1, __pyx_v_self->result); + __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_5, __pyx_t_7, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 340, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + } + } + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + + /* "asyncpg/protocol/coreproto.pyx":338 + * if ASYNCPG_DEBUG: + * if type(self.result) is not list: + * raise RuntimeError( # <<<<<<<<<<<<<< + * '_parse_data_msgs: result is not a list, but {!r}'. + * format(self.result)) + */ + __pyx_t_5 = PyTuple_New(1); if (unlikely(!__pyx_t_5)) __PYX_ERR(4, 338, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_GIVEREF(__pyx_t_1); + PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_t_1); + __pyx_t_1 = 0; + __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_RuntimeError, __pyx_t_5, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 338, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_Raise(__pyx_t_1, 0, 0, 0); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __PYX_ERR(4, 338, __pyx_L1_error) + + /* "asyncpg/protocol/coreproto.pyx":337 + * + * if ASYNCPG_DEBUG: + * if type(self.result) is not list: # <<<<<<<<<<<<<< + * raise RuntimeError( + * '_parse_data_msgs: result is not a list, but {!r}'. + */ + } + + /* "asyncpg/protocol/coreproto.pyx":336 + * return + * + * if ASYNCPG_DEBUG: # <<<<<<<<<<<<<< + * if type(self.result) is not list: + * raise RuntimeError( + */ + } + + /* "asyncpg/protocol/coreproto.pyx":342 + * format(self.result)) + * + * rows = self.result # <<<<<<<<<<<<<< + * while True: + * cbuf = buf.try_consume_message(&cbuf_len) + */ + if (!(likely(PyList_CheckExact(__pyx_v_self->result))||((__pyx_v_self->result) == Py_None)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "list", Py_TYPE(__pyx_v_self->result)->tp_name), 0))) __PYX_ERR(4, 342, __pyx_L1_error) + __pyx_t_1 = __pyx_v_self->result; + __Pyx_INCREF(__pyx_t_1); + __pyx_v_rows = ((PyObject*)__pyx_t_1); + __pyx_t_1 = 0; + + /* "asyncpg/protocol/coreproto.pyx":343 + * + * rows = self.result + * while True: # <<<<<<<<<<<<<< + * cbuf = buf.try_consume_message(&cbuf_len) + * if cbuf != NULL: + */ + while (1) { + + /* "asyncpg/protocol/coreproto.pyx":344 + * rows = self.result + * while True: + * cbuf = buf.try_consume_message(&cbuf_len) # <<<<<<<<<<<<<< + * if cbuf != NULL: + * row = decoder(self, cbuf, cbuf_len) + */ + __pyx_v_cbuf = __pyx_f_7asyncpg_8protocol_8protocol_10ReadBuffer_try_consume_message(__pyx_v_buf, (&__pyx_v_cbuf_len)); + + /* "asyncpg/protocol/coreproto.pyx":345 + * while True: + * cbuf = buf.try_consume_message(&cbuf_len) + * if cbuf != NULL: # <<<<<<<<<<<<<< + * row = decoder(self, cbuf, cbuf_len) + * else: + */ + __pyx_t_4 = ((__pyx_v_cbuf != NULL) != 0); + if (__pyx_t_4) { + + /* "asyncpg/protocol/coreproto.pyx":346 + * cbuf = buf.try_consume_message(&cbuf_len) + * if cbuf != NULL: + * row = decoder(self, cbuf, cbuf_len) # <<<<<<<<<<<<<< + * else: + * mem = buf.consume_message() + */ + __pyx_t_1 = __pyx_v_decoder(((PyObject *)__pyx_v_self), __pyx_v_cbuf, __pyx_v_cbuf_len); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 346, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_XDECREF_SET(__pyx_v_row, __pyx_t_1); + __pyx_t_1 = 0; + + /* "asyncpg/protocol/coreproto.pyx":345 + * while True: + * cbuf = buf.try_consume_message(&cbuf_len) + * if cbuf != NULL: # <<<<<<<<<<<<<< + * row = decoder(self, cbuf, cbuf_len) + * else: + */ + goto __pyx_L15; + } + + /* "asyncpg/protocol/coreproto.pyx":348 + * row = decoder(self, cbuf, cbuf_len) + * else: + * mem = buf.consume_message() # <<<<<<<<<<<<<< + * row = decoder(self, mem.buf, mem.length) + * + */ + /*else*/ { + __pyx_t_1 = ((PyObject *)__pyx_f_7asyncpg_8protocol_8protocol_10ReadBuffer_consume_message(__pyx_v_buf)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 348, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_XDECREF_SET(__pyx_v_mem, ((struct __pyx_obj_7asyncpg_8protocol_8protocol_Memory *)__pyx_t_1)); + __pyx_t_1 = 0; + + /* "asyncpg/protocol/coreproto.pyx":349 + * else: + * mem = buf.consume_message() + * row = decoder(self, mem.buf, mem.length) # <<<<<<<<<<<<<< + * + * cpython.PyList_Append(rows, row) + */ + __pyx_t_1 = __pyx_v_decoder(((PyObject *)__pyx_v_self), __pyx_v_mem->buf, __pyx_v_mem->length); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 349, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_XDECREF_SET(__pyx_v_row, __pyx_t_1); + __pyx_t_1 = 0; + } + __pyx_L15:; + + /* "asyncpg/protocol/coreproto.pyx":351 + * row = decoder(self, mem.buf, mem.length) + * + * cpython.PyList_Append(rows, row) # <<<<<<<<<<<<<< + * + * if not buf.has_message() or buf.get_message_type() != b'D': + */ + __pyx_t_8 = PyList_Append(__pyx_v_rows, __pyx_v_row); if (unlikely(__pyx_t_8 == -1)) __PYX_ERR(4, 351, __pyx_L1_error) + + /* "asyncpg/protocol/coreproto.pyx":353 + * cpython.PyList_Append(rows, row) + * + * if not buf.has_message() or buf.get_message_type() != b'D': # <<<<<<<<<<<<<< + * self._skip_discard = True + * return + */ + __pyx_t_3 = __pyx_f_7asyncpg_8protocol_8protocol_10ReadBuffer_has_message(__pyx_v_buf); if (unlikely(__pyx_t_3 == -1)) __PYX_ERR(4, 353, __pyx_L1_error) + __pyx_t_2 = ((!(__pyx_t_3 != 0)) != 0); + if (!__pyx_t_2) { + } else { + __pyx_t_4 = __pyx_t_2; + goto __pyx_L17_bool_binop_done; + } + __pyx_t_2 = ((__pyx_f_7asyncpg_8protocol_8protocol_10ReadBuffer_get_message_type(__pyx_v_buf) != 'D') != 0); + __pyx_t_4 = __pyx_t_2; + __pyx_L17_bool_binop_done:; + if (__pyx_t_4) { + + /* "asyncpg/protocol/coreproto.pyx":354 + * + * if not buf.has_message() or buf.get_message_type() != b'D': + * self._skip_discard = True # <<<<<<<<<<<<<< + * return + * + */ + __pyx_v_self->_skip_discard = 1; + + /* "asyncpg/protocol/coreproto.pyx":355 + * if not buf.has_message() or buf.get_message_type() != b'D': + * self._skip_discard = True + * return # <<<<<<<<<<<<<< + * + * cdef _parse_msg_backend_key_data(self): + */ + __Pyx_XDECREF(__pyx_r); + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + + /* "asyncpg/protocol/coreproto.pyx":353 + * cpython.PyList_Append(rows, row) + * + * if not buf.has_message() or buf.get_message_type() != b'D': # <<<<<<<<<<<<<< + * self._skip_discard = True + * return + */ + } + } + + /* "asyncpg/protocol/coreproto.pyx":313 + * self.result_status_msg = msg + * + * cdef _parse_data_msgs(self): # <<<<<<<<<<<<<< + * cdef: + * ReadBuffer buf = self.buffer + */ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_XDECREF(__pyx_t_6); + __Pyx_XDECREF(__pyx_t_7); + __Pyx_AddTraceback("asyncpg.protocol.protocol.CoreProtocol._parse_data_msgs", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XDECREF((PyObject *)__pyx_v_buf); + __Pyx_XDECREF(__pyx_v_rows); + __Pyx_XDECREF(__pyx_v_row); + __Pyx_XDECREF((PyObject *)__pyx_v_mem); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "asyncpg/protocol/coreproto.pyx":357 + * return + * + * cdef _parse_msg_backend_key_data(self): # <<<<<<<<<<<<<< + * self.backend_pid = self.buffer.read_int32() + * self.backend_secret = self.buffer.read_int32() + */ + +static PyObject *__pyx_f_7asyncpg_8protocol_8protocol_12CoreProtocol__parse_msg_backend_key_data(struct __pyx_obj_7asyncpg_8protocol_8protocol_CoreProtocol *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int32_t __pyx_t_2; + __Pyx_RefNannySetupContext("_parse_msg_backend_key_data", 0); + + /* "asyncpg/protocol/coreproto.pyx":358 + * + * cdef _parse_msg_backend_key_data(self): + * self.backend_pid = self.buffer.read_int32() # <<<<<<<<<<<<<< + * self.backend_secret = self.buffer.read_int32() + * + */ + __pyx_t_1 = __pyx_f_7asyncpg_8protocol_8protocol_10ReadBuffer_read_int32(__pyx_v_self->buffer); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 358, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = __Pyx_PyInt_As_int32_t(__pyx_t_1); if (unlikely((__pyx_t_2 == ((int32_t)-1)) && PyErr_Occurred())) __PYX_ERR(4, 358, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_v_self->backend_pid = __pyx_t_2; + + /* "asyncpg/protocol/coreproto.pyx":359 + * cdef _parse_msg_backend_key_data(self): + * self.backend_pid = self.buffer.read_int32() + * self.backend_secret = self.buffer.read_int32() # <<<<<<<<<<<<<< + * + * cdef _parse_msg_parameter_status(self): + */ + __pyx_t_1 = __pyx_f_7asyncpg_8protocol_8protocol_10ReadBuffer_read_int32(__pyx_v_self->buffer); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 359, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = __Pyx_PyInt_As_int32_t(__pyx_t_1); if (unlikely((__pyx_t_2 == ((int32_t)-1)) && PyErr_Occurred())) __PYX_ERR(4, 359, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_v_self->backend_secret = __pyx_t_2; + + /* "asyncpg/protocol/coreproto.pyx":357 + * return + * + * cdef _parse_msg_backend_key_data(self): # <<<<<<<<<<<<<< + * self.backend_pid = self.buffer.read_int32() + * self.backend_secret = self.buffer.read_int32() + */ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("asyncpg.protocol.protocol.CoreProtocol._parse_msg_backend_key_data", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "asyncpg/protocol/coreproto.pyx":361 + * self.backend_secret = self.buffer.read_int32() + * + * cdef _parse_msg_parameter_status(self): # <<<<<<<<<<<<<< + * name = self.buffer.read_cstr() + * name = name.decode(self.encoding) + */ + +static PyObject *__pyx_f_7asyncpg_8protocol_8protocol_12CoreProtocol__parse_msg_parameter_status(struct __pyx_obj_7asyncpg_8protocol_8protocol_CoreProtocol *__pyx_v_self) { + PyObject *__pyx_v_name = NULL; + PyObject *__pyx_v_val = NULL; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + __Pyx_RefNannySetupContext("_parse_msg_parameter_status", 0); + + /* "asyncpg/protocol/coreproto.pyx":362 + * + * cdef _parse_msg_parameter_status(self): + * name = self.buffer.read_cstr() # <<<<<<<<<<<<<< + * name = name.decode(self.encoding) + * + */ + __pyx_t_1 = __pyx_f_7asyncpg_8protocol_8protocol_10ReadBuffer_read_cstr(__pyx_v_self->buffer); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 362, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_v_name = __pyx_t_1; + __pyx_t_1 = 0; + + /* "asyncpg/protocol/coreproto.pyx":363 + * cdef _parse_msg_parameter_status(self): + * name = self.buffer.read_cstr() + * name = name.decode(self.encoding) # <<<<<<<<<<<<<< + * + * val = self.buffer.read_cstr() + */ + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_name, __pyx_n_s_decode); if (unlikely(!__pyx_t_2)) __PYX_ERR(4, 363, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = NULL; + if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_3)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_3); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + } + } + if (!__pyx_t_3) { + __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_v_self->encoding); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 363, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + } else { + #if CYTHON_FAST_PYCALL + if (PyFunction_Check(__pyx_t_2)) { + PyObject *__pyx_temp[2] = {__pyx_t_3, __pyx_v_self->encoding}; + __pyx_t_1 = __Pyx_PyFunction_FastCall(__pyx_t_2, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 363, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_GOTREF(__pyx_t_1); + } else + #endif + #if CYTHON_FAST_PYCCALL + if (__Pyx_PyFastCFunction_Check(__pyx_t_2)) { + PyObject *__pyx_temp[2] = {__pyx_t_3, __pyx_v_self->encoding}; + __pyx_t_1 = __Pyx_PyCFunction_FastCall(__pyx_t_2, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 363, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_GOTREF(__pyx_t_1); + } else + #endif + { + __pyx_t_4 = PyTuple_New(1+1); if (unlikely(!__pyx_t_4)) __PYX_ERR(4, 363, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_GIVEREF(__pyx_t_3); PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_3); __pyx_t_3 = NULL; + __Pyx_INCREF(__pyx_v_self->encoding); + __Pyx_GIVEREF(__pyx_v_self->encoding); + PyTuple_SET_ITEM(__pyx_t_4, 0+1, __pyx_v_self->encoding); + __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_t_4, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 363, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + } + } + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_DECREF_SET(__pyx_v_name, __pyx_t_1); + __pyx_t_1 = 0; + + /* "asyncpg/protocol/coreproto.pyx":365 + * name = name.decode(self.encoding) + * + * val = self.buffer.read_cstr() # <<<<<<<<<<<<<< + * val = val.decode(self.encoding) + * + */ + __pyx_t_1 = __pyx_f_7asyncpg_8protocol_8protocol_10ReadBuffer_read_cstr(__pyx_v_self->buffer); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 365, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_v_val = __pyx_t_1; + __pyx_t_1 = 0; + + /* "asyncpg/protocol/coreproto.pyx":366 + * + * val = self.buffer.read_cstr() + * val = val.decode(self.encoding) # <<<<<<<<<<<<<< + * + * self._set_server_parameter(name, val) + */ + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_val, __pyx_n_s_decode); if (unlikely(!__pyx_t_2)) __PYX_ERR(4, 366, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_4 = NULL; + if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_4)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_4); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + } + } + if (!__pyx_t_4) { + __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_v_self->encoding); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 366, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + } else { + #if CYTHON_FAST_PYCALL + if (PyFunction_Check(__pyx_t_2)) { + PyObject *__pyx_temp[2] = {__pyx_t_4, __pyx_v_self->encoding}; + __pyx_t_1 = __Pyx_PyFunction_FastCall(__pyx_t_2, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 366, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_GOTREF(__pyx_t_1); + } else + #endif + #if CYTHON_FAST_PYCCALL + if (__Pyx_PyFastCFunction_Check(__pyx_t_2)) { + PyObject *__pyx_temp[2] = {__pyx_t_4, __pyx_v_self->encoding}; + __pyx_t_1 = __Pyx_PyCFunction_FastCall(__pyx_t_2, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 366, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_GOTREF(__pyx_t_1); + } else + #endif + { + __pyx_t_3 = PyTuple_New(1+1); if (unlikely(!__pyx_t_3)) __PYX_ERR(4, 366, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_GIVEREF(__pyx_t_4); PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_t_4); __pyx_t_4 = NULL; + __Pyx_INCREF(__pyx_v_self->encoding); + __Pyx_GIVEREF(__pyx_v_self->encoding); + PyTuple_SET_ITEM(__pyx_t_3, 0+1, __pyx_v_self->encoding); + __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_t_3, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 366, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + } + } + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_DECREF_SET(__pyx_v_val, __pyx_t_1); + __pyx_t_1 = 0; + + /* "asyncpg/protocol/coreproto.pyx":368 + * val = val.decode(self.encoding) + * + * self._set_server_parameter(name, val) # <<<<<<<<<<<<<< + * + * cdef _parse_msg_notification(self): + */ + __pyx_t_1 = ((struct __pyx_vtabstruct_7asyncpg_8protocol_8protocol_CoreProtocol *)__pyx_v_self->__pyx_vtab)->_set_server_parameter(__pyx_v_self, __pyx_v_name, __pyx_v_val); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 368, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "asyncpg/protocol/coreproto.pyx":361 + * self.backend_secret = self.buffer.read_int32() + * + * cdef _parse_msg_parameter_status(self): # <<<<<<<<<<<<<< + * name = self.buffer.read_cstr() + * name = name.decode(self.encoding) + */ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_AddTraceback("asyncpg.protocol.protocol.CoreProtocol._parse_msg_parameter_status", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XDECREF(__pyx_v_name); + __Pyx_XDECREF(__pyx_v_val); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "asyncpg/protocol/coreproto.pyx":370 + * self._set_server_parameter(name, val) + * + * cdef _parse_msg_notification(self): # <<<<<<<<<<<<<< + * pid = self.buffer.read_int32() + * channel = self.buffer.read_cstr().decode(self.encoding) + */ + +static PyObject *__pyx_f_7asyncpg_8protocol_8protocol_12CoreProtocol__parse_msg_notification(struct __pyx_obj_7asyncpg_8protocol_8protocol_CoreProtocol *__pyx_v_self) { + PyObject *__pyx_v_pid = NULL; + PyObject *__pyx_v_channel = NULL; + PyObject *__pyx_v_payload = NULL; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + __Pyx_RefNannySetupContext("_parse_msg_notification", 0); + + /* "asyncpg/protocol/coreproto.pyx":371 + * + * cdef _parse_msg_notification(self): + * pid = self.buffer.read_int32() # <<<<<<<<<<<<<< + * channel = self.buffer.read_cstr().decode(self.encoding) + * payload = self.buffer.read_cstr().decode(self.encoding) + */ + __pyx_t_1 = __pyx_f_7asyncpg_8protocol_8protocol_10ReadBuffer_read_int32(__pyx_v_self->buffer); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 371, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_v_pid = __pyx_t_1; + __pyx_t_1 = 0; + + /* "asyncpg/protocol/coreproto.pyx":372 + * cdef _parse_msg_notification(self): + * pid = self.buffer.read_int32() + * channel = self.buffer.read_cstr().decode(self.encoding) # <<<<<<<<<<<<<< + * payload = self.buffer.read_cstr().decode(self.encoding) + * self._on_notification(pid, channel, payload) + */ + __pyx_t_2 = __pyx_f_7asyncpg_8protocol_8protocol_10ReadBuffer_read_cstr(__pyx_v_self->buffer); if (unlikely(!__pyx_t_2)) __PYX_ERR(4, 372, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_decode); if (unlikely(!__pyx_t_3)) __PYX_ERR(4, 372, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_2 = NULL; + if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_3))) { + __pyx_t_2 = PyMethod_GET_SELF(__pyx_t_3); + if (likely(__pyx_t_2)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); + __Pyx_INCREF(__pyx_t_2); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_3, function); + } + } + if (!__pyx_t_2) { + __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_v_self->encoding); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 372, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + } else { + #if CYTHON_FAST_PYCALL + if (PyFunction_Check(__pyx_t_3)) { + PyObject *__pyx_temp[2] = {__pyx_t_2, __pyx_v_self->encoding}; + __pyx_t_1 = __Pyx_PyFunction_FastCall(__pyx_t_3, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 372, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_GOTREF(__pyx_t_1); + } else + #endif + #if CYTHON_FAST_PYCCALL + if (__Pyx_PyFastCFunction_Check(__pyx_t_3)) { + PyObject *__pyx_temp[2] = {__pyx_t_2, __pyx_v_self->encoding}; + __pyx_t_1 = __Pyx_PyCFunction_FastCall(__pyx_t_3, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 372, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_GOTREF(__pyx_t_1); + } else + #endif + { + __pyx_t_4 = PyTuple_New(1+1); if (unlikely(!__pyx_t_4)) __PYX_ERR(4, 372, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_GIVEREF(__pyx_t_2); PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_2); __pyx_t_2 = NULL; + __Pyx_INCREF(__pyx_v_self->encoding); + __Pyx_GIVEREF(__pyx_v_self->encoding); + PyTuple_SET_ITEM(__pyx_t_4, 0+1, __pyx_v_self->encoding); + __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_t_4, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 372, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + } + } + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_v_channel = __pyx_t_1; + __pyx_t_1 = 0; + + /* "asyncpg/protocol/coreproto.pyx":373 + * pid = self.buffer.read_int32() + * channel = self.buffer.read_cstr().decode(self.encoding) + * payload = self.buffer.read_cstr().decode(self.encoding) # <<<<<<<<<<<<<< + * self._on_notification(pid, channel, payload) + * + */ + __pyx_t_3 = __pyx_f_7asyncpg_8protocol_8protocol_10ReadBuffer_read_cstr(__pyx_v_self->buffer); if (unlikely(!__pyx_t_3)) __PYX_ERR(4, 373, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_decode); if (unlikely(!__pyx_t_4)) __PYX_ERR(4, 373, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_3 = NULL; + if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_4))) { + __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_4); + if (likely(__pyx_t_3)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4); + __Pyx_INCREF(__pyx_t_3); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_4, function); + } + } + if (!__pyx_t_3) { + __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_v_self->encoding); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 373, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + } else { + #if CYTHON_FAST_PYCALL + if (PyFunction_Check(__pyx_t_4)) { + PyObject *__pyx_temp[2] = {__pyx_t_3, __pyx_v_self->encoding}; + __pyx_t_1 = __Pyx_PyFunction_FastCall(__pyx_t_4, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 373, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_GOTREF(__pyx_t_1); + } else + #endif + #if CYTHON_FAST_PYCCALL + if (__Pyx_PyFastCFunction_Check(__pyx_t_4)) { + PyObject *__pyx_temp[2] = {__pyx_t_3, __pyx_v_self->encoding}; + __pyx_t_1 = __Pyx_PyCFunction_FastCall(__pyx_t_4, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 373, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_GOTREF(__pyx_t_1); + } else + #endif + { + __pyx_t_2 = PyTuple_New(1+1); if (unlikely(!__pyx_t_2)) __PYX_ERR(4, 373, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_GIVEREF(__pyx_t_3); PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_t_3); __pyx_t_3 = NULL; + __Pyx_INCREF(__pyx_v_self->encoding); + __Pyx_GIVEREF(__pyx_v_self->encoding); + PyTuple_SET_ITEM(__pyx_t_2, 0+1, __pyx_v_self->encoding); + __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_4, __pyx_t_2, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 373, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } + } + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_v_payload = __pyx_t_1; + __pyx_t_1 = 0; + + /* "asyncpg/protocol/coreproto.pyx":374 + * channel = self.buffer.read_cstr().decode(self.encoding) + * payload = self.buffer.read_cstr().decode(self.encoding) + * self._on_notification(pid, channel, payload) # <<<<<<<<<<<<<< + * + * cdef _parse_msg_authentication(self): + */ + __pyx_t_1 = ((struct __pyx_vtabstruct_7asyncpg_8protocol_8protocol_CoreProtocol *)__pyx_v_self->__pyx_vtab)->_on_notification(__pyx_v_self, __pyx_v_pid, __pyx_v_channel, __pyx_v_payload); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 374, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "asyncpg/protocol/coreproto.pyx":370 + * self._set_server_parameter(name, val) + * + * cdef _parse_msg_notification(self): # <<<<<<<<<<<<<< + * pid = self.buffer.read_int32() + * channel = self.buffer.read_cstr().decode(self.encoding) + */ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_AddTraceback("asyncpg.protocol.protocol.CoreProtocol._parse_msg_notification", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XDECREF(__pyx_v_pid); + __Pyx_XDECREF(__pyx_v_channel); + __Pyx_XDECREF(__pyx_v_payload); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "asyncpg/protocol/coreproto.pyx":376 + * self._on_notification(pid, channel, payload) + * + * cdef _parse_msg_authentication(self): # <<<<<<<<<<<<<< + * cdef: + * int32_t status + */ + +static PyObject *__pyx_f_7asyncpg_8protocol_8protocol_12CoreProtocol__parse_msg_authentication(struct __pyx_obj_7asyncpg_8protocol_8protocol_CoreProtocol *__pyx_v_self) { + int32_t __pyx_v_status; + PyObject *__pyx_v_md5_salt = 0; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int32_t __pyx_t_2; + char *__pyx_t_3; + PyObject *__pyx_t_4 = NULL; + PyObject *__pyx_t_5 = NULL; + PyObject *__pyx_t_6 = NULL; + PyObject *__pyx_t_7 = NULL; + PyObject *__pyx_t_8 = NULL; + PyObject *__pyx_t_9 = NULL; + __Pyx_RefNannySetupContext("_parse_msg_authentication", 0); + + /* "asyncpg/protocol/coreproto.pyx":381 + * bytes md5_salt + * + * status = self.buffer.read_int32() # <<<<<<<<<<<<<< + * + * if status == AUTH_SUCCESSFUL: + */ + __pyx_t_1 = __pyx_f_7asyncpg_8protocol_8protocol_10ReadBuffer_read_int32(__pyx_v_self->buffer); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 381, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = __Pyx_PyInt_As_int32_t(__pyx_t_1); if (unlikely((__pyx_t_2 == ((int32_t)-1)) && PyErr_Occurred())) __PYX_ERR(4, 381, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_v_status = __pyx_t_2; + + /* "asyncpg/protocol/coreproto.pyx":383 + * status = self.buffer.read_int32() + * + * if status == AUTH_SUCCESSFUL: # <<<<<<<<<<<<<< + * # AuthenticationOk + * self.result_type = RESULT_OK + */ + switch (__pyx_v_status) { + case __pyx_e_7asyncpg_8protocol_8protocol_AUTH_SUCCESSFUL: + + /* "asyncpg/protocol/coreproto.pyx":385 + * if status == AUTH_SUCCESSFUL: + * # AuthenticationOk + * self.result_type = RESULT_OK # <<<<<<<<<<<<<< + * + * elif status == AUTH_REQUIRED_PASSWORD: + */ + __pyx_v_self->result_type = __pyx_e_7asyncpg_8protocol_8protocol_RESULT_OK; + + /* "asyncpg/protocol/coreproto.pyx":383 + * status = self.buffer.read_int32() + * + * if status == AUTH_SUCCESSFUL: # <<<<<<<<<<<<<< + * # AuthenticationOk + * self.result_type = RESULT_OK + */ + break; + + /* "asyncpg/protocol/coreproto.pyx":387 + * self.result_type = RESULT_OK + * + * elif status == AUTH_REQUIRED_PASSWORD: # <<<<<<<<<<<<<< + * # AuthenticationCleartextPassword + * self.result_type = RESULT_OK + */ + case __pyx_e_7asyncpg_8protocol_8protocol_AUTH_REQUIRED_PASSWORD: + + /* "asyncpg/protocol/coreproto.pyx":389 + * elif status == AUTH_REQUIRED_PASSWORD: + * # AuthenticationCleartextPassword + * self.result_type = RESULT_OK # <<<<<<<<<<<<<< + * self.auth_msg = self._auth_password_message_cleartext() + * + */ + __pyx_v_self->result_type = __pyx_e_7asyncpg_8protocol_8protocol_RESULT_OK; + + /* "asyncpg/protocol/coreproto.pyx":390 + * # AuthenticationCleartextPassword + * self.result_type = RESULT_OK + * self.auth_msg = self._auth_password_message_cleartext() # <<<<<<<<<<<<<< + * + * elif status == AUTH_REQUIRED_PASSWORDMD5: + */ + __pyx_t_1 = ((struct __pyx_vtabstruct_7asyncpg_8protocol_8protocol_CoreProtocol *)__pyx_v_self->__pyx_vtab)->_auth_password_message_cleartext(__pyx_v_self); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 390, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (__Pyx_PyObject_SetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_auth_msg, __pyx_t_1) < 0) __PYX_ERR(4, 390, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "asyncpg/protocol/coreproto.pyx":387 + * self.result_type = RESULT_OK + * + * elif status == AUTH_REQUIRED_PASSWORD: # <<<<<<<<<<<<<< + * # AuthenticationCleartextPassword + * self.result_type = RESULT_OK + */ + break; + + /* "asyncpg/protocol/coreproto.pyx":392 + * self.auth_msg = self._auth_password_message_cleartext() + * + * elif status == AUTH_REQUIRED_PASSWORDMD5: # <<<<<<<<<<<<<< + * # AuthenticationMD5Password + * # Note: MD5 salt is passed as a four-byte sequence + */ + case __pyx_e_7asyncpg_8protocol_8protocol_AUTH_REQUIRED_PASSWORDMD5: + + /* "asyncpg/protocol/coreproto.pyx":396 + * # Note: MD5 salt is passed as a four-byte sequence + * md5_salt = cpython.PyBytes_FromStringAndSize( + * self.buffer.read_bytes(4), 4) # <<<<<<<<<<<<<< + * self.auth_msg = self._auth_password_message_md5(md5_salt) + * + */ + __pyx_t_1 = __pyx_f_7asyncpg_8protocol_8protocol_10ReadBuffer_read_bytes(__pyx_v_self->buffer, 4); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 396, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_3 = __Pyx_PyObject_AsString(__pyx_t_1); if (unlikely((!__pyx_t_3) && PyErr_Occurred())) __PYX_ERR(4, 396, __pyx_L1_error) + + /* "asyncpg/protocol/coreproto.pyx":395 + * # AuthenticationMD5Password + * # Note: MD5 salt is passed as a four-byte sequence + * md5_salt = cpython.PyBytes_FromStringAndSize( # <<<<<<<<<<<<<< + * self.buffer.read_bytes(4), 4) + * self.auth_msg = self._auth_password_message_md5(md5_salt) + */ + __pyx_t_4 = PyBytes_FromStringAndSize(__pyx_t_3, 4); if (unlikely(!__pyx_t_4)) __PYX_ERR(4, 395, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_v_md5_salt = ((PyObject*)__pyx_t_4); + __pyx_t_4 = 0; + + /* "asyncpg/protocol/coreproto.pyx":397 + * md5_salt = cpython.PyBytes_FromStringAndSize( + * self.buffer.read_bytes(4), 4) + * self.auth_msg = self._auth_password_message_md5(md5_salt) # <<<<<<<<<<<<<< + * + * elif status in (AUTH_REQUIRED_KERBEROS, AUTH_REQUIRED_SCMCRED, + */ + __pyx_t_4 = ((struct __pyx_vtabstruct_7asyncpg_8protocol_8protocol_CoreProtocol *)__pyx_v_self->__pyx_vtab)->_auth_password_message_md5(__pyx_v_self, __pyx_v_md5_salt); if (unlikely(!__pyx_t_4)) __PYX_ERR(4, 397, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + if (__Pyx_PyObject_SetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_auth_msg, __pyx_t_4) < 0) __PYX_ERR(4, 397, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + + /* "asyncpg/protocol/coreproto.pyx":392 + * self.auth_msg = self._auth_password_message_cleartext() + * + * elif status == AUTH_REQUIRED_PASSWORDMD5: # <<<<<<<<<<<<<< + * # AuthenticationMD5Password + * # Note: MD5 salt is passed as a four-byte sequence + */ + break; + + /* "asyncpg/protocol/coreproto.pyx":399 + * self.auth_msg = self._auth_password_message_md5(md5_salt) + * + * elif status in (AUTH_REQUIRED_KERBEROS, AUTH_REQUIRED_SCMCRED, # <<<<<<<<<<<<<< + * AUTH_REQUIRED_GSS, AUTH_REQUIRED_GSS_CONTINUE, + * AUTH_REQUIRED_SSPI): + */ + case __pyx_e_7asyncpg_8protocol_8protocol_AUTH_REQUIRED_KERBEROS: + case __pyx_e_7asyncpg_8protocol_8protocol_AUTH_REQUIRED_SCMCRED: + + /* "asyncpg/protocol/coreproto.pyx":400 + * + * elif status in (AUTH_REQUIRED_KERBEROS, AUTH_REQUIRED_SCMCRED, + * AUTH_REQUIRED_GSS, AUTH_REQUIRED_GSS_CONTINUE, # <<<<<<<<<<<<<< + * AUTH_REQUIRED_SSPI): + * self.result_type = RESULT_FAILED + */ + case __pyx_e_7asyncpg_8protocol_8protocol_AUTH_REQUIRED_GSS: + case __pyx_e_7asyncpg_8protocol_8protocol_AUTH_REQUIRED_GSS_CONTINUE: + + /* "asyncpg/protocol/coreproto.pyx":401 + * elif status in (AUTH_REQUIRED_KERBEROS, AUTH_REQUIRED_SCMCRED, + * AUTH_REQUIRED_GSS, AUTH_REQUIRED_GSS_CONTINUE, + * AUTH_REQUIRED_SSPI): # <<<<<<<<<<<<<< + * self.result_type = RESULT_FAILED + * self.result = apg_exc.InterfaceError( + */ + case __pyx_e_7asyncpg_8protocol_8protocol_AUTH_REQUIRED_SSPI: + + /* "asyncpg/protocol/coreproto.pyx":402 + * AUTH_REQUIRED_GSS, AUTH_REQUIRED_GSS_CONTINUE, + * AUTH_REQUIRED_SSPI): + * self.result_type = RESULT_FAILED # <<<<<<<<<<<<<< + * self.result = apg_exc.InterfaceError( + * 'unsupported authentication method requested by the ' + */ + __pyx_v_self->result_type = __pyx_e_7asyncpg_8protocol_8protocol_RESULT_FAILED; + + /* "asyncpg/protocol/coreproto.pyx":403 + * AUTH_REQUIRED_SSPI): + * self.result_type = RESULT_FAILED + * self.result = apg_exc.InterfaceError( # <<<<<<<<<<<<<< + * 'unsupported authentication method requested by the ' + * 'server: {!r}'.format(AUTH_METHOD_NAME[status])) + */ + __pyx_t_1 = __Pyx_GetModuleGlobalName(__pyx_n_s_apg_exc); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 403, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_InterfaceError); if (unlikely(!__pyx_t_5)) __PYX_ERR(4, 403, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "asyncpg/protocol/coreproto.pyx":405 + * self.result = apg_exc.InterfaceError( + * 'unsupported authentication method requested by the ' + * 'server: {!r}'.format(AUTH_METHOD_NAME[status])) # <<<<<<<<<<<<<< + * + * else: + */ + __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_kp_u_unsupported_authentication_metho, __pyx_n_s_format); if (unlikely(!__pyx_t_6)) __PYX_ERR(4, 405, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_7 = __Pyx_GetModuleGlobalName(__pyx_n_s_AUTH_METHOD_NAME); if (unlikely(!__pyx_t_7)) __PYX_ERR(4, 405, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __pyx_t_8 = __Pyx_GetItemInt(__pyx_t_7, __pyx_v_status, int32_t, 1, __Pyx_PyInt_From_int32_t, 0, 1, 1); if (unlikely(!__pyx_t_8)) __PYX_ERR(4, 405, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __pyx_t_7 = NULL; + if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_6))) { + __pyx_t_7 = PyMethod_GET_SELF(__pyx_t_6); + if (likely(__pyx_t_7)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_6); + __Pyx_INCREF(__pyx_t_7); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_6, function); + } + } + if (!__pyx_t_7) { + __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_t_6, __pyx_t_8); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 405, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + __Pyx_GOTREF(__pyx_t_1); + } else { + #if CYTHON_FAST_PYCALL + if (PyFunction_Check(__pyx_t_6)) { + PyObject *__pyx_temp[2] = {__pyx_t_7, __pyx_t_8}; + __pyx_t_1 = __Pyx_PyFunction_FastCall(__pyx_t_6, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 405, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + } else + #endif + #if CYTHON_FAST_PYCCALL + if (__Pyx_PyFastCFunction_Check(__pyx_t_6)) { + PyObject *__pyx_temp[2] = {__pyx_t_7, __pyx_t_8}; + __pyx_t_1 = __Pyx_PyCFunction_FastCall(__pyx_t_6, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 405, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + } else + #endif + { + __pyx_t_9 = PyTuple_New(1+1); if (unlikely(!__pyx_t_9)) __PYX_ERR(4, 405, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_9); + __Pyx_GIVEREF(__pyx_t_7); PyTuple_SET_ITEM(__pyx_t_9, 0, __pyx_t_7); __pyx_t_7 = NULL; + __Pyx_GIVEREF(__pyx_t_8); + PyTuple_SET_ITEM(__pyx_t_9, 0+1, __pyx_t_8); + __pyx_t_8 = 0; + __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_6, __pyx_t_9, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 405, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + } + } + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __pyx_t_6 = NULL; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_5))) { + __pyx_t_6 = PyMethod_GET_SELF(__pyx_t_5); + if (likely(__pyx_t_6)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_5); + __Pyx_INCREF(__pyx_t_6); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_5, function); + } + } + if (!__pyx_t_6) { + __pyx_t_4 = __Pyx_PyObject_CallOneArg(__pyx_t_5, __pyx_t_1); if (unlikely(!__pyx_t_4)) __PYX_ERR(4, 403, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_GOTREF(__pyx_t_4); + } else { + #if CYTHON_FAST_PYCALL + if (PyFunction_Check(__pyx_t_5)) { + PyObject *__pyx_temp[2] = {__pyx_t_6, __pyx_t_1}; + __pyx_t_4 = __Pyx_PyFunction_FastCall(__pyx_t_5, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_4)) __PYX_ERR(4, 403, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + } else + #endif + #if CYTHON_FAST_PYCCALL + if (__Pyx_PyFastCFunction_Check(__pyx_t_5)) { + PyObject *__pyx_temp[2] = {__pyx_t_6, __pyx_t_1}; + __pyx_t_4 = __Pyx_PyCFunction_FastCall(__pyx_t_5, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_4)) __PYX_ERR(4, 403, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + } else + #endif + { + __pyx_t_9 = PyTuple_New(1+1); if (unlikely(!__pyx_t_9)) __PYX_ERR(4, 403, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_9); + __Pyx_GIVEREF(__pyx_t_6); PyTuple_SET_ITEM(__pyx_t_9, 0, __pyx_t_6); __pyx_t_6 = NULL; + __Pyx_GIVEREF(__pyx_t_1); + PyTuple_SET_ITEM(__pyx_t_9, 0+1, __pyx_t_1); + __pyx_t_1 = 0; + __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_5, __pyx_t_9, NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(4, 403, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + } + } + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + + /* "asyncpg/protocol/coreproto.pyx":403 + * AUTH_REQUIRED_SSPI): + * self.result_type = RESULT_FAILED + * self.result = apg_exc.InterfaceError( # <<<<<<<<<<<<<< + * 'unsupported authentication method requested by the ' + * 'server: {!r}'.format(AUTH_METHOD_NAME[status])) + */ + __Pyx_GIVEREF(__pyx_t_4); + __Pyx_GOTREF(__pyx_v_self->result); + __Pyx_DECREF(__pyx_v_self->result); + __pyx_v_self->result = __pyx_t_4; + __pyx_t_4 = 0; + + /* "asyncpg/protocol/coreproto.pyx":399 + * self.auth_msg = self._auth_password_message_md5(md5_salt) + * + * elif status in (AUTH_REQUIRED_KERBEROS, AUTH_REQUIRED_SCMCRED, # <<<<<<<<<<<<<< + * AUTH_REQUIRED_GSS, AUTH_REQUIRED_GSS_CONTINUE, + * AUTH_REQUIRED_SSPI): + */ + break; + default: + + /* "asyncpg/protocol/coreproto.pyx":408 + * + * else: + * self.result_type = RESULT_FAILED # <<<<<<<<<<<<<< + * self.result = apg_exc.InterfaceError( + * 'unsupported authentication method requested by the ' + */ + __pyx_v_self->result_type = __pyx_e_7asyncpg_8protocol_8protocol_RESULT_FAILED; + + /* "asyncpg/protocol/coreproto.pyx":409 + * else: + * self.result_type = RESULT_FAILED + * self.result = apg_exc.InterfaceError( # <<<<<<<<<<<<<< + * 'unsupported authentication method requested by the ' + * 'server: {}'.format(status)) + */ + __pyx_t_5 = __Pyx_GetModuleGlobalName(__pyx_n_s_apg_exc); if (unlikely(!__pyx_t_5)) __PYX_ERR(4, 409, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_9 = __Pyx_PyObject_GetAttrStr(__pyx_t_5, __pyx_n_s_InterfaceError); if (unlikely(!__pyx_t_9)) __PYX_ERR(4, 409, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_9); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + + /* "asyncpg/protocol/coreproto.pyx":411 + * self.result = apg_exc.InterfaceError( + * 'unsupported authentication method requested by the ' + * 'server: {}'.format(status)) # <<<<<<<<<<<<<< + * + * self.buffer.consume_message() + */ + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_kp_u_unsupported_authentication_metho_2, __pyx_n_s_format); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 411, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_6 = __Pyx_PyInt_From_int32_t(__pyx_v_status); if (unlikely(!__pyx_t_6)) __PYX_ERR(4, 411, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_8 = NULL; + if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_1))) { + __pyx_t_8 = PyMethod_GET_SELF(__pyx_t_1); + if (likely(__pyx_t_8)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_1); + __Pyx_INCREF(__pyx_t_8); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_1, function); + } + } + if (!__pyx_t_8) { + __pyx_t_5 = __Pyx_PyObject_CallOneArg(__pyx_t_1, __pyx_t_6); if (unlikely(!__pyx_t_5)) __PYX_ERR(4, 411, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_GOTREF(__pyx_t_5); + } else { + #if CYTHON_FAST_PYCALL + if (PyFunction_Check(__pyx_t_1)) { + PyObject *__pyx_temp[2] = {__pyx_t_8, __pyx_t_6}; + __pyx_t_5 = __Pyx_PyFunction_FastCall(__pyx_t_1, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_5)) __PYX_ERR(4, 411, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; + __Pyx_GOTREF(__pyx_t_5); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + } else + #endif + #if CYTHON_FAST_PYCCALL + if (__Pyx_PyFastCFunction_Check(__pyx_t_1)) { + PyObject *__pyx_temp[2] = {__pyx_t_8, __pyx_t_6}; + __pyx_t_5 = __Pyx_PyCFunction_FastCall(__pyx_t_1, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_5)) __PYX_ERR(4, 411, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; + __Pyx_GOTREF(__pyx_t_5); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + } else + #endif + { + __pyx_t_7 = PyTuple_New(1+1); if (unlikely(!__pyx_t_7)) __PYX_ERR(4, 411, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __Pyx_GIVEREF(__pyx_t_8); PyTuple_SET_ITEM(__pyx_t_7, 0, __pyx_t_8); __pyx_t_8 = NULL; + __Pyx_GIVEREF(__pyx_t_6); + PyTuple_SET_ITEM(__pyx_t_7, 0+1, __pyx_t_6); + __pyx_t_6 = 0; + __pyx_t_5 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_t_7, NULL); if (unlikely(!__pyx_t_5)) __PYX_ERR(4, 411, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + } + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_1 = NULL; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_9))) { + __pyx_t_1 = PyMethod_GET_SELF(__pyx_t_9); + if (likely(__pyx_t_1)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_9); + __Pyx_INCREF(__pyx_t_1); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_9, function); + } + } + if (!__pyx_t_1) { + __pyx_t_4 = __Pyx_PyObject_CallOneArg(__pyx_t_9, __pyx_t_5); if (unlikely(!__pyx_t_4)) __PYX_ERR(4, 409, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_GOTREF(__pyx_t_4); + } else { + #if CYTHON_FAST_PYCALL + if (PyFunction_Check(__pyx_t_9)) { + PyObject *__pyx_temp[2] = {__pyx_t_1, __pyx_t_5}; + __pyx_t_4 = __Pyx_PyFunction_FastCall(__pyx_t_9, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_4)) __PYX_ERR(4, 409, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + } else + #endif + #if CYTHON_FAST_PYCCALL + if (__Pyx_PyFastCFunction_Check(__pyx_t_9)) { + PyObject *__pyx_temp[2] = {__pyx_t_1, __pyx_t_5}; + __pyx_t_4 = __Pyx_PyCFunction_FastCall(__pyx_t_9, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_4)) __PYX_ERR(4, 409, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + } else + #endif + { + __pyx_t_7 = PyTuple_New(1+1); if (unlikely(!__pyx_t_7)) __PYX_ERR(4, 409, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __Pyx_GIVEREF(__pyx_t_1); PyTuple_SET_ITEM(__pyx_t_7, 0, __pyx_t_1); __pyx_t_1 = NULL; + __Pyx_GIVEREF(__pyx_t_5); + PyTuple_SET_ITEM(__pyx_t_7, 0+1, __pyx_t_5); + __pyx_t_5 = 0; + __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_9, __pyx_t_7, NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(4, 409, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + } + } + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + + /* "asyncpg/protocol/coreproto.pyx":409 + * else: + * self.result_type = RESULT_FAILED + * self.result = apg_exc.InterfaceError( # <<<<<<<<<<<<<< + * 'unsupported authentication method requested by the ' + * 'server: {}'.format(status)) + */ + __Pyx_GIVEREF(__pyx_t_4); + __Pyx_GOTREF(__pyx_v_self->result); + __Pyx_DECREF(__pyx_v_self->result); + __pyx_v_self->result = __pyx_t_4; + __pyx_t_4 = 0; + break; + } + + /* "asyncpg/protocol/coreproto.pyx":413 + * 'server: {}'.format(status)) + * + * self.buffer.consume_message() # <<<<<<<<<<<<<< + * + * cdef _auth_password_message_cleartext(self): + */ + __pyx_t_4 = ((PyObject *)__pyx_f_7asyncpg_8protocol_8protocol_10ReadBuffer_consume_message(__pyx_v_self->buffer)); if (unlikely(!__pyx_t_4)) __PYX_ERR(4, 413, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + + /* "asyncpg/protocol/coreproto.pyx":376 + * self._on_notification(pid, channel, payload) + * + * cdef _parse_msg_authentication(self): # <<<<<<<<<<<<<< + * cdef: + * int32_t status + */ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_XDECREF(__pyx_t_6); + __Pyx_XDECREF(__pyx_t_7); + __Pyx_XDECREF(__pyx_t_8); + __Pyx_XDECREF(__pyx_t_9); + __Pyx_AddTraceback("asyncpg.protocol.protocol.CoreProtocol._parse_msg_authentication", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XDECREF(__pyx_v_md5_salt); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "asyncpg/protocol/coreproto.pyx":415 + * self.buffer.consume_message() + * + * cdef _auth_password_message_cleartext(self): # <<<<<<<<<<<<<< + * cdef: + * WriteBuffer msg + */ + +static PyObject *__pyx_f_7asyncpg_8protocol_8protocol_12CoreProtocol__auth_password_message_cleartext(struct __pyx_obj_7asyncpg_8protocol_8protocol_CoreProtocol *__pyx_v_self) { + struct __pyx_obj_7asyncpg_8protocol_8protocol_WriteBuffer *__pyx_v_msg = 0; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + __Pyx_RefNannySetupContext("_auth_password_message_cleartext", 0); + + /* "asyncpg/protocol/coreproto.pyx":419 + * WriteBuffer msg + * + * msg = WriteBuffer.new_message(b'p') # <<<<<<<<<<<<<< + * msg.write_bytestring(self.password.encode('ascii')) + * msg.end_message() + */ + __pyx_t_1 = ((PyObject *)__pyx_f_7asyncpg_8protocol_8protocol_11WriteBuffer_new_message('p')); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 419, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_v_msg = ((struct __pyx_obj_7asyncpg_8protocol_8protocol_WriteBuffer *)__pyx_t_1); + __pyx_t_1 = 0; + + /* "asyncpg/protocol/coreproto.pyx":420 + * + * msg = WriteBuffer.new_message(b'p') + * msg.write_bytestring(self.password.encode('ascii')) # <<<<<<<<<<<<<< + * msg.end_message() + * + */ + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_password); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 420, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_encode); if (unlikely(!__pyx_t_2)) __PYX_ERR(4, 420, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_tuple__58, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 420, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + if (!(likely(PyBytes_CheckExact(__pyx_t_1))||((__pyx_t_1) == Py_None)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "bytes", Py_TYPE(__pyx_t_1)->tp_name), 0))) __PYX_ERR(4, 420, __pyx_L1_error) + __pyx_t_2 = __pyx_f_7asyncpg_8protocol_8protocol_11WriteBuffer_write_bytestring(__pyx_v_msg, ((PyObject*)__pyx_t_1)); if (unlikely(!__pyx_t_2)) __PYX_ERR(4, 420, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "asyncpg/protocol/coreproto.pyx":421 + * msg = WriteBuffer.new_message(b'p') + * msg.write_bytestring(self.password.encode('ascii')) + * msg.end_message() # <<<<<<<<<<<<<< + * + * return msg + */ + __pyx_t_2 = __pyx_f_7asyncpg_8protocol_8protocol_11WriteBuffer_end_message(__pyx_v_msg); if (unlikely(!__pyx_t_2)) __PYX_ERR(4, 421, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "asyncpg/protocol/coreproto.pyx":423 + * msg.end_message() + * + * return msg # <<<<<<<<<<<<<< + * + * cdef _auth_password_message_md5(self, bytes salt): + */ + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(((PyObject *)__pyx_v_msg)); + __pyx_r = ((PyObject *)__pyx_v_msg); + goto __pyx_L0; + + /* "asyncpg/protocol/coreproto.pyx":415 + * self.buffer.consume_message() + * + * cdef _auth_password_message_cleartext(self): # <<<<<<<<<<<<<< + * cdef: + * WriteBuffer msg + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_AddTraceback("asyncpg.protocol.protocol.CoreProtocol._auth_password_message_cleartext", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XDECREF((PyObject *)__pyx_v_msg); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "asyncpg/protocol/coreproto.pyx":425 + * return msg + * + * cdef _auth_password_message_md5(self, bytes salt): # <<<<<<<<<<<<<< + * cdef: + * WriteBuffer msg + */ + +static PyObject *__pyx_f_7asyncpg_8protocol_8protocol_12CoreProtocol__auth_password_message_md5(struct __pyx_obj_7asyncpg_8protocol_8protocol_CoreProtocol *__pyx_v_self, PyObject *__pyx_v_salt) { + struct __pyx_obj_7asyncpg_8protocol_8protocol_WriteBuffer *__pyx_v_msg = 0; + PyObject *__pyx_v_userpass = NULL; + PyObject *__pyx_v_hash = NULL; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + int __pyx_t_3; + PyObject *__pyx_t_4 = NULL; + PyObject *__pyx_t_5 = NULL; + PyObject *__pyx_t_6 = NULL; + PyObject *__pyx_t_7 = NULL; + PyObject *__pyx_t_8 = NULL; + PyObject *__pyx_t_9 = NULL; + __Pyx_RefNannySetupContext("_auth_password_message_md5", 0); + + /* "asyncpg/protocol/coreproto.pyx":429 + * WriteBuffer msg + * + * msg = WriteBuffer.new_message(b'p') # <<<<<<<<<<<<<< + * + * # 'md5' + md5(md5(password + username) + salt)) + */ + __pyx_t_1 = ((PyObject *)__pyx_f_7asyncpg_8protocol_8protocol_11WriteBuffer_new_message('p')); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 429, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_v_msg = ((struct __pyx_obj_7asyncpg_8protocol_8protocol_WriteBuffer *)__pyx_t_1); + __pyx_t_1 = 0; + + /* "asyncpg/protocol/coreproto.pyx":432 + * + * # 'md5' + md5(md5(password + username) + salt)) + * userpass = ((self.password or '') + (self.user or '')).encode('ascii') # <<<<<<<<<<<<<< + * hash = hashlib_md5(hashlib_md5(userpass).hexdigest().\ + * encode('ascii') + salt).hexdigest().encode('ascii') + */ + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_password); if (unlikely(!__pyx_t_2)) __PYX_ERR(4, 432, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = __Pyx_PyObject_IsTrue(__pyx_t_2); if (unlikely(__pyx_t_3 < 0)) __PYX_ERR(4, 432, __pyx_L1_error) + if (!__pyx_t_3) { + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } else { + __Pyx_INCREF(__pyx_t_2); + __pyx_t_1 = __pyx_t_2; + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + goto __pyx_L3_bool_binop_done; + } + __Pyx_INCREF(__pyx_kp_u__18); + __pyx_t_1 = __pyx_kp_u__18; + __pyx_L3_bool_binop_done:; + __pyx_t_4 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_user); if (unlikely(!__pyx_t_4)) __PYX_ERR(4, 432, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_3 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_3 < 0)) __PYX_ERR(4, 432, __pyx_L1_error) + if (!__pyx_t_3) { + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + } else { + __Pyx_INCREF(__pyx_t_4); + __pyx_t_2 = __pyx_t_4; + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + goto __pyx_L5_bool_binop_done; + } + __Pyx_INCREF(__pyx_kp_u__18); + __pyx_t_2 = __pyx_kp_u__18; + __pyx_L5_bool_binop_done:; + __pyx_t_4 = PyNumber_Add(__pyx_t_1, __pyx_t_2); if (unlikely(!__pyx_t_4)) __PYX_ERR(4, 432, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_n_s_encode); if (unlikely(!__pyx_t_2)) __PYX_ERR(4, 432, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_tuple__59, NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(4, 432, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_v_userpass = __pyx_t_4; + __pyx_t_4 = 0; + + /* "asyncpg/protocol/coreproto.pyx":433 + * # 'md5' + md5(md5(password + username) + salt)) + * userpass = ((self.password or '') + (self.user or '')).encode('ascii') + * hash = hashlib_md5(hashlib_md5(userpass).hexdigest().\ # <<<<<<<<<<<<<< + * encode('ascii') + salt).hexdigest().encode('ascii') + * + */ + __pyx_t_1 = __Pyx_GetModuleGlobalName(__pyx_n_s_hashlib_md5); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 433, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_7 = __Pyx_GetModuleGlobalName(__pyx_n_s_hashlib_md5); if (unlikely(!__pyx_t_7)) __PYX_ERR(4, 433, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __pyx_t_8 = NULL; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_7))) { + __pyx_t_8 = PyMethod_GET_SELF(__pyx_t_7); + if (likely(__pyx_t_8)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_7); + __Pyx_INCREF(__pyx_t_8); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_7, function); + } + } + if (!__pyx_t_8) { + __pyx_t_6 = __Pyx_PyObject_CallOneArg(__pyx_t_7, __pyx_v_userpass); if (unlikely(!__pyx_t_6)) __PYX_ERR(4, 433, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + } else { + #if CYTHON_FAST_PYCALL + if (PyFunction_Check(__pyx_t_7)) { + PyObject *__pyx_temp[2] = {__pyx_t_8, __pyx_v_userpass}; + __pyx_t_6 = __Pyx_PyFunction_FastCall(__pyx_t_7, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_6)) __PYX_ERR(4, 433, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; + __Pyx_GOTREF(__pyx_t_6); + } else + #endif + #if CYTHON_FAST_PYCCALL + if (__Pyx_PyFastCFunction_Check(__pyx_t_7)) { + PyObject *__pyx_temp[2] = {__pyx_t_8, __pyx_v_userpass}; + __pyx_t_6 = __Pyx_PyCFunction_FastCall(__pyx_t_7, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_6)) __PYX_ERR(4, 433, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; + __Pyx_GOTREF(__pyx_t_6); + } else + #endif + { + __pyx_t_9 = PyTuple_New(1+1); if (unlikely(!__pyx_t_9)) __PYX_ERR(4, 433, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_9); + __Pyx_GIVEREF(__pyx_t_8); PyTuple_SET_ITEM(__pyx_t_9, 0, __pyx_t_8); __pyx_t_8 = NULL; + __Pyx_INCREF(__pyx_v_userpass); + __Pyx_GIVEREF(__pyx_v_userpass); + PyTuple_SET_ITEM(__pyx_t_9, 0+1, __pyx_v_userpass); + __pyx_t_6 = __Pyx_PyObject_Call(__pyx_t_7, __pyx_t_9, NULL); if (unlikely(!__pyx_t_6)) __PYX_ERR(4, 433, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + } + } + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_n_s_hexdigest); if (unlikely(!__pyx_t_7)) __PYX_ERR(4, 433, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __pyx_t_6 = NULL; + if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_7))) { + __pyx_t_6 = PyMethod_GET_SELF(__pyx_t_7); + if (likely(__pyx_t_6)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_7); + __Pyx_INCREF(__pyx_t_6); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_7, function); + } + } + if (__pyx_t_6) { + __pyx_t_5 = __Pyx_PyObject_CallOneArg(__pyx_t_7, __pyx_t_6); if (unlikely(!__pyx_t_5)) __PYX_ERR(4, 433, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + } else { + __pyx_t_5 = __Pyx_PyObject_CallNoArg(__pyx_t_7); if (unlikely(!__pyx_t_5)) __PYX_ERR(4, 433, __pyx_L1_error) + } + __Pyx_GOTREF(__pyx_t_5); + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_t_5, __pyx_n_s_encode); if (unlikely(!__pyx_t_7)) __PYX_ERR(4, 433, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + + /* "asyncpg/protocol/coreproto.pyx":434 + * userpass = ((self.password or '') + (self.user or '')).encode('ascii') + * hash = hashlib_md5(hashlib_md5(userpass).hexdigest().\ + * encode('ascii') + salt).hexdigest().encode('ascii') # <<<<<<<<<<<<<< + * + * msg.write_bytestring(b'md5' + hash) + */ + __pyx_t_5 = __Pyx_PyObject_Call(__pyx_t_7, __pyx_tuple__60, NULL); if (unlikely(!__pyx_t_5)) __PYX_ERR(4, 434, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __pyx_t_7 = PyNumber_Add(__pyx_t_5, __pyx_v_salt); if (unlikely(!__pyx_t_7)) __PYX_ERR(4, 434, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __pyx_t_5 = NULL; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_1))) { + __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_1); + if (likely(__pyx_t_5)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_1); + __Pyx_INCREF(__pyx_t_5); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_1, function); + } + } + if (!__pyx_t_5) { + __pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_t_1, __pyx_t_7); if (unlikely(!__pyx_t_2)) __PYX_ERR(4, 433, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_GOTREF(__pyx_t_2); + } else { + #if CYTHON_FAST_PYCALL + if (PyFunction_Check(__pyx_t_1)) { + PyObject *__pyx_temp[2] = {__pyx_t_5, __pyx_t_7}; + __pyx_t_2 = __Pyx_PyFunction_FastCall(__pyx_t_1, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_2)) __PYX_ERR(4, 433, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + } else + #endif + #if CYTHON_FAST_PYCCALL + if (__Pyx_PyFastCFunction_Check(__pyx_t_1)) { + PyObject *__pyx_temp[2] = {__pyx_t_5, __pyx_t_7}; + __pyx_t_2 = __Pyx_PyCFunction_FastCall(__pyx_t_1, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_2)) __PYX_ERR(4, 433, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + } else + #endif + { + __pyx_t_6 = PyTuple_New(1+1); if (unlikely(!__pyx_t_6)) __PYX_ERR(4, 433, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_GIVEREF(__pyx_t_5); PyTuple_SET_ITEM(__pyx_t_6, 0, __pyx_t_5); __pyx_t_5 = NULL; + __Pyx_GIVEREF(__pyx_t_7); + PyTuple_SET_ITEM(__pyx_t_6, 0+1, __pyx_t_7); + __pyx_t_7 = 0; + __pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_t_6, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(4, 433, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + } + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_hexdigest); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 434, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_2 = NULL; + if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_1))) { + __pyx_t_2 = PyMethod_GET_SELF(__pyx_t_1); + if (likely(__pyx_t_2)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_1); + __Pyx_INCREF(__pyx_t_2); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_1, function); + } + } + if (__pyx_t_2) { + __pyx_t_4 = __Pyx_PyObject_CallOneArg(__pyx_t_1, __pyx_t_2); if (unlikely(!__pyx_t_4)) __PYX_ERR(4, 434, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } else { + __pyx_t_4 = __Pyx_PyObject_CallNoArg(__pyx_t_1); if (unlikely(!__pyx_t_4)) __PYX_ERR(4, 434, __pyx_L1_error) + } + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_n_s_encode); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 434, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_tuple__61, NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(4, 434, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_v_hash = __pyx_t_4; + __pyx_t_4 = 0; + + /* "asyncpg/protocol/coreproto.pyx":436 + * encode('ascii') + salt).hexdigest().encode('ascii') + * + * msg.write_bytestring(b'md5' + hash) # <<<<<<<<<<<<<< + * msg.end_message() + * + */ + __pyx_t_4 = PyNumber_Add(__pyx_n_b_md5, __pyx_v_hash); if (unlikely(!__pyx_t_4)) __PYX_ERR(4, 436, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + if (!(likely(PyBytes_CheckExact(__pyx_t_4))||((__pyx_t_4) == Py_None)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "bytes", Py_TYPE(__pyx_t_4)->tp_name), 0))) __PYX_ERR(4, 436, __pyx_L1_error) + __pyx_t_1 = __pyx_f_7asyncpg_8protocol_8protocol_11WriteBuffer_write_bytestring(__pyx_v_msg, ((PyObject*)__pyx_t_4)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 436, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "asyncpg/protocol/coreproto.pyx":437 + * + * msg.write_bytestring(b'md5' + hash) + * msg.end_message() # <<<<<<<<<<<<<< + * + * return msg + */ + __pyx_t_1 = __pyx_f_7asyncpg_8protocol_8protocol_11WriteBuffer_end_message(__pyx_v_msg); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 437, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "asyncpg/protocol/coreproto.pyx":439 + * msg.end_message() + * + * return msg # <<<<<<<<<<<<<< + * + * cdef _parse_msg_ready_for_query(self): + */ + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(((PyObject *)__pyx_v_msg)); + __pyx_r = ((PyObject *)__pyx_v_msg); + goto __pyx_L0; + + /* "asyncpg/protocol/coreproto.pyx":425 + * return msg + * + * cdef _auth_password_message_md5(self, bytes salt): # <<<<<<<<<<<<<< + * cdef: + * WriteBuffer msg + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_XDECREF(__pyx_t_6); + __Pyx_XDECREF(__pyx_t_7); + __Pyx_XDECREF(__pyx_t_8); + __Pyx_XDECREF(__pyx_t_9); + __Pyx_AddTraceback("asyncpg.protocol.protocol.CoreProtocol._auth_password_message_md5", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XDECREF((PyObject *)__pyx_v_msg); + __Pyx_XDECREF(__pyx_v_userpass); + __Pyx_XDECREF(__pyx_v_hash); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "asyncpg/protocol/coreproto.pyx":441 + * return msg + * + * cdef _parse_msg_ready_for_query(self): # <<<<<<<<<<<<<< + * cdef char status = self.buffer.read_byte() + * + */ + +static PyObject *__pyx_f_7asyncpg_8protocol_8protocol_12CoreProtocol__parse_msg_ready_for_query(struct __pyx_obj_7asyncpg_8protocol_8protocol_CoreProtocol *__pyx_v_self) { + char __pyx_v_status; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + char __pyx_t_2; + __Pyx_RefNannySetupContext("_parse_msg_ready_for_query", 0); + + /* "asyncpg/protocol/coreproto.pyx":442 + * + * cdef _parse_msg_ready_for_query(self): + * cdef char status = self.buffer.read_byte() # <<<<<<<<<<<<<< + * + * if status == b'I': + */ + __pyx_t_1 = __pyx_f_7asyncpg_8protocol_8protocol_10ReadBuffer_read_byte(__pyx_v_self->buffer); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 442, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = __Pyx_PyInt_As_char(__pyx_t_1); if (unlikely((__pyx_t_2 == (char)-1) && PyErr_Occurred())) __PYX_ERR(4, 442, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_v_status = __pyx_t_2; + + /* "asyncpg/protocol/coreproto.pyx":444 + * cdef char status = self.buffer.read_byte() + * + * if status == b'I': # <<<<<<<<<<<<<< + * self.xact_status = PQTRANS_IDLE + * elif status == b'T': + */ + switch (__pyx_v_status) { + case 'I': + + /* "asyncpg/protocol/coreproto.pyx":445 + * + * if status == b'I': + * self.xact_status = PQTRANS_IDLE # <<<<<<<<<<<<<< + * elif status == b'T': + * self.xact_status = PQTRANS_INTRANS + */ + __pyx_v_self->xact_status = __pyx_e_7asyncpg_8protocol_8protocol_PQTRANS_IDLE; + + /* "asyncpg/protocol/coreproto.pyx":444 + * cdef char status = self.buffer.read_byte() + * + * if status == b'I': # <<<<<<<<<<<<<< + * self.xact_status = PQTRANS_IDLE + * elif status == b'T': + */ + break; + + /* "asyncpg/protocol/coreproto.pyx":446 + * if status == b'I': + * self.xact_status = PQTRANS_IDLE + * elif status == b'T': # <<<<<<<<<<<<<< + * self.xact_status = PQTRANS_INTRANS + * elif status == b'E': + */ + case 'T': + + /* "asyncpg/protocol/coreproto.pyx":447 + * self.xact_status = PQTRANS_IDLE + * elif status == b'T': + * self.xact_status = PQTRANS_INTRANS # <<<<<<<<<<<<<< + * elif status == b'E': + * self.xact_status = PQTRANS_INERROR + */ + __pyx_v_self->xact_status = __pyx_e_7asyncpg_8protocol_8protocol_PQTRANS_INTRANS; + + /* "asyncpg/protocol/coreproto.pyx":446 + * if status == b'I': + * self.xact_status = PQTRANS_IDLE + * elif status == b'T': # <<<<<<<<<<<<<< + * self.xact_status = PQTRANS_INTRANS + * elif status == b'E': + */ + break; + + /* "asyncpg/protocol/coreproto.pyx":448 + * elif status == b'T': + * self.xact_status = PQTRANS_INTRANS + * elif status == b'E': # <<<<<<<<<<<<<< + * self.xact_status = PQTRANS_INERROR + * else: + */ + case 'E': + + /* "asyncpg/protocol/coreproto.pyx":449 + * self.xact_status = PQTRANS_INTRANS + * elif status == b'E': + * self.xact_status = PQTRANS_INERROR # <<<<<<<<<<<<<< + * else: + * self.xact_status = PQTRANS_UNKNOWN + */ + __pyx_v_self->xact_status = __pyx_e_7asyncpg_8protocol_8protocol_PQTRANS_INERROR; + + /* "asyncpg/protocol/coreproto.pyx":448 + * elif status == b'T': + * self.xact_status = PQTRANS_INTRANS + * elif status == b'E': # <<<<<<<<<<<<<< + * self.xact_status = PQTRANS_INERROR + * else: + */ + break; + default: + + /* "asyncpg/protocol/coreproto.pyx":451 + * self.xact_status = PQTRANS_INERROR + * else: + * self.xact_status = PQTRANS_UNKNOWN # <<<<<<<<<<<<<< + * + * cdef _parse_msg_error_response(self, is_error): + */ + __pyx_v_self->xact_status = __pyx_e_7asyncpg_8protocol_8protocol_PQTRANS_UNKNOWN; + break; + } + + /* "asyncpg/protocol/coreproto.pyx":441 + * return msg + * + * cdef _parse_msg_ready_for_query(self): # <<<<<<<<<<<<<< + * cdef char status = self.buffer.read_byte() + * + */ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("asyncpg.protocol.protocol.CoreProtocol._parse_msg_ready_for_query", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "asyncpg/protocol/coreproto.pyx":453 + * self.xact_status = PQTRANS_UNKNOWN + * + * cdef _parse_msg_error_response(self, is_error): # <<<<<<<<<<<<<< + * cdef: + * char code + */ + +static PyObject *__pyx_f_7asyncpg_8protocol_8protocol_12CoreProtocol__parse_msg_error_response(struct __pyx_obj_7asyncpg_8protocol_8protocol_CoreProtocol *__pyx_v_self, PyObject *__pyx_v_is_error) { + char __pyx_v_code; + PyObject *__pyx_v_message = 0; + PyObject *__pyx_v_parsed = 0; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + char __pyx_t_2; + int __pyx_t_3; + PyObject *__pyx_t_4 = NULL; + PyObject *__pyx_t_5 = NULL; + __Pyx_RefNannySetupContext("_parse_msg_error_response", 0); + + /* "asyncpg/protocol/coreproto.pyx":457 + * char code + * bytes message + * dict parsed = {} # <<<<<<<<<<<<<< + * + * while True: + */ + __pyx_t_1 = PyDict_New(); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 457, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_v_parsed = ((PyObject*)__pyx_t_1); + __pyx_t_1 = 0; + + /* "asyncpg/protocol/coreproto.pyx":459 + * dict parsed = {} + * + * while True: # <<<<<<<<<<<<<< + * code = self.buffer.read_byte() + * if code == 0: + */ + while (1) { + + /* "asyncpg/protocol/coreproto.pyx":460 + * + * while True: + * code = self.buffer.read_byte() # <<<<<<<<<<<<<< + * if code == 0: + * break + */ + __pyx_t_1 = __pyx_f_7asyncpg_8protocol_8protocol_10ReadBuffer_read_byte(__pyx_v_self->buffer); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 460, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = __Pyx_PyInt_As_char(__pyx_t_1); if (unlikely((__pyx_t_2 == (char)-1) && PyErr_Occurred())) __PYX_ERR(4, 460, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_v_code = __pyx_t_2; + + /* "asyncpg/protocol/coreproto.pyx":461 + * while True: + * code = self.buffer.read_byte() + * if code == 0: # <<<<<<<<<<<<<< + * break + * + */ + __pyx_t_3 = ((__pyx_v_code == 0) != 0); + if (__pyx_t_3) { + + /* "asyncpg/protocol/coreproto.pyx":462 + * code = self.buffer.read_byte() + * if code == 0: + * break # <<<<<<<<<<<<<< + * + * message = self.buffer.read_cstr() + */ + goto __pyx_L4_break; + + /* "asyncpg/protocol/coreproto.pyx":461 + * while True: + * code = self.buffer.read_byte() + * if code == 0: # <<<<<<<<<<<<<< + * break + * + */ + } + + /* "asyncpg/protocol/coreproto.pyx":464 + * break + * + * message = self.buffer.read_cstr() # <<<<<<<<<<<<<< + * + * parsed[chr(code)] = message.decode() + */ + __pyx_t_1 = __pyx_f_7asyncpg_8protocol_8protocol_10ReadBuffer_read_cstr(__pyx_v_self->buffer); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 464, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (!(likely(PyBytes_CheckExact(__pyx_t_1))||((__pyx_t_1) == Py_None)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "bytes", Py_TYPE(__pyx_t_1)->tp_name), 0))) __PYX_ERR(4, 464, __pyx_L1_error) + __Pyx_XDECREF_SET(__pyx_v_message, ((PyObject*)__pyx_t_1)); + __pyx_t_1 = 0; + + /* "asyncpg/protocol/coreproto.pyx":466 + * message = self.buffer.read_cstr() + * + * parsed[chr(code)] = message.decode() # <<<<<<<<<<<<<< + * + * if is_error: + */ + if (unlikely(__pyx_v_message == Py_None)) { + PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%s'", "decode"); + __PYX_ERR(4, 466, __pyx_L1_error) + } + __pyx_t_1 = __Pyx_decode_bytes(__pyx_v_message, 0, PY_SSIZE_T_MAX, NULL, NULL, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 466, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_4 = __Pyx_PyInt_From_char(__pyx_v_code); if (unlikely(!__pyx_t_4)) __PYX_ERR(4, 466, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_5 = PyTuple_New(1); if (unlikely(!__pyx_t_5)) __PYX_ERR(4, 466, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_GIVEREF(__pyx_t_4); + PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_t_4); + __pyx_t_4 = 0; + __pyx_t_4 = __Pyx_PyObject_Call(__pyx_builtin_chr, __pyx_t_5, NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(4, 466, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + if (unlikely(PyDict_SetItem(__pyx_v_parsed, __pyx_t_4, __pyx_t_1) < 0)) __PYX_ERR(4, 466, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + } + __pyx_L4_break:; + + /* "asyncpg/protocol/coreproto.pyx":468 + * parsed[chr(code)] = message.decode() + * + * if is_error: # <<<<<<<<<<<<<< + * self.result_type = RESULT_FAILED + * self.result = parsed + */ + __pyx_t_3 = __Pyx_PyObject_IsTrue(__pyx_v_is_error); if (unlikely(__pyx_t_3 < 0)) __PYX_ERR(4, 468, __pyx_L1_error) + if (__pyx_t_3) { + + /* "asyncpg/protocol/coreproto.pyx":469 + * + * if is_error: + * self.result_type = RESULT_FAILED # <<<<<<<<<<<<<< + * self.result = parsed + * + */ + __pyx_v_self->result_type = __pyx_e_7asyncpg_8protocol_8protocol_RESULT_FAILED; + + /* "asyncpg/protocol/coreproto.pyx":470 + * if is_error: + * self.result_type = RESULT_FAILED + * self.result = parsed # <<<<<<<<<<<<<< + * + * cdef _push_result(self): + */ + __Pyx_INCREF(__pyx_v_parsed); + __Pyx_GIVEREF(__pyx_v_parsed); + __Pyx_GOTREF(__pyx_v_self->result); + __Pyx_DECREF(__pyx_v_self->result); + __pyx_v_self->result = __pyx_v_parsed; + + /* "asyncpg/protocol/coreproto.pyx":468 + * parsed[chr(code)] = message.decode() + * + * if is_error: # <<<<<<<<<<<<<< + * self.result_type = RESULT_FAILED + * self.result = parsed + */ + } + + /* "asyncpg/protocol/coreproto.pyx":453 + * self.xact_status = PQTRANS_UNKNOWN + * + * cdef _parse_msg_error_response(self, is_error): # <<<<<<<<<<<<<< + * cdef: + * char code + */ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_AddTraceback("asyncpg.protocol.protocol.CoreProtocol._parse_msg_error_response", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XDECREF(__pyx_v_message); + __Pyx_XDECREF(__pyx_v_parsed); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "asyncpg/protocol/coreproto.pyx":472 + * self.result = parsed + * + * cdef _push_result(self): # <<<<<<<<<<<<<< + * try: + * self._on_result() + */ + +static PyObject *__pyx_f_7asyncpg_8protocol_8protocol_12CoreProtocol__push_result(struct __pyx_obj_7asyncpg_8protocol_8protocol_CoreProtocol *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_t_2; + int __pyx_t_3; + char const *__pyx_t_4; + PyObject *__pyx_t_5 = NULL; + PyObject *__pyx_t_6 = NULL; + PyObject *__pyx_t_7 = NULL; + PyObject *__pyx_t_8 = NULL; + PyObject *__pyx_t_9 = NULL; + PyObject *__pyx_t_10 = NULL; + __Pyx_RefNannySetupContext("_push_result", 0); + + /* "asyncpg/protocol/coreproto.pyx":473 + * + * cdef _push_result(self): + * try: # <<<<<<<<<<<<<< + * self._on_result() + * finally: + */ + /*try:*/ { + + /* "asyncpg/protocol/coreproto.pyx":474 + * cdef _push_result(self): + * try: + * self._on_result() # <<<<<<<<<<<<<< + * finally: + * self._set_state(PROTOCOL_IDLE) + */ + __pyx_t_1 = ((struct __pyx_vtabstruct_7asyncpg_8protocol_8protocol_CoreProtocol *)__pyx_v_self->__pyx_vtab)->_on_result(__pyx_v_self); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 474, __pyx_L4_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + } + + /* "asyncpg/protocol/coreproto.pyx":476 + * self._on_result() + * finally: + * self._set_state(PROTOCOL_IDLE) # <<<<<<<<<<<<<< + * self._reset_result() + * + */ + /*finally:*/ { + /*normal exit:*/{ + __pyx_t_1 = ((struct __pyx_vtabstruct_7asyncpg_8protocol_8protocol_CoreProtocol *)__pyx_v_self->__pyx_vtab)->_set_state(__pyx_v_self, __pyx_e_7asyncpg_8protocol_8protocol_PROTOCOL_IDLE); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 476, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "asyncpg/protocol/coreproto.pyx":477 + * finally: + * self._set_state(PROTOCOL_IDLE) + * self._reset_result() # <<<<<<<<<<<<<< + * + * cdef _reset_result(self): + */ + __pyx_t_1 = ((struct __pyx_vtabstruct_7asyncpg_8protocol_8protocol_CoreProtocol *)__pyx_v_self->__pyx_vtab)->_reset_result(__pyx_v_self); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 477, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + goto __pyx_L5; + } + /*exception exit:*/{ + __Pyx_PyThreadState_declare + __pyx_L4_error:; + __pyx_t_5 = 0; __pyx_t_6 = 0; __pyx_t_7 = 0; __pyx_t_8 = 0; __pyx_t_9 = 0; __pyx_t_10 = 0; + __Pyx_PyThreadState_assign + __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; + if (PY_MAJOR_VERSION >= 3) __Pyx_ExceptionSwap(&__pyx_t_8, &__pyx_t_9, &__pyx_t_10); + if ((PY_MAJOR_VERSION < 3) || unlikely(__Pyx_GetException(&__pyx_t_5, &__pyx_t_6, &__pyx_t_7) < 0)) __Pyx_ErrFetch(&__pyx_t_5, &__pyx_t_6, &__pyx_t_7); + __Pyx_XGOTREF(__pyx_t_5); + __Pyx_XGOTREF(__pyx_t_6); + __Pyx_XGOTREF(__pyx_t_7); + __Pyx_XGOTREF(__pyx_t_8); + __Pyx_XGOTREF(__pyx_t_9); + __Pyx_XGOTREF(__pyx_t_10); + __pyx_t_2 = __pyx_lineno; __pyx_t_3 = __pyx_clineno; __pyx_t_4 = __pyx_filename; + { + + /* "asyncpg/protocol/coreproto.pyx":476 + * self._on_result() + * finally: + * self._set_state(PROTOCOL_IDLE) # <<<<<<<<<<<<<< + * self._reset_result() + * + */ + __pyx_t_1 = ((struct __pyx_vtabstruct_7asyncpg_8protocol_8protocol_CoreProtocol *)__pyx_v_self->__pyx_vtab)->_set_state(__pyx_v_self, __pyx_e_7asyncpg_8protocol_8protocol_PROTOCOL_IDLE); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 476, __pyx_L7_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "asyncpg/protocol/coreproto.pyx":477 + * finally: + * self._set_state(PROTOCOL_IDLE) + * self._reset_result() # <<<<<<<<<<<<<< + * + * cdef _reset_result(self): + */ + __pyx_t_1 = ((struct __pyx_vtabstruct_7asyncpg_8protocol_8protocol_CoreProtocol *)__pyx_v_self->__pyx_vtab)->_reset_result(__pyx_v_self); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 477, __pyx_L7_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + } + __Pyx_PyThreadState_assign + if (PY_MAJOR_VERSION >= 3) { + __Pyx_XGIVEREF(__pyx_t_8); + __Pyx_XGIVEREF(__pyx_t_9); + __Pyx_XGIVEREF(__pyx_t_10); + __Pyx_ExceptionReset(__pyx_t_8, __pyx_t_9, __pyx_t_10); + } + __Pyx_XGIVEREF(__pyx_t_5); + __Pyx_XGIVEREF(__pyx_t_6); + __Pyx_XGIVEREF(__pyx_t_7); + __Pyx_ErrRestore(__pyx_t_5, __pyx_t_6, __pyx_t_7); + __pyx_t_5 = 0; __pyx_t_6 = 0; __pyx_t_7 = 0; __pyx_t_8 = 0; __pyx_t_9 = 0; __pyx_t_10 = 0; + __pyx_lineno = __pyx_t_2; __pyx_clineno = __pyx_t_3; __pyx_filename = __pyx_t_4; + goto __pyx_L1_error; + __pyx_L7_error:; + __Pyx_PyThreadState_assign + if (PY_MAJOR_VERSION >= 3) { + __Pyx_XGIVEREF(__pyx_t_8); + __Pyx_XGIVEREF(__pyx_t_9); + __Pyx_XGIVEREF(__pyx_t_10); + __Pyx_ExceptionReset(__pyx_t_8, __pyx_t_9, __pyx_t_10); + } + __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; + __pyx_t_8 = 0; __pyx_t_9 = 0; __pyx_t_10 = 0; + goto __pyx_L1_error; + } + __pyx_L5:; + } + + /* "asyncpg/protocol/coreproto.pyx":472 + * self.result = parsed + * + * cdef _push_result(self): # <<<<<<<<<<<<<< + * try: + * self._on_result() + */ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("asyncpg.protocol.protocol.CoreProtocol._push_result", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "asyncpg/protocol/coreproto.pyx":479 + * self._reset_result() + * + * cdef _reset_result(self): # <<<<<<<<<<<<<< + * self.result_type = RESULT_OK + * self.result = None + */ + +static PyObject *__pyx_f_7asyncpg_8protocol_8protocol_12CoreProtocol__reset_result(struct __pyx_obj_7asyncpg_8protocol_8protocol_CoreProtocol *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("_reset_result", 0); + + /* "asyncpg/protocol/coreproto.pyx":480 + * + * cdef _reset_result(self): + * self.result_type = RESULT_OK # <<<<<<<<<<<<<< + * self.result = None + * self.result_param_desc = None + */ + __pyx_v_self->result_type = __pyx_e_7asyncpg_8protocol_8protocol_RESULT_OK; + + /* "asyncpg/protocol/coreproto.pyx":481 + * cdef _reset_result(self): + * self.result_type = RESULT_OK + * self.result = None # <<<<<<<<<<<<<< + * self.result_param_desc = None + * self.result_row_desc = None + */ + __Pyx_INCREF(Py_None); + __Pyx_GIVEREF(Py_None); + __Pyx_GOTREF(__pyx_v_self->result); + __Pyx_DECREF(__pyx_v_self->result); + __pyx_v_self->result = Py_None; + + /* "asyncpg/protocol/coreproto.pyx":482 + * self.result_type = RESULT_OK + * self.result = None + * self.result_param_desc = None # <<<<<<<<<<<<<< + * self.result_row_desc = None + * self.result_status_msg = None + */ + __Pyx_INCREF(Py_None); + __Pyx_GIVEREF(Py_None); + __Pyx_GOTREF(__pyx_v_self->result_param_desc); + __Pyx_DECREF(__pyx_v_self->result_param_desc); + __pyx_v_self->result_param_desc = ((PyObject*)Py_None); + + /* "asyncpg/protocol/coreproto.pyx":483 + * self.result = None + * self.result_param_desc = None + * self.result_row_desc = None # <<<<<<<<<<<<<< + * self.result_status_msg = None + * self.result_execute_completed = False + */ + __Pyx_INCREF(Py_None); + __Pyx_GIVEREF(Py_None); + __Pyx_GOTREF(__pyx_v_self->result_row_desc); + __Pyx_DECREF(__pyx_v_self->result_row_desc); + __pyx_v_self->result_row_desc = ((PyObject*)Py_None); + + /* "asyncpg/protocol/coreproto.pyx":484 + * self.result_param_desc = None + * self.result_row_desc = None + * self.result_status_msg = None # <<<<<<<<<<<<<< + * self.result_execute_completed = False + * self._discard_data = False + */ + __Pyx_INCREF(Py_None); + __Pyx_GIVEREF(Py_None); + __Pyx_GOTREF(__pyx_v_self->result_status_msg); + __Pyx_DECREF(__pyx_v_self->result_status_msg); + __pyx_v_self->result_status_msg = ((PyObject*)Py_None); + + /* "asyncpg/protocol/coreproto.pyx":485 + * self.result_row_desc = None + * self.result_status_msg = None + * self.result_execute_completed = False # <<<<<<<<<<<<<< + * self._discard_data = False + * + */ + __pyx_v_self->result_execute_completed = 0; + + /* "asyncpg/protocol/coreproto.pyx":486 + * self.result_status_msg = None + * self.result_execute_completed = False + * self._discard_data = False # <<<<<<<<<<<<<< + * + * cdef _set_state(self, ProtocolState new_state): + */ + __pyx_v_self->_discard_data = 0; + + /* "asyncpg/protocol/coreproto.pyx":479 + * self._reset_result() + * + * cdef _reset_result(self): # <<<<<<<<<<<<<< + * self.result_type = RESULT_OK + * self.result = None + */ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "asyncpg/protocol/coreproto.pyx":488 + * self._discard_data = False + * + * cdef _set_state(self, ProtocolState new_state): # <<<<<<<<<<<<<< + * if new_state == PROTOCOL_IDLE: + * if self.state == PROTOCOL_FAILED: + */ + +static PyObject *__pyx_f_7asyncpg_8protocol_8protocol_12CoreProtocol__set_state(struct __pyx_obj_7asyncpg_8protocol_8protocol_CoreProtocol *__pyx_v_self, enum __pyx_t_7asyncpg_8protocol_8protocol_ProtocolState __pyx_v_new_state) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + PyObject *__pyx_t_5 = NULL; + PyObject *__pyx_t_6 = NULL; + int __pyx_t_7; + PyObject *__pyx_t_8 = NULL; + __Pyx_RefNannySetupContext("_set_state", 0); + + /* "asyncpg/protocol/coreproto.pyx":489 + * + * cdef _set_state(self, ProtocolState new_state): + * if new_state == PROTOCOL_IDLE: # <<<<<<<<<<<<<< + * if self.state == PROTOCOL_FAILED: + * raise RuntimeError( + */ + switch (__pyx_v_new_state) { + case __pyx_e_7asyncpg_8protocol_8protocol_PROTOCOL_IDLE: + + /* "asyncpg/protocol/coreproto.pyx":490 + * cdef _set_state(self, ProtocolState new_state): + * if new_state == PROTOCOL_IDLE: + * if self.state == PROTOCOL_FAILED: # <<<<<<<<<<<<<< + * raise RuntimeError( + * 'cannot switch to "idle" state; ' + */ + __pyx_t_1 = ((__pyx_v_self->state == __pyx_e_7asyncpg_8protocol_8protocol_PROTOCOL_FAILED) != 0); + if (__pyx_t_1) { + + /* "asyncpg/protocol/coreproto.pyx":491 + * if new_state == PROTOCOL_IDLE: + * if self.state == PROTOCOL_FAILED: + * raise RuntimeError( # <<<<<<<<<<<<<< + * 'cannot switch to "idle" state; ' + * 'protocol is in the "failed" state') + */ + __pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_RuntimeError, __pyx_tuple__62, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(4, 491, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_Raise(__pyx_t_2, 0, 0, 0); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __PYX_ERR(4, 491, __pyx_L1_error) + + /* "asyncpg/protocol/coreproto.pyx":490 + * cdef _set_state(self, ProtocolState new_state): + * if new_state == PROTOCOL_IDLE: + * if self.state == PROTOCOL_FAILED: # <<<<<<<<<<<<<< + * raise RuntimeError( + * 'cannot switch to "idle" state; ' + */ + } + + /* "asyncpg/protocol/coreproto.pyx":494 + * 'cannot switch to "idle" state; ' + * 'protocol is in the "failed" state') + * elif self.state == PROTOCOL_IDLE: # <<<<<<<<<<<<<< + * raise RuntimeError( + * 'protocol is already in the "idle" state') + */ + __pyx_t_1 = ((__pyx_v_self->state == __pyx_e_7asyncpg_8protocol_8protocol_PROTOCOL_IDLE) != 0); + if (__pyx_t_1) { + + /* "asyncpg/protocol/coreproto.pyx":495 + * 'protocol is in the "failed" state') + * elif self.state == PROTOCOL_IDLE: + * raise RuntimeError( # <<<<<<<<<<<<<< + * 'protocol is already in the "idle" state') + * else: + */ + __pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_RuntimeError, __pyx_tuple__63, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(4, 495, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_Raise(__pyx_t_2, 0, 0, 0); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __PYX_ERR(4, 495, __pyx_L1_error) + + /* "asyncpg/protocol/coreproto.pyx":494 + * 'cannot switch to "idle" state; ' + * 'protocol is in the "failed" state') + * elif self.state == PROTOCOL_IDLE: # <<<<<<<<<<<<<< + * raise RuntimeError( + * 'protocol is already in the "idle" state') + */ + } + + /* "asyncpg/protocol/coreproto.pyx":498 + * 'protocol is already in the "idle" state') + * else: + * self.state = new_state # <<<<<<<<<<<<<< + * + * elif new_state == PROTOCOL_FAILED: + */ + /*else*/ { + __pyx_v_self->state = __pyx_v_new_state; + } + + /* "asyncpg/protocol/coreproto.pyx":489 + * + * cdef _set_state(self, ProtocolState new_state): + * if new_state == PROTOCOL_IDLE: # <<<<<<<<<<<<<< + * if self.state == PROTOCOL_FAILED: + * raise RuntimeError( + */ + break; + + /* "asyncpg/protocol/coreproto.pyx":500 + * self.state = new_state + * + * elif new_state == PROTOCOL_FAILED: # <<<<<<<<<<<<<< + * self.state = PROTOCOL_FAILED + * + */ + case __pyx_e_7asyncpg_8protocol_8protocol_PROTOCOL_FAILED: + + /* "asyncpg/protocol/coreproto.pyx":501 + * + * elif new_state == PROTOCOL_FAILED: + * self.state = PROTOCOL_FAILED # <<<<<<<<<<<<<< + * + * else: + */ + __pyx_v_self->state = __pyx_e_7asyncpg_8protocol_8protocol_PROTOCOL_FAILED; + + /* "asyncpg/protocol/coreproto.pyx":500 + * self.state = new_state + * + * elif new_state == PROTOCOL_FAILED: # <<<<<<<<<<<<<< + * self.state = PROTOCOL_FAILED + * + */ + break; + default: + + /* "asyncpg/protocol/coreproto.pyx":504 + * + * else: + * if self.state == PROTOCOL_IDLE: # <<<<<<<<<<<<<< + * self.state = new_state + * + */ + __pyx_t_1 = ((__pyx_v_self->state == __pyx_e_7asyncpg_8protocol_8protocol_PROTOCOL_IDLE) != 0); + if (__pyx_t_1) { + + /* "asyncpg/protocol/coreproto.pyx":505 + * else: + * if self.state == PROTOCOL_IDLE: + * self.state = new_state # <<<<<<<<<<<<<< + * + * elif self.state == PROTOCOL_FAILED: + */ + __pyx_v_self->state = __pyx_v_new_state; + + /* "asyncpg/protocol/coreproto.pyx":504 + * + * else: + * if self.state == PROTOCOL_IDLE: # <<<<<<<<<<<<<< + * self.state = new_state + * + */ + goto __pyx_L4; + } + + /* "asyncpg/protocol/coreproto.pyx":507 + * self.state = new_state + * + * elif self.state == PROTOCOL_FAILED: # <<<<<<<<<<<<<< + * raise RuntimeError( + * 'cannot switch to state {}; ' + */ + __pyx_t_1 = ((__pyx_v_self->state == __pyx_e_7asyncpg_8protocol_8protocol_PROTOCOL_FAILED) != 0); + if (__pyx_t_1) { + + /* "asyncpg/protocol/coreproto.pyx":510 + * raise RuntimeError( + * 'cannot switch to state {}; ' + * 'protocol is in the "failed" state'.format(new_state)) # <<<<<<<<<<<<<< + * else: + * raise RuntimeError( + */ + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_kp_u_cannot_switch_to_state_protocol, __pyx_n_s_format); if (unlikely(!__pyx_t_3)) __PYX_ERR(4, 510, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = __Pyx_PyInt_From_enum____pyx_t_7asyncpg_8protocol_8protocol_ProtocolState(__pyx_v_new_state); if (unlikely(!__pyx_t_4)) __PYX_ERR(4, 510, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_5 = NULL; + if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_3))) { + __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_3); + if (likely(__pyx_t_5)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); + __Pyx_INCREF(__pyx_t_5); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_3, function); + } + } + if (!__pyx_t_5) { + __pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_4); if (unlikely(!__pyx_t_2)) __PYX_ERR(4, 510, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_GOTREF(__pyx_t_2); + } else { + #if CYTHON_FAST_PYCALL + if (PyFunction_Check(__pyx_t_3)) { + PyObject *__pyx_temp[2] = {__pyx_t_5, __pyx_t_4}; + __pyx_t_2 = __Pyx_PyFunction_FastCall(__pyx_t_3, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_2)) __PYX_ERR(4, 510, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + } else + #endif + #if CYTHON_FAST_PYCCALL + if (__Pyx_PyFastCFunction_Check(__pyx_t_3)) { + PyObject *__pyx_temp[2] = {__pyx_t_5, __pyx_t_4}; + __pyx_t_2 = __Pyx_PyCFunction_FastCall(__pyx_t_3, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_2)) __PYX_ERR(4, 510, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + } else + #endif + { + __pyx_t_6 = PyTuple_New(1+1); if (unlikely(!__pyx_t_6)) __PYX_ERR(4, 510, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_GIVEREF(__pyx_t_5); PyTuple_SET_ITEM(__pyx_t_6, 0, __pyx_t_5); __pyx_t_5 = NULL; + __Pyx_GIVEREF(__pyx_t_4); + PyTuple_SET_ITEM(__pyx_t_6, 0+1, __pyx_t_4); + __pyx_t_4 = 0; + __pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_t_6, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(4, 510, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + } + } + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + + /* "asyncpg/protocol/coreproto.pyx":508 + * + * elif self.state == PROTOCOL_FAILED: + * raise RuntimeError( # <<<<<<<<<<<<<< + * 'cannot switch to state {}; ' + * 'protocol is in the "failed" state'.format(new_state)) + */ + __pyx_t_3 = PyTuple_New(1); if (unlikely(!__pyx_t_3)) __PYX_ERR(4, 508, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_GIVEREF(__pyx_t_2); + PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_t_2); + __pyx_t_2 = 0; + __pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_RuntimeError, __pyx_t_3, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(4, 508, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_Raise(__pyx_t_2, 0, 0, 0); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __PYX_ERR(4, 508, __pyx_L1_error) + + /* "asyncpg/protocol/coreproto.pyx":507 + * self.state = new_state + * + * elif self.state == PROTOCOL_FAILED: # <<<<<<<<<<<<<< + * raise RuntimeError( + * 'cannot switch to state {}; ' + */ + } + + /* "asyncpg/protocol/coreproto.pyx":512 + * 'protocol is in the "failed" state'.format(new_state)) + * else: + * raise RuntimeError( # <<<<<<<<<<<<<< + * 'cannot switch to state {}; ' + * 'another operation ({}) is in progress'.format( + */ + /*else*/ { + + /* "asyncpg/protocol/coreproto.pyx":514 + * raise RuntimeError( + * 'cannot switch to state {}; ' + * 'another operation ({}) is in progress'.format( # <<<<<<<<<<<<<< + * new_state, self.state)) + * + */ + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_kp_u_cannot_switch_to_state_another_o, __pyx_n_s_format); if (unlikely(!__pyx_t_3)) __PYX_ERR(4, 514, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + + /* "asyncpg/protocol/coreproto.pyx":515 + * 'cannot switch to state {}; ' + * 'another operation ({}) is in progress'.format( + * new_state, self.state)) # <<<<<<<<<<<<<< + * + * cdef _ensure_connected(self): + */ + __pyx_t_6 = __Pyx_PyInt_From_enum____pyx_t_7asyncpg_8protocol_8protocol_ProtocolState(__pyx_v_new_state); if (unlikely(!__pyx_t_6)) __PYX_ERR(4, 515, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_4 = __Pyx_PyInt_From_enum____pyx_t_7asyncpg_8protocol_8protocol_ProtocolState(__pyx_v_self->state); if (unlikely(!__pyx_t_4)) __PYX_ERR(4, 515, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_5 = NULL; + __pyx_t_7 = 0; + if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_3))) { + __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_3); + if (likely(__pyx_t_5)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); + __Pyx_INCREF(__pyx_t_5); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_3, function); + __pyx_t_7 = 1; + } + } + #if CYTHON_FAST_PYCALL + if (PyFunction_Check(__pyx_t_3)) { + PyObject *__pyx_temp[3] = {__pyx_t_5, __pyx_t_6, __pyx_t_4}; + __pyx_t_2 = __Pyx_PyFunction_FastCall(__pyx_t_3, __pyx_temp+1-__pyx_t_7, 2+__pyx_t_7); if (unlikely(!__pyx_t_2)) __PYX_ERR(4, 514, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + } else + #endif + #if CYTHON_FAST_PYCCALL + if (__Pyx_PyFastCFunction_Check(__pyx_t_3)) { + PyObject *__pyx_temp[3] = {__pyx_t_5, __pyx_t_6, __pyx_t_4}; + __pyx_t_2 = __Pyx_PyCFunction_FastCall(__pyx_t_3, __pyx_temp+1-__pyx_t_7, 2+__pyx_t_7); if (unlikely(!__pyx_t_2)) __PYX_ERR(4, 514, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + } else + #endif + { + __pyx_t_8 = PyTuple_New(2+__pyx_t_7); if (unlikely(!__pyx_t_8)) __PYX_ERR(4, 514, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + if (__pyx_t_5) { + __Pyx_GIVEREF(__pyx_t_5); PyTuple_SET_ITEM(__pyx_t_8, 0, __pyx_t_5); __pyx_t_5 = NULL; + } + __Pyx_GIVEREF(__pyx_t_6); + PyTuple_SET_ITEM(__pyx_t_8, 0+__pyx_t_7, __pyx_t_6); + __Pyx_GIVEREF(__pyx_t_4); + PyTuple_SET_ITEM(__pyx_t_8, 1+__pyx_t_7, __pyx_t_4); + __pyx_t_6 = 0; + __pyx_t_4 = 0; + __pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_t_8, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(4, 514, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + } + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + + /* "asyncpg/protocol/coreproto.pyx":512 + * 'protocol is in the "failed" state'.format(new_state)) + * else: + * raise RuntimeError( # <<<<<<<<<<<<<< + * 'cannot switch to state {}; ' + * 'another operation ({}) is in progress'.format( + */ + __pyx_t_3 = PyTuple_New(1); if (unlikely(!__pyx_t_3)) __PYX_ERR(4, 512, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_GIVEREF(__pyx_t_2); + PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_t_2); + __pyx_t_2 = 0; + __pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_RuntimeError, __pyx_t_3, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(4, 512, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_Raise(__pyx_t_2, 0, 0, 0); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __PYX_ERR(4, 512, __pyx_L1_error) + } + __pyx_L4:; + break; + } + + /* "asyncpg/protocol/coreproto.pyx":488 + * self._discard_data = False + * + * cdef _set_state(self, ProtocolState new_state): # <<<<<<<<<<<<<< + * if new_state == PROTOCOL_IDLE: + * if self.state == PROTOCOL_FAILED: + */ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_XDECREF(__pyx_t_6); + __Pyx_XDECREF(__pyx_t_8); + __Pyx_AddTraceback("asyncpg.protocol.protocol.CoreProtocol._set_state", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "asyncpg/protocol/coreproto.pyx":517 + * new_state, self.state)) + * + * cdef _ensure_connected(self): # <<<<<<<<<<<<<< + * if self.con_status != CONNECTION_OK: + * raise RuntimeError('not connected') + */ + +static PyObject *__pyx_f_7asyncpg_8protocol_8protocol_12CoreProtocol__ensure_connected(struct __pyx_obj_7asyncpg_8protocol_8protocol_CoreProtocol *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + PyObject *__pyx_t_2 = NULL; + __Pyx_RefNannySetupContext("_ensure_connected", 0); + + /* "asyncpg/protocol/coreproto.pyx":518 + * + * cdef _ensure_connected(self): + * if self.con_status != CONNECTION_OK: # <<<<<<<<<<<<<< + * raise RuntimeError('not connected') + * + */ + __pyx_t_1 = ((__pyx_v_self->con_status != __pyx_e_7asyncpg_8protocol_8protocol_CONNECTION_OK) != 0); + if (__pyx_t_1) { + + /* "asyncpg/protocol/coreproto.pyx":519 + * cdef _ensure_connected(self): + * if self.con_status != CONNECTION_OK: + * raise RuntimeError('not connected') # <<<<<<<<<<<<<< + * + * cdef WriteBuffer _build_bind_message(self, str portal_name, + */ + __pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_RuntimeError, __pyx_tuple__64, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(4, 519, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_Raise(__pyx_t_2, 0, 0, 0); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __PYX_ERR(4, 519, __pyx_L1_error) + + /* "asyncpg/protocol/coreproto.pyx":518 + * + * cdef _ensure_connected(self): + * if self.con_status != CONNECTION_OK: # <<<<<<<<<<<<<< + * raise RuntimeError('not connected') + * + */ + } + + /* "asyncpg/protocol/coreproto.pyx":517 + * new_state, self.state)) + * + * cdef _ensure_connected(self): # <<<<<<<<<<<<<< + * if self.con_status != CONNECTION_OK: + * raise RuntimeError('not connected') + */ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_2); + __Pyx_AddTraceback("asyncpg.protocol.protocol.CoreProtocol._ensure_connected", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "asyncpg/protocol/coreproto.pyx":521 + * raise RuntimeError('not connected') + * + * cdef WriteBuffer _build_bind_message(self, str portal_name, # <<<<<<<<<<<<<< + * str stmt_name, + * WriteBuffer bind_data): + */ + +static struct __pyx_obj_7asyncpg_8protocol_8protocol_WriteBuffer *__pyx_f_7asyncpg_8protocol_8protocol_12CoreProtocol__build_bind_message(struct __pyx_obj_7asyncpg_8protocol_8protocol_CoreProtocol *__pyx_v_self, PyObject *__pyx_v_portal_name, PyObject *__pyx_v_stmt_name, struct __pyx_obj_7asyncpg_8protocol_8protocol_WriteBuffer *__pyx_v_bind_data) { + struct __pyx_obj_7asyncpg_8protocol_8protocol_WriteBuffer *__pyx_v_buf = 0; + struct __pyx_obj_7asyncpg_8protocol_8protocol_WriteBuffer *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + __Pyx_RefNannySetupContext("_build_bind_message", 0); + + /* "asyncpg/protocol/coreproto.pyx":526 + * cdef WriteBuffer buf + * + * buf = WriteBuffer.new_message(b'B') # <<<<<<<<<<<<<< + * buf.write_str(portal_name, self.encoding) + * buf.write_str(stmt_name, self.encoding) + */ + __pyx_t_1 = ((PyObject *)__pyx_f_7asyncpg_8protocol_8protocol_11WriteBuffer_new_message('B')); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 526, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_v_buf = ((struct __pyx_obj_7asyncpg_8protocol_8protocol_WriteBuffer *)__pyx_t_1); + __pyx_t_1 = 0; + + /* "asyncpg/protocol/coreproto.pyx":527 + * + * buf = WriteBuffer.new_message(b'B') + * buf.write_str(portal_name, self.encoding) # <<<<<<<<<<<<<< + * buf.write_str(stmt_name, self.encoding) + * + */ + __pyx_t_1 = __pyx_v_self->encoding; + __Pyx_INCREF(__pyx_t_1); + __pyx_t_2 = __pyx_f_7asyncpg_8protocol_8protocol_11WriteBuffer_write_str(__pyx_v_buf, __pyx_v_portal_name, ((PyObject*)__pyx_t_1)); if (unlikely(!__pyx_t_2)) __PYX_ERR(4, 527, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "asyncpg/protocol/coreproto.pyx":528 + * buf = WriteBuffer.new_message(b'B') + * buf.write_str(portal_name, self.encoding) + * buf.write_str(stmt_name, self.encoding) # <<<<<<<<<<<<<< + * + * # Arguments + */ + __pyx_t_2 = __pyx_v_self->encoding; + __Pyx_INCREF(__pyx_t_2); + __pyx_t_1 = __pyx_f_7asyncpg_8protocol_8protocol_11WriteBuffer_write_str(__pyx_v_buf, __pyx_v_stmt_name, ((PyObject*)__pyx_t_2)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 528, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "asyncpg/protocol/coreproto.pyx":531 + * + * # Arguments + * buf.write_buffer(bind_data) # <<<<<<<<<<<<<< + * + * buf.end_message() + */ + __pyx_t_1 = __pyx_f_7asyncpg_8protocol_8protocol_11WriteBuffer_write_buffer(__pyx_v_buf, __pyx_v_bind_data); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 531, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "asyncpg/protocol/coreproto.pyx":533 + * buf.write_buffer(bind_data) + * + * buf.end_message() # <<<<<<<<<<<<<< + * return buf + * + */ + __pyx_t_1 = __pyx_f_7asyncpg_8protocol_8protocol_11WriteBuffer_end_message(__pyx_v_buf); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 533, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "asyncpg/protocol/coreproto.pyx":534 + * + * buf.end_message() + * return buf # <<<<<<<<<<<<<< + * + * # API for subclasses + */ + __Pyx_XDECREF(((PyObject *)__pyx_r)); + __Pyx_INCREF(((PyObject *)__pyx_v_buf)); + __pyx_r = __pyx_v_buf; + goto __pyx_L0; + + /* "asyncpg/protocol/coreproto.pyx":521 + * raise RuntimeError('not connected') + * + * cdef WriteBuffer _build_bind_message(self, str portal_name, # <<<<<<<<<<<<<< + * str stmt_name, + * WriteBuffer bind_data): + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_AddTraceback("asyncpg.protocol.protocol.CoreProtocol._build_bind_message", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XDECREF((PyObject *)__pyx_v_buf); + __Pyx_XGIVEREF((PyObject *)__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "asyncpg/protocol/coreproto.pyx":538 + * # API for subclasses + * + * cdef _connect(self): # <<<<<<<<<<<<<< + * cdef: + * WriteBuffer buf + */ + +static PyObject *__pyx_f_7asyncpg_8protocol_8protocol_12CoreProtocol__connect(struct __pyx_obj_7asyncpg_8protocol_8protocol_CoreProtocol *__pyx_v_self) { + struct __pyx_obj_7asyncpg_8protocol_8protocol_WriteBuffer *__pyx_v_buf = 0; + struct __pyx_obj_7asyncpg_8protocol_8protocol_WriteBuffer *__pyx_v_outbuf = 0; + PyObject *__pyx_v_param = NULL; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + PyObject *__pyx_t_5 = NULL; + Py_ssize_t __pyx_t_6; + Py_ssize_t __pyx_t_7; + int __pyx_t_8; + int __pyx_t_9; + int32_t __pyx_t_10; + __Pyx_RefNannySetupContext("_connect", 0); + + /* "asyncpg/protocol/coreproto.pyx":543 + * WriteBuffer outbuf + * + * if self.con_status != CONNECTION_BAD: # <<<<<<<<<<<<<< + * raise RuntimeError('already connected') + * + */ + __pyx_t_1 = ((__pyx_v_self->con_status != __pyx_e_7asyncpg_8protocol_8protocol_CONNECTION_BAD) != 0); + if (__pyx_t_1) { + + /* "asyncpg/protocol/coreproto.pyx":544 + * + * if self.con_status != CONNECTION_BAD: + * raise RuntimeError('already connected') # <<<<<<<<<<<<<< + * + * self._set_state(PROTOCOL_AUTH) + */ + __pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_RuntimeError, __pyx_tuple__65, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(4, 544, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_Raise(__pyx_t_2, 0, 0, 0); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __PYX_ERR(4, 544, __pyx_L1_error) + + /* "asyncpg/protocol/coreproto.pyx":543 + * WriteBuffer outbuf + * + * if self.con_status != CONNECTION_BAD: # <<<<<<<<<<<<<< + * raise RuntimeError('already connected') + * + */ + } + + /* "asyncpg/protocol/coreproto.pyx":546 + * raise RuntimeError('already connected') + * + * self._set_state(PROTOCOL_AUTH) # <<<<<<<<<<<<<< + * self.con_status = CONNECTION_STARTED + * + */ + __pyx_t_2 = ((struct __pyx_vtabstruct_7asyncpg_8protocol_8protocol_CoreProtocol *)__pyx_v_self->__pyx_vtab)->_set_state(__pyx_v_self, __pyx_e_7asyncpg_8protocol_8protocol_PROTOCOL_AUTH); if (unlikely(!__pyx_t_2)) __PYX_ERR(4, 546, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "asyncpg/protocol/coreproto.pyx":547 + * + * self._set_state(PROTOCOL_AUTH) + * self.con_status = CONNECTION_STARTED # <<<<<<<<<<<<<< + * + * # Assemble a startup message + */ + __pyx_v_self->con_status = __pyx_e_7asyncpg_8protocol_8protocol_CONNECTION_STARTED; + + /* "asyncpg/protocol/coreproto.pyx":550 + * + * # Assemble a startup message + * buf = WriteBuffer() # <<<<<<<<<<<<<< + * + * # protocol version + */ + __pyx_t_2 = __Pyx_PyObject_Call(((PyObject *)__pyx_ptype_7asyncpg_8protocol_8protocol_WriteBuffer), __pyx_empty_tuple, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(4, 550, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_v_buf = ((struct __pyx_obj_7asyncpg_8protocol_8protocol_WriteBuffer *)__pyx_t_2); + __pyx_t_2 = 0; + + /* "asyncpg/protocol/coreproto.pyx":553 + * + * # protocol version + * buf.write_int16(3) # <<<<<<<<<<<<<< + * buf.write_int16(0) + * + */ + __pyx_t_2 = __pyx_f_7asyncpg_8protocol_8protocol_11WriteBuffer_write_int16(__pyx_v_buf, 3); if (unlikely(!__pyx_t_2)) __PYX_ERR(4, 553, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "asyncpg/protocol/coreproto.pyx":554 + * # protocol version + * buf.write_int16(3) + * buf.write_int16(0) # <<<<<<<<<<<<<< + * + * buf.write_bytestring(b'client_encoding') + */ + __pyx_t_2 = __pyx_f_7asyncpg_8protocol_8protocol_11WriteBuffer_write_int16(__pyx_v_buf, 0); if (unlikely(!__pyx_t_2)) __PYX_ERR(4, 554, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "asyncpg/protocol/coreproto.pyx":556 + * buf.write_int16(0) + * + * buf.write_bytestring(b'client_encoding') # <<<<<<<<<<<<<< + * buf.write_bytestring("'{}'".format(self.encoding).encode('ascii')) + * + */ + __pyx_t_2 = __pyx_f_7asyncpg_8protocol_8protocol_11WriteBuffer_write_bytestring(__pyx_v_buf, __pyx_n_b_client_encoding); if (unlikely(!__pyx_t_2)) __PYX_ERR(4, 556, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "asyncpg/protocol/coreproto.pyx":557 + * + * buf.write_bytestring(b'client_encoding') + * buf.write_bytestring("'{}'".format(self.encoding).encode('ascii')) # <<<<<<<<<<<<<< + * + * for param in self.con_args: + */ + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_kp_u__66, __pyx_n_s_format); if (unlikely(!__pyx_t_3)) __PYX_ERR(4, 557, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = NULL; + if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_3))) { + __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_3); + if (likely(__pyx_t_4)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); + __Pyx_INCREF(__pyx_t_4); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_3, function); + } + } + if (!__pyx_t_4) { + __pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_v_self->encoding); if (unlikely(!__pyx_t_2)) __PYX_ERR(4, 557, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + } else { + #if CYTHON_FAST_PYCALL + if (PyFunction_Check(__pyx_t_3)) { + PyObject *__pyx_temp[2] = {__pyx_t_4, __pyx_v_self->encoding}; + __pyx_t_2 = __Pyx_PyFunction_FastCall(__pyx_t_3, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_2)) __PYX_ERR(4, 557, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_GOTREF(__pyx_t_2); + } else + #endif + #if CYTHON_FAST_PYCCALL + if (__Pyx_PyFastCFunction_Check(__pyx_t_3)) { + PyObject *__pyx_temp[2] = {__pyx_t_4, __pyx_v_self->encoding}; + __pyx_t_2 = __Pyx_PyCFunction_FastCall(__pyx_t_3, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_2)) __PYX_ERR(4, 557, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_GOTREF(__pyx_t_2); + } else + #endif + { + __pyx_t_5 = PyTuple_New(1+1); if (unlikely(!__pyx_t_5)) __PYX_ERR(4, 557, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_GIVEREF(__pyx_t_4); PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_t_4); __pyx_t_4 = NULL; + __Pyx_INCREF(__pyx_v_self->encoding); + __Pyx_GIVEREF(__pyx_v_self->encoding); + PyTuple_SET_ITEM(__pyx_t_5, 0+1, __pyx_v_self->encoding); + __pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_t_5, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(4, 557, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + } + } + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_encode); if (unlikely(!__pyx_t_3)) __PYX_ERR(4, 557, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_tuple__67, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(4, 557, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (!(likely(PyBytes_CheckExact(__pyx_t_2))||((__pyx_t_2) == Py_None)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "bytes", Py_TYPE(__pyx_t_2)->tp_name), 0))) __PYX_ERR(4, 557, __pyx_L1_error) + __pyx_t_3 = __pyx_f_7asyncpg_8protocol_8protocol_11WriteBuffer_write_bytestring(__pyx_v_buf, ((PyObject*)__pyx_t_2)); if (unlikely(!__pyx_t_3)) __PYX_ERR(4, 557, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + + /* "asyncpg/protocol/coreproto.pyx":559 + * buf.write_bytestring("'{}'".format(self.encoding).encode('ascii')) + * + * for param in self.con_args: # <<<<<<<<<<<<<< + * if param == 'password': + * continue + */ + __pyx_t_6 = 0; + if (unlikely(__pyx_v_self->con_args == Py_None)) { + PyErr_SetString(PyExc_TypeError, "'NoneType' object is not iterable"); + __PYX_ERR(4, 559, __pyx_L1_error) + } + __pyx_t_2 = __Pyx_dict_iterator(__pyx_v_self->con_args, 1, ((PyObject *)NULL), (&__pyx_t_7), (&__pyx_t_8)); if (unlikely(!__pyx_t_2)) __PYX_ERR(4, 559, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __pyx_t_3 = __pyx_t_2; + __pyx_t_2 = 0; + while (1) { + __pyx_t_9 = __Pyx_dict_iter_next(__pyx_t_3, __pyx_t_7, &__pyx_t_6, &__pyx_t_2, NULL, NULL, __pyx_t_8); + if (unlikely(__pyx_t_9 == 0)) break; + if (unlikely(__pyx_t_9 == -1)) __PYX_ERR(4, 559, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_XDECREF_SET(__pyx_v_param, __pyx_t_2); + __pyx_t_2 = 0; + + /* "asyncpg/protocol/coreproto.pyx":560 + * + * for param in self.con_args: + * if param == 'password': # <<<<<<<<<<<<<< + * continue + * buf.write_str(param, self.encoding) + */ + __pyx_t_1 = (__Pyx_PyUnicode_Equals(__pyx_v_param, __pyx_n_u_password, Py_EQ)); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(4, 560, __pyx_L1_error) + if (__pyx_t_1) { + + /* "asyncpg/protocol/coreproto.pyx":561 + * for param in self.con_args: + * if param == 'password': + * continue # <<<<<<<<<<<<<< + * buf.write_str(param, self.encoding) + * buf.write_str(self.con_args[param], self.encoding) + */ + goto __pyx_L4_continue; + + /* "asyncpg/protocol/coreproto.pyx":560 + * + * for param in self.con_args: + * if param == 'password': # <<<<<<<<<<<<<< + * continue + * buf.write_str(param, self.encoding) + */ + } + + /* "asyncpg/protocol/coreproto.pyx":562 + * if param == 'password': + * continue + * buf.write_str(param, self.encoding) # <<<<<<<<<<<<<< + * buf.write_str(self.con_args[param], self.encoding) + * + */ + if (!(likely(PyUnicode_CheckExact(__pyx_v_param))||((__pyx_v_param) == Py_None)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "unicode", Py_TYPE(__pyx_v_param)->tp_name), 0))) __PYX_ERR(4, 562, __pyx_L1_error) + __pyx_t_2 = __pyx_v_self->encoding; + __Pyx_INCREF(__pyx_t_2); + __pyx_t_5 = __pyx_f_7asyncpg_8protocol_8protocol_11WriteBuffer_write_str(__pyx_v_buf, ((PyObject*)__pyx_v_param), ((PyObject*)__pyx_t_2)); if (unlikely(!__pyx_t_5)) __PYX_ERR(4, 562, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + + /* "asyncpg/protocol/coreproto.pyx":563 + * continue + * buf.write_str(param, self.encoding) + * buf.write_str(self.con_args[param], self.encoding) # <<<<<<<<<<<<<< + * + * buf.write_bytestring(b'') + */ + if (unlikely(__pyx_v_self->con_args == Py_None)) { + PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable"); + __PYX_ERR(4, 563, __pyx_L1_error) + } + __pyx_t_5 = __Pyx_PyDict_GetItem(__pyx_v_self->con_args, __pyx_v_param); if (unlikely(!__pyx_t_5)) __PYX_ERR(4, 563, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + if (!(likely(PyUnicode_CheckExact(__pyx_t_5))||((__pyx_t_5) == Py_None)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "unicode", Py_TYPE(__pyx_t_5)->tp_name), 0))) __PYX_ERR(4, 563, __pyx_L1_error) + __pyx_t_2 = __pyx_v_self->encoding; + __Pyx_INCREF(__pyx_t_2); + __pyx_t_4 = __pyx_f_7asyncpg_8protocol_8protocol_11WriteBuffer_write_str(__pyx_v_buf, ((PyObject*)__pyx_t_5), ((PyObject*)__pyx_t_2)); if (unlikely(!__pyx_t_4)) __PYX_ERR(4, 563, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_L4_continue:; + } + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + + /* "asyncpg/protocol/coreproto.pyx":565 + * buf.write_str(self.con_args[param], self.encoding) + * + * buf.write_bytestring(b'') # <<<<<<<<<<<<<< + * + * # Send the buffer + */ + __pyx_t_3 = __pyx_f_7asyncpg_8protocol_8protocol_11WriteBuffer_write_bytestring(__pyx_v_buf, __pyx_kp_b__18); if (unlikely(!__pyx_t_3)) __PYX_ERR(4, 565, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + + /* "asyncpg/protocol/coreproto.pyx":568 + * + * # Send the buffer + * outbuf = WriteBuffer() # <<<<<<<<<<<<<< + * outbuf.write_int32(buf.len() + 4) + * outbuf.write_buffer(buf) + */ + __pyx_t_3 = __Pyx_PyObject_Call(((PyObject *)__pyx_ptype_7asyncpg_8protocol_8protocol_WriteBuffer), __pyx_empty_tuple, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(4, 568, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_v_outbuf = ((struct __pyx_obj_7asyncpg_8protocol_8protocol_WriteBuffer *)__pyx_t_3); + __pyx_t_3 = 0; + + /* "asyncpg/protocol/coreproto.pyx":569 + * # Send the buffer + * outbuf = WriteBuffer() + * outbuf.write_int32(buf.len() + 4) # <<<<<<<<<<<<<< + * outbuf.write_buffer(buf) + * self._write(outbuf) + */ + __pyx_t_3 = __pyx_f_7asyncpg_8protocol_8protocol_11WriteBuffer_len(__pyx_v_buf); if (unlikely(!__pyx_t_3)) __PYX_ERR(4, 569, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = __Pyx_PyInt_AddObjC(__pyx_t_3, __pyx_int_4, 4, 0); if (unlikely(!__pyx_t_4)) __PYX_ERR(4, 569, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_10 = __Pyx_PyInt_As_int32_t(__pyx_t_4); if (unlikely((__pyx_t_10 == ((int32_t)-1)) && PyErr_Occurred())) __PYX_ERR(4, 569, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_4 = __pyx_f_7asyncpg_8protocol_8protocol_11WriteBuffer_write_int32(__pyx_v_outbuf, __pyx_t_10); if (unlikely(!__pyx_t_4)) __PYX_ERR(4, 569, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + + /* "asyncpg/protocol/coreproto.pyx":570 + * outbuf = WriteBuffer() + * outbuf.write_int32(buf.len() + 4) + * outbuf.write_buffer(buf) # <<<<<<<<<<<<<< + * self._write(outbuf) + * + */ + __pyx_t_4 = __pyx_f_7asyncpg_8protocol_8protocol_11WriteBuffer_write_buffer(__pyx_v_outbuf, __pyx_v_buf); if (unlikely(!__pyx_t_4)) __PYX_ERR(4, 570, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + + /* "asyncpg/protocol/coreproto.pyx":571 + * outbuf.write_int32(buf.len() + 4) + * outbuf.write_buffer(buf) + * self._write(outbuf) # <<<<<<<<<<<<<< + * + * cdef _prepare(self, str stmt_name, str query): + */ + __pyx_t_4 = ((struct __pyx_vtabstruct_7asyncpg_8protocol_8protocol_CoreProtocol *)__pyx_v_self->__pyx_vtab)->_write(__pyx_v_self, ((PyObject *)__pyx_v_outbuf)); if (unlikely(!__pyx_t_4)) __PYX_ERR(4, 571, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + + /* "asyncpg/protocol/coreproto.pyx":538 + * # API for subclasses + * + * cdef _connect(self): # <<<<<<<<<<<<<< + * cdef: + * WriteBuffer buf + */ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_AddTraceback("asyncpg.protocol.protocol.CoreProtocol._connect", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XDECREF((PyObject *)__pyx_v_buf); + __Pyx_XDECREF((PyObject *)__pyx_v_outbuf); + __Pyx_XDECREF(__pyx_v_param); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "asyncpg/protocol/coreproto.pyx":573 + * self._write(outbuf) + * + * cdef _prepare(self, str stmt_name, str query): # <<<<<<<<<<<<<< + * cdef: + * WriteBuffer packet + */ + +static PyObject *__pyx_f_7asyncpg_8protocol_8protocol_12CoreProtocol__prepare(struct __pyx_obj_7asyncpg_8protocol_8protocol_CoreProtocol *__pyx_v_self, PyObject *__pyx_v_stmt_name, PyObject *__pyx_v_query) { + struct __pyx_obj_7asyncpg_8protocol_8protocol_WriteBuffer *__pyx_v_packet = 0; + struct __pyx_obj_7asyncpg_8protocol_8protocol_WriteBuffer *__pyx_v_buf = 0; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + PyObject *__pyx_t_5 = NULL; + __Pyx_RefNannySetupContext("_prepare", 0); + + /* "asyncpg/protocol/coreproto.pyx":578 + * WriteBuffer buf + * + * self._ensure_connected() # <<<<<<<<<<<<<< + * self._set_state(PROTOCOL_PREPARE) + * + */ + __pyx_t_1 = ((struct __pyx_vtabstruct_7asyncpg_8protocol_8protocol_CoreProtocol *)__pyx_v_self->__pyx_vtab)->_ensure_connected(__pyx_v_self); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 578, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "asyncpg/protocol/coreproto.pyx":579 + * + * self._ensure_connected() + * self._set_state(PROTOCOL_PREPARE) # <<<<<<<<<<<<<< + * + * packet = WriteBuffer.new() + */ + __pyx_t_1 = ((struct __pyx_vtabstruct_7asyncpg_8protocol_8protocol_CoreProtocol *)__pyx_v_self->__pyx_vtab)->_set_state(__pyx_v_self, __pyx_e_7asyncpg_8protocol_8protocol_PROTOCOL_PREPARE); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 579, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "asyncpg/protocol/coreproto.pyx":581 + * self._set_state(PROTOCOL_PREPARE) + * + * packet = WriteBuffer.new() # <<<<<<<<<<<<<< + * + * buf = WriteBuffer.new_message(b'P') + */ + __pyx_t_1 = ((PyObject *)__pyx_f_7asyncpg_8protocol_8protocol_11WriteBuffer_new()); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 581, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_v_packet = ((struct __pyx_obj_7asyncpg_8protocol_8protocol_WriteBuffer *)__pyx_t_1); + __pyx_t_1 = 0; + + /* "asyncpg/protocol/coreproto.pyx":583 + * packet = WriteBuffer.new() + * + * buf = WriteBuffer.new_message(b'P') # <<<<<<<<<<<<<< + * buf.write_str(stmt_name, self.encoding) + * buf.write_str(query, self.encoding) + */ + __pyx_t_1 = ((PyObject *)__pyx_f_7asyncpg_8protocol_8protocol_11WriteBuffer_new_message('P')); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 583, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_v_buf = ((struct __pyx_obj_7asyncpg_8protocol_8protocol_WriteBuffer *)__pyx_t_1); + __pyx_t_1 = 0; + + /* "asyncpg/protocol/coreproto.pyx":584 + * + * buf = WriteBuffer.new_message(b'P') + * buf.write_str(stmt_name, self.encoding) # <<<<<<<<<<<<<< + * buf.write_str(query, self.encoding) + * buf.write_int16(0) + */ + __pyx_t_1 = __pyx_v_self->encoding; + __Pyx_INCREF(__pyx_t_1); + __pyx_t_2 = __pyx_f_7asyncpg_8protocol_8protocol_11WriteBuffer_write_str(__pyx_v_buf, __pyx_v_stmt_name, ((PyObject*)__pyx_t_1)); if (unlikely(!__pyx_t_2)) __PYX_ERR(4, 584, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "asyncpg/protocol/coreproto.pyx":585 + * buf = WriteBuffer.new_message(b'P') + * buf.write_str(stmt_name, self.encoding) + * buf.write_str(query, self.encoding) # <<<<<<<<<<<<<< + * buf.write_int16(0) + * buf.end_message() + */ + __pyx_t_2 = __pyx_v_self->encoding; + __Pyx_INCREF(__pyx_t_2); + __pyx_t_1 = __pyx_f_7asyncpg_8protocol_8protocol_11WriteBuffer_write_str(__pyx_v_buf, __pyx_v_query, ((PyObject*)__pyx_t_2)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 585, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "asyncpg/protocol/coreproto.pyx":586 + * buf.write_str(stmt_name, self.encoding) + * buf.write_str(query, self.encoding) + * buf.write_int16(0) # <<<<<<<<<<<<<< + * buf.end_message() + * packet.write_buffer(buf) + */ + __pyx_t_1 = __pyx_f_7asyncpg_8protocol_8protocol_11WriteBuffer_write_int16(__pyx_v_buf, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 586, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "asyncpg/protocol/coreproto.pyx":587 + * buf.write_str(query, self.encoding) + * buf.write_int16(0) + * buf.end_message() # <<<<<<<<<<<<<< + * packet.write_buffer(buf) + * + */ + __pyx_t_1 = __pyx_f_7asyncpg_8protocol_8protocol_11WriteBuffer_end_message(__pyx_v_buf); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 587, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "asyncpg/protocol/coreproto.pyx":588 + * buf.write_int16(0) + * buf.end_message() + * packet.write_buffer(buf) # <<<<<<<<<<<<<< + * + * buf = WriteBuffer.new_message(b'D') + */ + __pyx_t_1 = __pyx_f_7asyncpg_8protocol_8protocol_11WriteBuffer_write_buffer(__pyx_v_packet, __pyx_v_buf); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 588, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "asyncpg/protocol/coreproto.pyx":590 + * packet.write_buffer(buf) + * + * buf = WriteBuffer.new_message(b'D') # <<<<<<<<<<<<<< + * buf.write_byte(b'S') + * buf.write_str(stmt_name, self.encoding) + */ + __pyx_t_1 = ((PyObject *)__pyx_f_7asyncpg_8protocol_8protocol_11WriteBuffer_new_message('D')); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 590, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF_SET(__pyx_v_buf, ((struct __pyx_obj_7asyncpg_8protocol_8protocol_WriteBuffer *)__pyx_t_1)); + __pyx_t_1 = 0; + + /* "asyncpg/protocol/coreproto.pyx":591 + * + * buf = WriteBuffer.new_message(b'D') + * buf.write_byte(b'S') # <<<<<<<<<<<<<< + * buf.write_str(stmt_name, self.encoding) + * buf.end_message() + */ + __pyx_t_1 = __pyx_f_7asyncpg_8protocol_8protocol_11WriteBuffer_write_byte(__pyx_v_buf, 'S'); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 591, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "asyncpg/protocol/coreproto.pyx":592 + * buf = WriteBuffer.new_message(b'D') + * buf.write_byte(b'S') + * buf.write_str(stmt_name, self.encoding) # <<<<<<<<<<<<<< + * buf.end_message() + * packet.write_buffer(buf) + */ + __pyx_t_1 = __pyx_v_self->encoding; + __Pyx_INCREF(__pyx_t_1); + __pyx_t_2 = __pyx_f_7asyncpg_8protocol_8protocol_11WriteBuffer_write_str(__pyx_v_buf, __pyx_v_stmt_name, ((PyObject*)__pyx_t_1)); if (unlikely(!__pyx_t_2)) __PYX_ERR(4, 592, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "asyncpg/protocol/coreproto.pyx":593 + * buf.write_byte(b'S') + * buf.write_str(stmt_name, self.encoding) + * buf.end_message() # <<<<<<<<<<<<<< + * packet.write_buffer(buf) + * + */ + __pyx_t_2 = __pyx_f_7asyncpg_8protocol_8protocol_11WriteBuffer_end_message(__pyx_v_buf); if (unlikely(!__pyx_t_2)) __PYX_ERR(4, 593, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "asyncpg/protocol/coreproto.pyx":594 + * buf.write_str(stmt_name, self.encoding) + * buf.end_message() + * packet.write_buffer(buf) # <<<<<<<<<<<<<< + * + * packet.write_bytes(SYNC_MESSAGE) + */ + __pyx_t_2 = __pyx_f_7asyncpg_8protocol_8protocol_11WriteBuffer_write_buffer(__pyx_v_packet, __pyx_v_buf); if (unlikely(!__pyx_t_2)) __PYX_ERR(4, 594, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "asyncpg/protocol/coreproto.pyx":596 + * packet.write_buffer(buf) + * + * packet.write_bytes(SYNC_MESSAGE) # <<<<<<<<<<<<<< + * + * self.transport.write(memoryview(packet)) + */ + __pyx_t_2 = __pyx_v_7asyncpg_8protocol_8protocol_SYNC_MESSAGE; + __Pyx_INCREF(__pyx_t_2); + __pyx_t_1 = __pyx_f_7asyncpg_8protocol_8protocol_11WriteBuffer_write_bytes(__pyx_v_packet, ((PyObject*)__pyx_t_2)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 596, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "asyncpg/protocol/coreproto.pyx":598 + * packet.write_bytes(SYNC_MESSAGE) + * + * self.transport.write(memoryview(packet)) # <<<<<<<<<<<<<< + * + * cdef _send_bind_message(self, str portal_name, str stmt_name, + */ + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_self->transport, __pyx_n_s_write); if (unlikely(!__pyx_t_2)) __PYX_ERR(4, 598, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = PyTuple_New(1); if (unlikely(!__pyx_t_3)) __PYX_ERR(4, 598, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_INCREF(((PyObject *)__pyx_v_packet)); + __Pyx_GIVEREF(((PyObject *)__pyx_v_packet)); + PyTuple_SET_ITEM(__pyx_t_3, 0, ((PyObject *)__pyx_v_packet)); + __pyx_t_4 = __Pyx_PyObject_Call(__pyx_builtin_memoryview, __pyx_t_3, NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(4, 598, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_3 = NULL; + if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_3)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_3); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + } + } + if (!__pyx_t_3) { + __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_4); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 598, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_GOTREF(__pyx_t_1); + } else { + #if CYTHON_FAST_PYCALL + if (PyFunction_Check(__pyx_t_2)) { + PyObject *__pyx_temp[2] = {__pyx_t_3, __pyx_t_4}; + __pyx_t_1 = __Pyx_PyFunction_FastCall(__pyx_t_2, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 598, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + } else + #endif + #if CYTHON_FAST_PYCCALL + if (__Pyx_PyFastCFunction_Check(__pyx_t_2)) { + PyObject *__pyx_temp[2] = {__pyx_t_3, __pyx_t_4}; + __pyx_t_1 = __Pyx_PyCFunction_FastCall(__pyx_t_2, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 598, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + } else + #endif + { + __pyx_t_5 = PyTuple_New(1+1); if (unlikely(!__pyx_t_5)) __PYX_ERR(4, 598, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_GIVEREF(__pyx_t_3); PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_t_3); __pyx_t_3 = NULL; + __Pyx_GIVEREF(__pyx_t_4); + PyTuple_SET_ITEM(__pyx_t_5, 0+1, __pyx_t_4); + __pyx_t_4 = 0; + __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_t_5, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 598, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + } + } + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "asyncpg/protocol/coreproto.pyx":573 + * self._write(outbuf) + * + * cdef _prepare(self, str stmt_name, str query): # <<<<<<<<<<<<<< + * cdef: + * WriteBuffer packet + */ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_AddTraceback("asyncpg.protocol.protocol.CoreProtocol._prepare", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XDECREF((PyObject *)__pyx_v_packet); + __Pyx_XDECREF((PyObject *)__pyx_v_buf); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "asyncpg/protocol/coreproto.pyx":600 + * self.transport.write(memoryview(packet)) + * + * cdef _send_bind_message(self, str portal_name, str stmt_name, # <<<<<<<<<<<<<< + * WriteBuffer bind_data, int32_t limit): + * + */ + +static PyObject *__pyx_f_7asyncpg_8protocol_8protocol_12CoreProtocol__send_bind_message(struct __pyx_obj_7asyncpg_8protocol_8protocol_CoreProtocol *__pyx_v_self, PyObject *__pyx_v_portal_name, PyObject *__pyx_v_stmt_name, struct __pyx_obj_7asyncpg_8protocol_8protocol_WriteBuffer *__pyx_v_bind_data, int32_t __pyx_v_limit) { + struct __pyx_obj_7asyncpg_8protocol_8protocol_WriteBuffer *__pyx_v_buf = 0; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + __Pyx_RefNannySetupContext("_send_bind_message", 0); + + /* "asyncpg/protocol/coreproto.pyx":605 + * cdef WriteBuffer buf + * + * buf = self._build_bind_message(portal_name, stmt_name, bind_data) # <<<<<<<<<<<<<< + * self._write(buf) + * + */ + __pyx_t_1 = ((PyObject *)((struct __pyx_vtabstruct_7asyncpg_8protocol_8protocol_CoreProtocol *)__pyx_v_self->__pyx_vtab)->_build_bind_message(__pyx_v_self, __pyx_v_portal_name, __pyx_v_stmt_name, __pyx_v_bind_data)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 605, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_v_buf = ((struct __pyx_obj_7asyncpg_8protocol_8protocol_WriteBuffer *)__pyx_t_1); + __pyx_t_1 = 0; + + /* "asyncpg/protocol/coreproto.pyx":606 + * + * buf = self._build_bind_message(portal_name, stmt_name, bind_data) + * self._write(buf) # <<<<<<<<<<<<<< + * + * buf = WriteBuffer.new_message(b'E') + */ + __pyx_t_1 = ((struct __pyx_vtabstruct_7asyncpg_8protocol_8protocol_CoreProtocol *)__pyx_v_self->__pyx_vtab)->_write(__pyx_v_self, ((PyObject *)__pyx_v_buf)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 606, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "asyncpg/protocol/coreproto.pyx":608 + * self._write(buf) + * + * buf = WriteBuffer.new_message(b'E') # <<<<<<<<<<<<<< + * buf.write_str(portal_name, self.encoding) # name of the portal + * buf.write_int32(limit) # number of rows to return; 0 - all + */ + __pyx_t_1 = ((PyObject *)__pyx_f_7asyncpg_8protocol_8protocol_11WriteBuffer_new_message('E')); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 608, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF_SET(__pyx_v_buf, ((struct __pyx_obj_7asyncpg_8protocol_8protocol_WriteBuffer *)__pyx_t_1)); + __pyx_t_1 = 0; + + /* "asyncpg/protocol/coreproto.pyx":609 + * + * buf = WriteBuffer.new_message(b'E') + * buf.write_str(portal_name, self.encoding) # name of the portal # <<<<<<<<<<<<<< + * buf.write_int32(limit) # number of rows to return; 0 - all + * buf.end_message() + */ + __pyx_t_1 = __pyx_v_self->encoding; + __Pyx_INCREF(__pyx_t_1); + __pyx_t_2 = __pyx_f_7asyncpg_8protocol_8protocol_11WriteBuffer_write_str(__pyx_v_buf, __pyx_v_portal_name, ((PyObject*)__pyx_t_1)); if (unlikely(!__pyx_t_2)) __PYX_ERR(4, 609, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "asyncpg/protocol/coreproto.pyx":610 + * buf = WriteBuffer.new_message(b'E') + * buf.write_str(portal_name, self.encoding) # name of the portal + * buf.write_int32(limit) # number of rows to return; 0 - all # <<<<<<<<<<<<<< + * buf.end_message() + * self._write(buf) + */ + __pyx_t_2 = __pyx_f_7asyncpg_8protocol_8protocol_11WriteBuffer_write_int32(__pyx_v_buf, __pyx_v_limit); if (unlikely(!__pyx_t_2)) __PYX_ERR(4, 610, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "asyncpg/protocol/coreproto.pyx":611 + * buf.write_str(portal_name, self.encoding) # name of the portal + * buf.write_int32(limit) # number of rows to return; 0 - all + * buf.end_message() # <<<<<<<<<<<<<< + * self._write(buf) + * + */ + __pyx_t_2 = __pyx_f_7asyncpg_8protocol_8protocol_11WriteBuffer_end_message(__pyx_v_buf); if (unlikely(!__pyx_t_2)) __PYX_ERR(4, 611, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "asyncpg/protocol/coreproto.pyx":612 + * buf.write_int32(limit) # number of rows to return; 0 - all + * buf.end_message() + * self._write(buf) # <<<<<<<<<<<<<< + * + * self._write_sync_message() + */ + __pyx_t_2 = ((struct __pyx_vtabstruct_7asyncpg_8protocol_8protocol_CoreProtocol *)__pyx_v_self->__pyx_vtab)->_write(__pyx_v_self, ((PyObject *)__pyx_v_buf)); if (unlikely(!__pyx_t_2)) __PYX_ERR(4, 612, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "asyncpg/protocol/coreproto.pyx":614 + * self._write(buf) + * + * self._write_sync_message() # <<<<<<<<<<<<<< + * + * cdef _bind_execute(self, str portal_name, str stmt_name, + */ + __pyx_t_2 = __pyx_f_7asyncpg_8protocol_8protocol_12CoreProtocol__write_sync_message(__pyx_v_self); if (unlikely(!__pyx_t_2)) __PYX_ERR(4, 614, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "asyncpg/protocol/coreproto.pyx":600 + * self.transport.write(memoryview(packet)) + * + * cdef _send_bind_message(self, str portal_name, str stmt_name, # <<<<<<<<<<<<<< + * WriteBuffer bind_data, int32_t limit): + * + */ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_AddTraceback("asyncpg.protocol.protocol.CoreProtocol._send_bind_message", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XDECREF((PyObject *)__pyx_v_buf); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "asyncpg/protocol/coreproto.pyx":616 + * self._write_sync_message() + * + * cdef _bind_execute(self, str portal_name, str stmt_name, # <<<<<<<<<<<<<< + * WriteBuffer bind_data, int32_t limit): + * + */ + +static PyObject *__pyx_f_7asyncpg_8protocol_8protocol_12CoreProtocol__bind_execute(struct __pyx_obj_7asyncpg_8protocol_8protocol_CoreProtocol *__pyx_v_self, PyObject *__pyx_v_portal_name, PyObject *__pyx_v_stmt_name, struct __pyx_obj_7asyncpg_8protocol_8protocol_WriteBuffer *__pyx_v_bind_data, int32_t __pyx_v_limit) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + __Pyx_RefNannySetupContext("_bind_execute", 0); + + /* "asyncpg/protocol/coreproto.pyx":621 + * cdef WriteBuffer buf + * + * self._ensure_connected() # <<<<<<<<<<<<<< + * self._set_state(PROTOCOL_BIND_EXECUTE) + * + */ + __pyx_t_1 = ((struct __pyx_vtabstruct_7asyncpg_8protocol_8protocol_CoreProtocol *)__pyx_v_self->__pyx_vtab)->_ensure_connected(__pyx_v_self); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 621, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "asyncpg/protocol/coreproto.pyx":622 + * + * self._ensure_connected() + * self._set_state(PROTOCOL_BIND_EXECUTE) # <<<<<<<<<<<<<< + * + * self.result = [] + */ + __pyx_t_1 = ((struct __pyx_vtabstruct_7asyncpg_8protocol_8protocol_CoreProtocol *)__pyx_v_self->__pyx_vtab)->_set_state(__pyx_v_self, __pyx_e_7asyncpg_8protocol_8protocol_PROTOCOL_BIND_EXECUTE); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 622, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "asyncpg/protocol/coreproto.pyx":624 + * self._set_state(PROTOCOL_BIND_EXECUTE) + * + * self.result = [] # <<<<<<<<<<<<<< + * + * self._send_bind_message(portal_name, stmt_name, bind_data, limit) + */ + __pyx_t_1 = PyList_New(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 624, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_GIVEREF(__pyx_t_1); + __Pyx_GOTREF(__pyx_v_self->result); + __Pyx_DECREF(__pyx_v_self->result); + __pyx_v_self->result = __pyx_t_1; + __pyx_t_1 = 0; + + /* "asyncpg/protocol/coreproto.pyx":626 + * self.result = [] + * + * self._send_bind_message(portal_name, stmt_name, bind_data, limit) # <<<<<<<<<<<<<< + * + * cdef _bind_execute_many(self, str portal_name, str stmt_name, + */ + __pyx_t_1 = ((struct __pyx_vtabstruct_7asyncpg_8protocol_8protocol_CoreProtocol *)__pyx_v_self->__pyx_vtab)->_send_bind_message(__pyx_v_self, __pyx_v_portal_name, __pyx_v_stmt_name, __pyx_v_bind_data, __pyx_v_limit); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 626, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "asyncpg/protocol/coreproto.pyx":616 + * self._write_sync_message() + * + * cdef _bind_execute(self, str portal_name, str stmt_name, # <<<<<<<<<<<<<< + * WriteBuffer bind_data, int32_t limit): + * + */ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("asyncpg.protocol.protocol.CoreProtocol._bind_execute", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "asyncpg/protocol/coreproto.pyx":628 + * self._send_bind_message(portal_name, stmt_name, bind_data, limit) + * + * cdef _bind_execute_many(self, str portal_name, str stmt_name, # <<<<<<<<<<<<<< + * object bind_data): + * + */ + +static PyObject *__pyx_f_7asyncpg_8protocol_8protocol_12CoreProtocol__bind_execute_many(struct __pyx_obj_7asyncpg_8protocol_8protocol_CoreProtocol *__pyx_v_self, PyObject *__pyx_v_portal_name, PyObject *__pyx_v_stmt_name, PyObject *__pyx_v_bind_data) { + struct __pyx_obj_7asyncpg_8protocol_8protocol_WriteBuffer *__pyx_v_buf = 0; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + PyObject *__pyx_t_5 = NULL; + int __pyx_t_6; + PyObject *__pyx_t_7 = NULL; + PyObject *__pyx_t_8 = NULL; + __Pyx_RefNannySetupContext("_bind_execute_many", 0); + + /* "asyncpg/protocol/coreproto.pyx":633 + * cdef WriteBuffer buf + * + * self._ensure_connected() # <<<<<<<<<<<<<< + * self._set_state(PROTOCOL_BIND_EXECUTE_MANY) + * + */ + __pyx_t_1 = ((struct __pyx_vtabstruct_7asyncpg_8protocol_8protocol_CoreProtocol *)__pyx_v_self->__pyx_vtab)->_ensure_connected(__pyx_v_self); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 633, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "asyncpg/protocol/coreproto.pyx":634 + * + * self._ensure_connected() + * self._set_state(PROTOCOL_BIND_EXECUTE_MANY) # <<<<<<<<<<<<<< + * + * self.result = None + */ + __pyx_t_1 = ((struct __pyx_vtabstruct_7asyncpg_8protocol_8protocol_CoreProtocol *)__pyx_v_self->__pyx_vtab)->_set_state(__pyx_v_self, __pyx_e_7asyncpg_8protocol_8protocol_PROTOCOL_BIND_EXECUTE_MANY); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 634, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "asyncpg/protocol/coreproto.pyx":636 + * self._set_state(PROTOCOL_BIND_EXECUTE_MANY) + * + * self.result = None # <<<<<<<<<<<<<< + * self._discard_data = True + * self._execute_iter = bind_data + */ + __Pyx_INCREF(Py_None); + __Pyx_GIVEREF(Py_None); + __Pyx_GOTREF(__pyx_v_self->result); + __Pyx_DECREF(__pyx_v_self->result); + __pyx_v_self->result = Py_None; + + /* "asyncpg/protocol/coreproto.pyx":637 + * + * self.result = None + * self._discard_data = True # <<<<<<<<<<<<<< + * self._execute_iter = bind_data + * self._execute_portal_name = portal_name + */ + __pyx_v_self->_discard_data = 1; + + /* "asyncpg/protocol/coreproto.pyx":638 + * self.result = None + * self._discard_data = True + * self._execute_iter = bind_data # <<<<<<<<<<<<<< + * self._execute_portal_name = portal_name + * self._execute_stmt_name = stmt_name + */ + __Pyx_INCREF(__pyx_v_bind_data); + __Pyx_GIVEREF(__pyx_v_bind_data); + __Pyx_GOTREF(__pyx_v_self->_execute_iter); + __Pyx_DECREF(__pyx_v_self->_execute_iter); + __pyx_v_self->_execute_iter = __pyx_v_bind_data; + + /* "asyncpg/protocol/coreproto.pyx":639 + * self._discard_data = True + * self._execute_iter = bind_data + * self._execute_portal_name = portal_name # <<<<<<<<<<<<<< + * self._execute_stmt_name = stmt_name + * + */ + __Pyx_INCREF(__pyx_v_portal_name); + __Pyx_GIVEREF(__pyx_v_portal_name); + __Pyx_GOTREF(__pyx_v_self->_execute_portal_name); + __Pyx_DECREF(__pyx_v_self->_execute_portal_name); + __pyx_v_self->_execute_portal_name = __pyx_v_portal_name; + + /* "asyncpg/protocol/coreproto.pyx":640 + * self._execute_iter = bind_data + * self._execute_portal_name = portal_name + * self._execute_stmt_name = stmt_name # <<<<<<<<<<<<<< + * + * try: + */ + __Pyx_INCREF(__pyx_v_stmt_name); + __Pyx_GIVEREF(__pyx_v_stmt_name); + __Pyx_GOTREF(__pyx_v_self->_execute_stmt_name); + __Pyx_DECREF(__pyx_v_self->_execute_stmt_name); + __pyx_v_self->_execute_stmt_name = __pyx_v_stmt_name; + + /* "asyncpg/protocol/coreproto.pyx":642 + * self._execute_stmt_name = stmt_name + * + * try: # <<<<<<<<<<<<<< + * buf = next(bind_data) + * except StopIteration: + */ + { + __Pyx_PyThreadState_declare + __Pyx_PyThreadState_assign + __Pyx_ExceptionSave(&__pyx_t_2, &__pyx_t_3, &__pyx_t_4); + __Pyx_XGOTREF(__pyx_t_2); + __Pyx_XGOTREF(__pyx_t_3); + __Pyx_XGOTREF(__pyx_t_4); + /*try:*/ { + + /* "asyncpg/protocol/coreproto.pyx":643 + * + * try: + * buf = next(bind_data) # <<<<<<<<<<<<<< + * except StopIteration: + * self._push_result() + */ + __pyx_t_1 = __Pyx_PyIter_Next(__pyx_v_bind_data); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 643, __pyx_L3_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_5 = __pyx_t_1; + __Pyx_INCREF(__pyx_t_5); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_v_buf = ((struct __pyx_obj_7asyncpg_8protocol_8protocol_WriteBuffer *)__pyx_t_5); + __pyx_t_5 = 0; + + /* "asyncpg/protocol/coreproto.pyx":642 + * self._execute_stmt_name = stmt_name + * + * try: # <<<<<<<<<<<<<< + * buf = next(bind_data) + * except StopIteration: + */ + } + + /* "asyncpg/protocol/coreproto.pyx":647 + * self._push_result() + * else: + * self._send_bind_message(portal_name, stmt_name, buf, 0) # <<<<<<<<<<<<<< + * + * cdef _execute(self, str portal_name, int32_t limit): + */ + /*else:*/ { + __pyx_t_5 = ((struct __pyx_vtabstruct_7asyncpg_8protocol_8protocol_CoreProtocol *)__pyx_v_self->__pyx_vtab)->_send_bind_message(__pyx_v_self, __pyx_v_portal_name, __pyx_v_stmt_name, __pyx_v_buf, 0); if (unlikely(!__pyx_t_5)) __PYX_ERR(4, 647, __pyx_L5_except_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + } + __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + goto __pyx_L10_try_end; + __pyx_L3_error:; + __Pyx_PyThreadState_assign + __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; + + /* "asyncpg/protocol/coreproto.pyx":644 + * try: + * buf = next(bind_data) + * except StopIteration: # <<<<<<<<<<<<<< + * self._push_result() + * else: + */ + __pyx_t_6 = __Pyx_PyErr_ExceptionMatches(__pyx_builtin_StopIteration); + if (__pyx_t_6) { + __Pyx_AddTraceback("asyncpg.protocol.protocol.CoreProtocol._bind_execute_many", __pyx_clineno, __pyx_lineno, __pyx_filename); + if (__Pyx_GetException(&__pyx_t_5, &__pyx_t_1, &__pyx_t_7) < 0) __PYX_ERR(4, 644, __pyx_L5_except_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_GOTREF(__pyx_t_1); + __Pyx_GOTREF(__pyx_t_7); + + /* "asyncpg/protocol/coreproto.pyx":645 + * buf = next(bind_data) + * except StopIteration: + * self._push_result() # <<<<<<<<<<<<<< + * else: + * self._send_bind_message(portal_name, stmt_name, buf, 0) + */ + __pyx_t_8 = ((struct __pyx_vtabstruct_7asyncpg_8protocol_8protocol_CoreProtocol *)__pyx_v_self->__pyx_vtab)->_push_result(__pyx_v_self); if (unlikely(!__pyx_t_8)) __PYX_ERR(4, 645, __pyx_L5_except_error) + __Pyx_GOTREF(__pyx_t_8); + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + goto __pyx_L4_exception_handled; + } + goto __pyx_L5_except_error; + __pyx_L5_except_error:; + + /* "asyncpg/protocol/coreproto.pyx":642 + * self._execute_stmt_name = stmt_name + * + * try: # <<<<<<<<<<<<<< + * buf = next(bind_data) + * except StopIteration: + */ + __Pyx_PyThreadState_assign + __Pyx_XGIVEREF(__pyx_t_2); + __Pyx_XGIVEREF(__pyx_t_3); + __Pyx_XGIVEREF(__pyx_t_4); + __Pyx_ExceptionReset(__pyx_t_2, __pyx_t_3, __pyx_t_4); + goto __pyx_L1_error; + __pyx_L4_exception_handled:; + __Pyx_PyThreadState_assign + __Pyx_XGIVEREF(__pyx_t_2); + __Pyx_XGIVEREF(__pyx_t_3); + __Pyx_XGIVEREF(__pyx_t_4); + __Pyx_ExceptionReset(__pyx_t_2, __pyx_t_3, __pyx_t_4); + __pyx_L10_try_end:; + } + + /* "asyncpg/protocol/coreproto.pyx":628 + * self._send_bind_message(portal_name, stmt_name, bind_data, limit) + * + * cdef _bind_execute_many(self, str portal_name, str stmt_name, # <<<<<<<<<<<<<< + * object bind_data): + * + */ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_XDECREF(__pyx_t_7); + __Pyx_XDECREF(__pyx_t_8); + __Pyx_AddTraceback("asyncpg.protocol.protocol.CoreProtocol._bind_execute_many", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XDECREF((PyObject *)__pyx_v_buf); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "asyncpg/protocol/coreproto.pyx":649 + * self._send_bind_message(portal_name, stmt_name, buf, 0) + * + * cdef _execute(self, str portal_name, int32_t limit): # <<<<<<<<<<<<<< + * cdef WriteBuffer buf + * + */ + +static PyObject *__pyx_f_7asyncpg_8protocol_8protocol_12CoreProtocol__execute(struct __pyx_obj_7asyncpg_8protocol_8protocol_CoreProtocol *__pyx_v_self, PyObject *__pyx_v_portal_name, int32_t __pyx_v_limit) { + struct __pyx_obj_7asyncpg_8protocol_8protocol_WriteBuffer *__pyx_v_buf = 0; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + __Pyx_RefNannySetupContext("_execute", 0); + + /* "asyncpg/protocol/coreproto.pyx":652 + * cdef WriteBuffer buf + * + * self._ensure_connected() # <<<<<<<<<<<<<< + * self._set_state(PROTOCOL_EXECUTE) + * + */ + __pyx_t_1 = ((struct __pyx_vtabstruct_7asyncpg_8protocol_8protocol_CoreProtocol *)__pyx_v_self->__pyx_vtab)->_ensure_connected(__pyx_v_self); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 652, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "asyncpg/protocol/coreproto.pyx":653 + * + * self._ensure_connected() + * self._set_state(PROTOCOL_EXECUTE) # <<<<<<<<<<<<<< + * + * self.result = [] + */ + __pyx_t_1 = ((struct __pyx_vtabstruct_7asyncpg_8protocol_8protocol_CoreProtocol *)__pyx_v_self->__pyx_vtab)->_set_state(__pyx_v_self, __pyx_e_7asyncpg_8protocol_8protocol_PROTOCOL_EXECUTE); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 653, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "asyncpg/protocol/coreproto.pyx":655 + * self._set_state(PROTOCOL_EXECUTE) + * + * self.result = [] # <<<<<<<<<<<<<< + * + * buf = WriteBuffer.new_message(b'E') + */ + __pyx_t_1 = PyList_New(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 655, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_GIVEREF(__pyx_t_1); + __Pyx_GOTREF(__pyx_v_self->result); + __Pyx_DECREF(__pyx_v_self->result); + __pyx_v_self->result = __pyx_t_1; + __pyx_t_1 = 0; + + /* "asyncpg/protocol/coreproto.pyx":657 + * self.result = [] + * + * buf = WriteBuffer.new_message(b'E') # <<<<<<<<<<<<<< + * buf.write_str(portal_name, self.encoding) # name of the portal + * buf.write_int32(limit) # number of rows to return; 0 - all + */ + __pyx_t_1 = ((PyObject *)__pyx_f_7asyncpg_8protocol_8protocol_11WriteBuffer_new_message('E')); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 657, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_v_buf = ((struct __pyx_obj_7asyncpg_8protocol_8protocol_WriteBuffer *)__pyx_t_1); + __pyx_t_1 = 0; + + /* "asyncpg/protocol/coreproto.pyx":658 + * + * buf = WriteBuffer.new_message(b'E') + * buf.write_str(portal_name, self.encoding) # name of the portal # <<<<<<<<<<<<<< + * buf.write_int32(limit) # number of rows to return; 0 - all + * buf.end_message() + */ + __pyx_t_1 = __pyx_v_self->encoding; + __Pyx_INCREF(__pyx_t_1); + __pyx_t_2 = __pyx_f_7asyncpg_8protocol_8protocol_11WriteBuffer_write_str(__pyx_v_buf, __pyx_v_portal_name, ((PyObject*)__pyx_t_1)); if (unlikely(!__pyx_t_2)) __PYX_ERR(4, 658, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "asyncpg/protocol/coreproto.pyx":659 + * buf = WriteBuffer.new_message(b'E') + * buf.write_str(portal_name, self.encoding) # name of the portal + * buf.write_int32(limit) # number of rows to return; 0 - all # <<<<<<<<<<<<<< + * buf.end_message() + * self._write(buf) + */ + __pyx_t_2 = __pyx_f_7asyncpg_8protocol_8protocol_11WriteBuffer_write_int32(__pyx_v_buf, __pyx_v_limit); if (unlikely(!__pyx_t_2)) __PYX_ERR(4, 659, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "asyncpg/protocol/coreproto.pyx":660 + * buf.write_str(portal_name, self.encoding) # name of the portal + * buf.write_int32(limit) # number of rows to return; 0 - all + * buf.end_message() # <<<<<<<<<<<<<< + * self._write(buf) + * self._write_sync_message() + */ + __pyx_t_2 = __pyx_f_7asyncpg_8protocol_8protocol_11WriteBuffer_end_message(__pyx_v_buf); if (unlikely(!__pyx_t_2)) __PYX_ERR(4, 660, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "asyncpg/protocol/coreproto.pyx":661 + * buf.write_int32(limit) # number of rows to return; 0 - all + * buf.end_message() + * self._write(buf) # <<<<<<<<<<<<<< + * self._write_sync_message() + * + */ + __pyx_t_2 = ((struct __pyx_vtabstruct_7asyncpg_8protocol_8protocol_CoreProtocol *)__pyx_v_self->__pyx_vtab)->_write(__pyx_v_self, ((PyObject *)__pyx_v_buf)); if (unlikely(!__pyx_t_2)) __PYX_ERR(4, 661, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "asyncpg/protocol/coreproto.pyx":662 + * buf.end_message() + * self._write(buf) + * self._write_sync_message() # <<<<<<<<<<<<<< + * + * cdef _bind(self, str portal_name, str stmt_name, + */ + __pyx_t_2 = __pyx_f_7asyncpg_8protocol_8protocol_12CoreProtocol__write_sync_message(__pyx_v_self); if (unlikely(!__pyx_t_2)) __PYX_ERR(4, 662, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "asyncpg/protocol/coreproto.pyx":649 + * self._send_bind_message(portal_name, stmt_name, buf, 0) + * + * cdef _execute(self, str portal_name, int32_t limit): # <<<<<<<<<<<<<< + * cdef WriteBuffer buf + * + */ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_AddTraceback("asyncpg.protocol.protocol.CoreProtocol._execute", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XDECREF((PyObject *)__pyx_v_buf); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "asyncpg/protocol/coreproto.pyx":664 + * self._write_sync_message() + * + * cdef _bind(self, str portal_name, str stmt_name, # <<<<<<<<<<<<<< + * WriteBuffer bind_data): + * + */ + +static PyObject *__pyx_f_7asyncpg_8protocol_8protocol_12CoreProtocol__bind(struct __pyx_obj_7asyncpg_8protocol_8protocol_CoreProtocol *__pyx_v_self, PyObject *__pyx_v_portal_name, PyObject *__pyx_v_stmt_name, struct __pyx_obj_7asyncpg_8protocol_8protocol_WriteBuffer *__pyx_v_bind_data) { + struct __pyx_obj_7asyncpg_8protocol_8protocol_WriteBuffer *__pyx_v_buf = 0; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + __Pyx_RefNannySetupContext("_bind", 0); + + /* "asyncpg/protocol/coreproto.pyx":669 + * cdef WriteBuffer buf + * + * self._ensure_connected() # <<<<<<<<<<<<<< + * self._set_state(PROTOCOL_BIND) + * + */ + __pyx_t_1 = ((struct __pyx_vtabstruct_7asyncpg_8protocol_8protocol_CoreProtocol *)__pyx_v_self->__pyx_vtab)->_ensure_connected(__pyx_v_self); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 669, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "asyncpg/protocol/coreproto.pyx":670 + * + * self._ensure_connected() + * self._set_state(PROTOCOL_BIND) # <<<<<<<<<<<<<< + * + * buf = self._build_bind_message(portal_name, stmt_name, bind_data) + */ + __pyx_t_1 = ((struct __pyx_vtabstruct_7asyncpg_8protocol_8protocol_CoreProtocol *)__pyx_v_self->__pyx_vtab)->_set_state(__pyx_v_self, __pyx_e_7asyncpg_8protocol_8protocol_PROTOCOL_BIND); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 670, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "asyncpg/protocol/coreproto.pyx":672 + * self._set_state(PROTOCOL_BIND) + * + * buf = self._build_bind_message(portal_name, stmt_name, bind_data) # <<<<<<<<<<<<<< + * self._write(buf) + * self._write_sync_message() + */ + __pyx_t_1 = ((PyObject *)((struct __pyx_vtabstruct_7asyncpg_8protocol_8protocol_CoreProtocol *)__pyx_v_self->__pyx_vtab)->_build_bind_message(__pyx_v_self, __pyx_v_portal_name, __pyx_v_stmt_name, __pyx_v_bind_data)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 672, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_v_buf = ((struct __pyx_obj_7asyncpg_8protocol_8protocol_WriteBuffer *)__pyx_t_1); + __pyx_t_1 = 0; + + /* "asyncpg/protocol/coreproto.pyx":673 + * + * buf = self._build_bind_message(portal_name, stmt_name, bind_data) + * self._write(buf) # <<<<<<<<<<<<<< + * self._write_sync_message() + * + */ + __pyx_t_1 = ((struct __pyx_vtabstruct_7asyncpg_8protocol_8protocol_CoreProtocol *)__pyx_v_self->__pyx_vtab)->_write(__pyx_v_self, ((PyObject *)__pyx_v_buf)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 673, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "asyncpg/protocol/coreproto.pyx":674 + * buf = self._build_bind_message(portal_name, stmt_name, bind_data) + * self._write(buf) + * self._write_sync_message() # <<<<<<<<<<<<<< + * + * cdef _close(self, str name, bint is_portal): + */ + __pyx_t_1 = __pyx_f_7asyncpg_8protocol_8protocol_12CoreProtocol__write_sync_message(__pyx_v_self); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 674, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "asyncpg/protocol/coreproto.pyx":664 + * self._write_sync_message() + * + * cdef _bind(self, str portal_name, str stmt_name, # <<<<<<<<<<<<<< + * WriteBuffer bind_data): + * + */ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("asyncpg.protocol.protocol.CoreProtocol._bind", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XDECREF((PyObject *)__pyx_v_buf); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "asyncpg/protocol/coreproto.pyx":676 + * self._write_sync_message() + * + * cdef _close(self, str name, bint is_portal): # <<<<<<<<<<<<<< + * cdef WriteBuffer buf + * + */ + +static PyObject *__pyx_f_7asyncpg_8protocol_8protocol_12CoreProtocol__close(struct __pyx_obj_7asyncpg_8protocol_8protocol_CoreProtocol *__pyx_v_self, PyObject *__pyx_v_name, int __pyx_v_is_portal) { + struct __pyx_obj_7asyncpg_8protocol_8protocol_WriteBuffer *__pyx_v_buf = 0; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_t_2; + PyObject *__pyx_t_3 = NULL; + __Pyx_RefNannySetupContext("_close", 0); + + /* "asyncpg/protocol/coreproto.pyx":679 + * cdef WriteBuffer buf + * + * self._ensure_connected() # <<<<<<<<<<<<<< + * self._set_state(PROTOCOL_CLOSE_STMT_PORTAL) + * + */ + __pyx_t_1 = ((struct __pyx_vtabstruct_7asyncpg_8protocol_8protocol_CoreProtocol *)__pyx_v_self->__pyx_vtab)->_ensure_connected(__pyx_v_self); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 679, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "asyncpg/protocol/coreproto.pyx":680 + * + * self._ensure_connected() + * self._set_state(PROTOCOL_CLOSE_STMT_PORTAL) # <<<<<<<<<<<<<< + * + * buf = WriteBuffer.new_message(b'C') + */ + __pyx_t_1 = ((struct __pyx_vtabstruct_7asyncpg_8protocol_8protocol_CoreProtocol *)__pyx_v_self->__pyx_vtab)->_set_state(__pyx_v_self, __pyx_e_7asyncpg_8protocol_8protocol_PROTOCOL_CLOSE_STMT_PORTAL); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 680, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "asyncpg/protocol/coreproto.pyx":682 + * self._set_state(PROTOCOL_CLOSE_STMT_PORTAL) + * + * buf = WriteBuffer.new_message(b'C') # <<<<<<<<<<<<<< + * + * if is_portal: + */ + __pyx_t_1 = ((PyObject *)__pyx_f_7asyncpg_8protocol_8protocol_11WriteBuffer_new_message('C')); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 682, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_v_buf = ((struct __pyx_obj_7asyncpg_8protocol_8protocol_WriteBuffer *)__pyx_t_1); + __pyx_t_1 = 0; + + /* "asyncpg/protocol/coreproto.pyx":684 + * buf = WriteBuffer.new_message(b'C') + * + * if is_portal: # <<<<<<<<<<<<<< + * buf.write_byte(b'P') + * else: + */ + __pyx_t_2 = (__pyx_v_is_portal != 0); + if (__pyx_t_2) { + + /* "asyncpg/protocol/coreproto.pyx":685 + * + * if is_portal: + * buf.write_byte(b'P') # <<<<<<<<<<<<<< + * else: + * buf.write_byte(b'S') + */ + __pyx_t_1 = __pyx_f_7asyncpg_8protocol_8protocol_11WriteBuffer_write_byte(__pyx_v_buf, 'P'); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 685, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "asyncpg/protocol/coreproto.pyx":684 + * buf = WriteBuffer.new_message(b'C') + * + * if is_portal: # <<<<<<<<<<<<<< + * buf.write_byte(b'P') + * else: + */ + goto __pyx_L3; + } + + /* "asyncpg/protocol/coreproto.pyx":687 + * buf.write_byte(b'P') + * else: + * buf.write_byte(b'S') # <<<<<<<<<<<<<< + * + * buf.write_str(name, self.encoding) + */ + /*else*/ { + __pyx_t_1 = __pyx_f_7asyncpg_8protocol_8protocol_11WriteBuffer_write_byte(__pyx_v_buf, 'S'); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 687, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + } + __pyx_L3:; + + /* "asyncpg/protocol/coreproto.pyx":689 + * buf.write_byte(b'S') + * + * buf.write_str(name, self.encoding) # <<<<<<<<<<<<<< + * buf.end_message() + * self._write(buf) + */ + __pyx_t_1 = __pyx_v_self->encoding; + __Pyx_INCREF(__pyx_t_1); + __pyx_t_3 = __pyx_f_7asyncpg_8protocol_8protocol_11WriteBuffer_write_str(__pyx_v_buf, __pyx_v_name, ((PyObject*)__pyx_t_1)); if (unlikely(!__pyx_t_3)) __PYX_ERR(4, 689, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + + /* "asyncpg/protocol/coreproto.pyx":690 + * + * buf.write_str(name, self.encoding) + * buf.end_message() # <<<<<<<<<<<<<< + * self._write(buf) + * + */ + __pyx_t_3 = __pyx_f_7asyncpg_8protocol_8protocol_11WriteBuffer_end_message(__pyx_v_buf); if (unlikely(!__pyx_t_3)) __PYX_ERR(4, 690, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + + /* "asyncpg/protocol/coreproto.pyx":691 + * buf.write_str(name, self.encoding) + * buf.end_message() + * self._write(buf) # <<<<<<<<<<<<<< + * + * self._write_sync_message() + */ + __pyx_t_3 = ((struct __pyx_vtabstruct_7asyncpg_8protocol_8protocol_CoreProtocol *)__pyx_v_self->__pyx_vtab)->_write(__pyx_v_self, ((PyObject *)__pyx_v_buf)); if (unlikely(!__pyx_t_3)) __PYX_ERR(4, 691, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + + /* "asyncpg/protocol/coreproto.pyx":693 + * self._write(buf) + * + * self._write_sync_message() # <<<<<<<<<<<<<< + * + * cdef _simple_query(self, str query): + */ + __pyx_t_3 = __pyx_f_7asyncpg_8protocol_8protocol_12CoreProtocol__write_sync_message(__pyx_v_self); if (unlikely(!__pyx_t_3)) __PYX_ERR(4, 693, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + + /* "asyncpg/protocol/coreproto.pyx":676 + * self._write_sync_message() + * + * cdef _close(self, str name, bint is_portal): # <<<<<<<<<<<<<< + * cdef WriteBuffer buf + * + */ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_AddTraceback("asyncpg.protocol.protocol.CoreProtocol._close", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XDECREF((PyObject *)__pyx_v_buf); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "asyncpg/protocol/coreproto.pyx":695 + * self._write_sync_message() + * + * cdef _simple_query(self, str query): # <<<<<<<<<<<<<< + * cdef WriteBuffer buf + * self._ensure_connected() + */ + +static PyObject *__pyx_f_7asyncpg_8protocol_8protocol_12CoreProtocol__simple_query(struct __pyx_obj_7asyncpg_8protocol_8protocol_CoreProtocol *__pyx_v_self, PyObject *__pyx_v_query) { + struct __pyx_obj_7asyncpg_8protocol_8protocol_WriteBuffer *__pyx_v_buf = 0; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + __Pyx_RefNannySetupContext("_simple_query", 0); + + /* "asyncpg/protocol/coreproto.pyx":697 + * cdef _simple_query(self, str query): + * cdef WriteBuffer buf + * self._ensure_connected() # <<<<<<<<<<<<<< + * self._set_state(PROTOCOL_SIMPLE_QUERY) + * buf = WriteBuffer.new_message(b'Q') + */ + __pyx_t_1 = ((struct __pyx_vtabstruct_7asyncpg_8protocol_8protocol_CoreProtocol *)__pyx_v_self->__pyx_vtab)->_ensure_connected(__pyx_v_self); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 697, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "asyncpg/protocol/coreproto.pyx":698 + * cdef WriteBuffer buf + * self._ensure_connected() + * self._set_state(PROTOCOL_SIMPLE_QUERY) # <<<<<<<<<<<<<< + * buf = WriteBuffer.new_message(b'Q') + * buf.write_str(query, self.encoding) + */ + __pyx_t_1 = ((struct __pyx_vtabstruct_7asyncpg_8protocol_8protocol_CoreProtocol *)__pyx_v_self->__pyx_vtab)->_set_state(__pyx_v_self, __pyx_e_7asyncpg_8protocol_8protocol_PROTOCOL_SIMPLE_QUERY); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 698, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "asyncpg/protocol/coreproto.pyx":699 + * self._ensure_connected() + * self._set_state(PROTOCOL_SIMPLE_QUERY) + * buf = WriteBuffer.new_message(b'Q') # <<<<<<<<<<<<<< + * buf.write_str(query, self.encoding) + * buf.end_message() + */ + __pyx_t_1 = ((PyObject *)__pyx_f_7asyncpg_8protocol_8protocol_11WriteBuffer_new_message('Q')); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 699, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_v_buf = ((struct __pyx_obj_7asyncpg_8protocol_8protocol_WriteBuffer *)__pyx_t_1); + __pyx_t_1 = 0; + + /* "asyncpg/protocol/coreproto.pyx":700 + * self._set_state(PROTOCOL_SIMPLE_QUERY) + * buf = WriteBuffer.new_message(b'Q') + * buf.write_str(query, self.encoding) # <<<<<<<<<<<<<< + * buf.end_message() + * self._write(buf) + */ + __pyx_t_1 = __pyx_v_self->encoding; + __Pyx_INCREF(__pyx_t_1); + __pyx_t_2 = __pyx_f_7asyncpg_8protocol_8protocol_11WriteBuffer_write_str(__pyx_v_buf, __pyx_v_query, ((PyObject*)__pyx_t_1)); if (unlikely(!__pyx_t_2)) __PYX_ERR(4, 700, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "asyncpg/protocol/coreproto.pyx":701 + * buf = WriteBuffer.new_message(b'Q') + * buf.write_str(query, self.encoding) + * buf.end_message() # <<<<<<<<<<<<<< + * self._write(buf) + * + */ + __pyx_t_2 = __pyx_f_7asyncpg_8protocol_8protocol_11WriteBuffer_end_message(__pyx_v_buf); if (unlikely(!__pyx_t_2)) __PYX_ERR(4, 701, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "asyncpg/protocol/coreproto.pyx":702 + * buf.write_str(query, self.encoding) + * buf.end_message() + * self._write(buf) # <<<<<<<<<<<<<< + * + * cdef _terminate(self): + */ + __pyx_t_2 = ((struct __pyx_vtabstruct_7asyncpg_8protocol_8protocol_CoreProtocol *)__pyx_v_self->__pyx_vtab)->_write(__pyx_v_self, ((PyObject *)__pyx_v_buf)); if (unlikely(!__pyx_t_2)) __PYX_ERR(4, 702, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "asyncpg/protocol/coreproto.pyx":695 + * self._write_sync_message() + * + * cdef _simple_query(self, str query): # <<<<<<<<<<<<<< + * cdef WriteBuffer buf + * self._ensure_connected() + */ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_AddTraceback("asyncpg.protocol.protocol.CoreProtocol._simple_query", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XDECREF((PyObject *)__pyx_v_buf); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "asyncpg/protocol/coreproto.pyx":704 + * self._write(buf) + * + * cdef _terminate(self): # <<<<<<<<<<<<<< + * cdef WriteBuffer buf + * self._ensure_connected() + */ + +static PyObject *__pyx_f_7asyncpg_8protocol_8protocol_12CoreProtocol__terminate(struct __pyx_obj_7asyncpg_8protocol_8protocol_CoreProtocol *__pyx_v_self) { + struct __pyx_obj_7asyncpg_8protocol_8protocol_WriteBuffer *__pyx_v_buf = 0; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + __Pyx_RefNannySetupContext("_terminate", 0); + + /* "asyncpg/protocol/coreproto.pyx":706 + * cdef _terminate(self): + * cdef WriteBuffer buf + * self._ensure_connected() # <<<<<<<<<<<<<< + * buf = WriteBuffer.new_message(b'X') + * buf.end_message() + */ + __pyx_t_1 = ((struct __pyx_vtabstruct_7asyncpg_8protocol_8protocol_CoreProtocol *)__pyx_v_self->__pyx_vtab)->_ensure_connected(__pyx_v_self); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 706, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "asyncpg/protocol/coreproto.pyx":707 + * cdef WriteBuffer buf + * self._ensure_connected() + * buf = WriteBuffer.new_message(b'X') # <<<<<<<<<<<<<< + * buf.end_message() + * self._write(buf) + */ + __pyx_t_1 = ((PyObject *)__pyx_f_7asyncpg_8protocol_8protocol_11WriteBuffer_new_message('X')); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 707, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_v_buf = ((struct __pyx_obj_7asyncpg_8protocol_8protocol_WriteBuffer *)__pyx_t_1); + __pyx_t_1 = 0; + + /* "asyncpg/protocol/coreproto.pyx":708 + * self._ensure_connected() + * buf = WriteBuffer.new_message(b'X') + * buf.end_message() # <<<<<<<<<<<<<< + * self._write(buf) + * + */ + __pyx_t_1 = __pyx_f_7asyncpg_8protocol_8protocol_11WriteBuffer_end_message(__pyx_v_buf); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 708, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "asyncpg/protocol/coreproto.pyx":709 + * buf = WriteBuffer.new_message(b'X') + * buf.end_message() + * self._write(buf) # <<<<<<<<<<<<<< + * + * cdef _decode_row(self, const char* buf, ssize_t buf_len): + */ + __pyx_t_1 = ((struct __pyx_vtabstruct_7asyncpg_8protocol_8protocol_CoreProtocol *)__pyx_v_self->__pyx_vtab)->_write(__pyx_v_self, ((PyObject *)__pyx_v_buf)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 709, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "asyncpg/protocol/coreproto.pyx":704 + * self._write(buf) + * + * cdef _terminate(self): # <<<<<<<<<<<<<< + * cdef WriteBuffer buf + * self._ensure_connected() + */ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("asyncpg.protocol.protocol.CoreProtocol._terminate", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XDECREF((PyObject *)__pyx_v_buf); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "asyncpg/protocol/coreproto.pyx":711 + * self._write(buf) + * + * cdef _decode_row(self, const char* buf, ssize_t buf_len): # <<<<<<<<<<<<<< + * pass + * + */ + +static PyObject *__pyx_f_7asyncpg_8protocol_8protocol_12CoreProtocol__decode_row(CYTHON_UNUSED struct __pyx_obj_7asyncpg_8protocol_8protocol_CoreProtocol *__pyx_v_self, CYTHON_UNUSED char const *__pyx_v_buf, CYTHON_UNUSED Py_ssize_t __pyx_v_buf_len) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("_decode_row", 0); + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "asyncpg/protocol/coreproto.pyx":714 + * pass + * + * cdef _set_server_parameter(self, name, val): # <<<<<<<<<<<<<< + * pass + * + */ + +static PyObject *__pyx_f_7asyncpg_8protocol_8protocol_12CoreProtocol__set_server_parameter(CYTHON_UNUSED struct __pyx_obj_7asyncpg_8protocol_8protocol_CoreProtocol *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v_name, CYTHON_UNUSED PyObject *__pyx_v_val) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("_set_server_parameter", 0); + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "asyncpg/protocol/coreproto.pyx":717 + * pass + * + * cdef _on_result(self): # <<<<<<<<<<<<<< + * pass + * + */ + +static PyObject *__pyx_f_7asyncpg_8protocol_8protocol_12CoreProtocol__on_result(CYTHON_UNUSED struct __pyx_obj_7asyncpg_8protocol_8protocol_CoreProtocol *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("_on_result", 0); + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "asyncpg/protocol/coreproto.pyx":720 + * pass + * + * cdef _on_notification(self, pid, channel, payload): # <<<<<<<<<<<<<< + * pass + * + */ + +static PyObject *__pyx_f_7asyncpg_8protocol_8protocol_12CoreProtocol__on_notification(CYTHON_UNUSED struct __pyx_obj_7asyncpg_8protocol_8protocol_CoreProtocol *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v_pid, CYTHON_UNUSED PyObject *__pyx_v_channel, CYTHON_UNUSED PyObject *__pyx_v_payload) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("_on_notification", 0); + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "asyncpg/protocol/coreproto.pyx":723 + * pass + * + * cdef _on_connection_lost(self, exc): # <<<<<<<<<<<<<< + * pass + * + */ + +static PyObject *__pyx_f_7asyncpg_8protocol_8protocol_12CoreProtocol__on_connection_lost(CYTHON_UNUSED struct __pyx_obj_7asyncpg_8protocol_8protocol_CoreProtocol *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v_exc) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("_on_connection_lost", 0); + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "asyncpg/protocol/coreproto.pyx":728 + * # asyncio callbacks: + * + * def data_received(self, data): # <<<<<<<<<<<<<< + * self.buffer.feed_data(data) + * self._read_server_messages() + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_7asyncpg_8protocol_8protocol_12CoreProtocol_3data_received(PyObject *__pyx_v_self, PyObject *__pyx_v_data); /*proto*/ +static PyObject *__pyx_pw_7asyncpg_8protocol_8protocol_12CoreProtocol_3data_received(PyObject *__pyx_v_self, PyObject *__pyx_v_data) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("data_received (wrapper)", 0); + __pyx_r = __pyx_pf_7asyncpg_8protocol_8protocol_12CoreProtocol_2data_received(((struct __pyx_obj_7asyncpg_8protocol_8protocol_CoreProtocol *)__pyx_v_self), ((PyObject *)__pyx_v_data)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_7asyncpg_8protocol_8protocol_12CoreProtocol_2data_received(struct __pyx_obj_7asyncpg_8protocol_8protocol_CoreProtocol *__pyx_v_self, PyObject *__pyx_v_data) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + __Pyx_RefNannySetupContext("data_received", 0); + + /* "asyncpg/protocol/coreproto.pyx":729 + * + * def data_received(self, data): + * self.buffer.feed_data(data) # <<<<<<<<<<<<<< + * self._read_server_messages() + * + */ + __pyx_t_1 = __pyx_f_7asyncpg_8protocol_8protocol_10ReadBuffer_feed_data(__pyx_v_self->buffer, __pyx_v_data); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 729, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "asyncpg/protocol/coreproto.pyx":730 + * def data_received(self, data): + * self.buffer.feed_data(data) + * self._read_server_messages() # <<<<<<<<<<<<<< + * + * def connection_made(self, transport): + */ + __pyx_t_1 = ((struct __pyx_vtabstruct_7asyncpg_8protocol_8protocol_CoreProtocol *)__pyx_v_self->__pyx_vtab)->_read_server_messages(__pyx_v_self); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 730, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "asyncpg/protocol/coreproto.pyx":728 + * # asyncio callbacks: + * + * def data_received(self, data): # <<<<<<<<<<<<<< + * self.buffer.feed_data(data) + * self._read_server_messages() + */ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("asyncpg.protocol.protocol.CoreProtocol.data_received", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "asyncpg/protocol/coreproto.pyx":732 + * self._read_server_messages() + * + * def connection_made(self, transport): # <<<<<<<<<<<<<< + * self.transport = transport + * + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_7asyncpg_8protocol_8protocol_12CoreProtocol_5connection_made(PyObject *__pyx_v_self, PyObject *__pyx_v_transport); /*proto*/ +static PyObject *__pyx_pw_7asyncpg_8protocol_8protocol_12CoreProtocol_5connection_made(PyObject *__pyx_v_self, PyObject *__pyx_v_transport) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("connection_made (wrapper)", 0); + __pyx_r = __pyx_pf_7asyncpg_8protocol_8protocol_12CoreProtocol_4connection_made(((struct __pyx_obj_7asyncpg_8protocol_8protocol_CoreProtocol *)__pyx_v_self), ((PyObject *)__pyx_v_transport)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_7asyncpg_8protocol_8protocol_12CoreProtocol_4connection_made(struct __pyx_obj_7asyncpg_8protocol_8protocol_CoreProtocol *__pyx_v_self, PyObject *__pyx_v_transport) { + PyObject *__pyx_v_sock = NULL; + PyObject *__pyx_v_ex = NULL; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + int __pyx_t_3; + int __pyx_t_4; + int __pyx_t_5; + PyObject *__pyx_t_6 = NULL; + PyObject *__pyx_t_7 = NULL; + PyObject *__pyx_t_8 = NULL; + int __pyx_t_9; + PyObject *__pyx_t_10 = NULL; + PyObject *__pyx_t_11 = NULL; + PyObject *__pyx_t_12 = NULL; + PyObject *__pyx_t_13 = NULL; + PyObject *__pyx_t_14 = NULL; + int __pyx_t_15; + char const *__pyx_t_16; + PyObject *__pyx_t_17 = NULL; + PyObject *__pyx_t_18 = NULL; + PyObject *__pyx_t_19 = NULL; + PyObject *__pyx_t_20 = NULL; + PyObject *__pyx_t_21 = NULL; + PyObject *__pyx_t_22 = NULL; + __Pyx_RefNannySetupContext("connection_made", 0); + + /* "asyncpg/protocol/coreproto.pyx":733 + * + * def connection_made(self, transport): + * self.transport = transport # <<<<<<<<<<<<<< + * + * sock = transport.get_extra_info('socket') + */ + __Pyx_INCREF(__pyx_v_transport); + __Pyx_GIVEREF(__pyx_v_transport); + __Pyx_GOTREF(__pyx_v_self->transport); + __Pyx_DECREF(__pyx_v_self->transport); + __pyx_v_self->transport = __pyx_v_transport; + + /* "asyncpg/protocol/coreproto.pyx":735 + * self.transport = transport + * + * sock = transport.get_extra_info('socket') # <<<<<<<<<<<<<< + * if (sock is not None and + * (not hasattr(socket, 'AF_UNIX') + */ + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_transport, __pyx_n_s_get_extra_info); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 735, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_tuple__68, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(4, 735, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_v_sock = __pyx_t_2; + __pyx_t_2 = 0; + + /* "asyncpg/protocol/coreproto.pyx":736 + * + * sock = transport.get_extra_info('socket') + * if (sock is not None and # <<<<<<<<<<<<<< + * (not hasattr(socket, 'AF_UNIX') + * or sock.family != socket.AF_UNIX)): + */ + __pyx_t_4 = (__pyx_v_sock != Py_None); + __pyx_t_5 = (__pyx_t_4 != 0); + if (__pyx_t_5) { + } else { + __pyx_t_3 = __pyx_t_5; + goto __pyx_L4_bool_binop_done; + } + + /* "asyncpg/protocol/coreproto.pyx":737 + * sock = transport.get_extra_info('socket') + * if (sock is not None and + * (not hasattr(socket, 'AF_UNIX') # <<<<<<<<<<<<<< + * or sock.family != socket.AF_UNIX)): + * sock.setsockopt(socket.IPPROTO_TCP, + */ + __pyx_t_2 = __Pyx_GetModuleGlobalName(__pyx_n_s_socket); if (unlikely(!__pyx_t_2)) __PYX_ERR(4, 737, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_5 = PyObject_HasAttr(__pyx_t_2, __pyx_n_u_AF_UNIX); if (unlikely(__pyx_t_5 == -1)) __PYX_ERR(4, 737, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_4 = ((!(__pyx_t_5 != 0)) != 0); + if (!__pyx_t_4) { + } else { + __pyx_t_3 = __pyx_t_4; + goto __pyx_L4_bool_binop_done; + } + + /* "asyncpg/protocol/coreproto.pyx":738 + * if (sock is not None and + * (not hasattr(socket, 'AF_UNIX') + * or sock.family != socket.AF_UNIX)): # <<<<<<<<<<<<<< + * sock.setsockopt(socket.IPPROTO_TCP, + * socket.TCP_NODELAY, 1) + */ + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_sock, __pyx_n_s_family); if (unlikely(!__pyx_t_2)) __PYX_ERR(4, 738, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_1 = __Pyx_GetModuleGlobalName(__pyx_n_s_socket); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 738, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_AF_UNIX); if (unlikely(!__pyx_t_6)) __PYX_ERR(4, 738, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_1 = PyObject_RichCompare(__pyx_t_2, __pyx_t_6, Py_NE); __Pyx_XGOTREF(__pyx_t_1); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 738, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __pyx_t_4 = __Pyx_PyObject_IsTrue(__pyx_t_1); if (unlikely(__pyx_t_4 < 0)) __PYX_ERR(4, 738, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_3 = __pyx_t_4; + __pyx_L4_bool_binop_done:; + + /* "asyncpg/protocol/coreproto.pyx":736 + * + * sock = transport.get_extra_info('socket') + * if (sock is not None and # <<<<<<<<<<<<<< + * (not hasattr(socket, 'AF_UNIX') + * or sock.family != socket.AF_UNIX)): + */ + if (__pyx_t_3) { + + /* "asyncpg/protocol/coreproto.pyx":739 + * (not hasattr(socket, 'AF_UNIX') + * or sock.family != socket.AF_UNIX)): + * sock.setsockopt(socket.IPPROTO_TCP, # <<<<<<<<<<<<<< + * socket.TCP_NODELAY, 1) + * + */ + __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_v_sock, __pyx_n_s_setsockopt); if (unlikely(!__pyx_t_6)) __PYX_ERR(4, 739, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_2 = __Pyx_GetModuleGlobalName(__pyx_n_s_socket); if (unlikely(!__pyx_t_2)) __PYX_ERR(4, 739, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_IPPROTO_TCP); if (unlikely(!__pyx_t_7)) __PYX_ERR(4, 739, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "asyncpg/protocol/coreproto.pyx":740 + * or sock.family != socket.AF_UNIX)): + * sock.setsockopt(socket.IPPROTO_TCP, + * socket.TCP_NODELAY, 1) # <<<<<<<<<<<<<< + * + * try: + */ + __pyx_t_2 = __Pyx_GetModuleGlobalName(__pyx_n_s_socket); if (unlikely(!__pyx_t_2)) __PYX_ERR(4, 740, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_8 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_TCP_NODELAY); if (unlikely(!__pyx_t_8)) __PYX_ERR(4, 740, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_2 = NULL; + __pyx_t_9 = 0; + if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_6))) { + __pyx_t_2 = PyMethod_GET_SELF(__pyx_t_6); + if (likely(__pyx_t_2)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_6); + __Pyx_INCREF(__pyx_t_2); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_6, function); + __pyx_t_9 = 1; + } + } + #if CYTHON_FAST_PYCALL + if (PyFunction_Check(__pyx_t_6)) { + PyObject *__pyx_temp[4] = {__pyx_t_2, __pyx_t_7, __pyx_t_8, __pyx_int_1}; + __pyx_t_1 = __Pyx_PyFunction_FastCall(__pyx_t_6, __pyx_temp+1-__pyx_t_9, 3+__pyx_t_9); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 739, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + } else + #endif + #if CYTHON_FAST_PYCCALL + if (__Pyx_PyFastCFunction_Check(__pyx_t_6)) { + PyObject *__pyx_temp[4] = {__pyx_t_2, __pyx_t_7, __pyx_t_8, __pyx_int_1}; + __pyx_t_1 = __Pyx_PyCFunction_FastCall(__pyx_t_6, __pyx_temp+1-__pyx_t_9, 3+__pyx_t_9); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 739, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + } else + #endif + { + __pyx_t_10 = PyTuple_New(3+__pyx_t_9); if (unlikely(!__pyx_t_10)) __PYX_ERR(4, 739, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_10); + if (__pyx_t_2) { + __Pyx_GIVEREF(__pyx_t_2); PyTuple_SET_ITEM(__pyx_t_10, 0, __pyx_t_2); __pyx_t_2 = NULL; + } + __Pyx_GIVEREF(__pyx_t_7); + PyTuple_SET_ITEM(__pyx_t_10, 0+__pyx_t_9, __pyx_t_7); + __Pyx_GIVEREF(__pyx_t_8); + PyTuple_SET_ITEM(__pyx_t_10, 1+__pyx_t_9, __pyx_t_8); + __Pyx_INCREF(__pyx_int_1); + __Pyx_GIVEREF(__pyx_int_1); + PyTuple_SET_ITEM(__pyx_t_10, 2+__pyx_t_9, __pyx_int_1); + __pyx_t_7 = 0; + __pyx_t_8 = 0; + __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_6, __pyx_t_10, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 739, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; + } + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "asyncpg/protocol/coreproto.pyx":736 + * + * sock = transport.get_extra_info('socket') + * if (sock is not None and # <<<<<<<<<<<<<< + * (not hasattr(socket, 'AF_UNIX') + * or sock.family != socket.AF_UNIX)): + */ + } + + /* "asyncpg/protocol/coreproto.pyx":742 + * socket.TCP_NODELAY, 1) + * + * try: # <<<<<<<<<<<<<< + * self._connect() + * except Exception as ex: + */ + { + __Pyx_PyThreadState_declare + __Pyx_PyThreadState_assign + __Pyx_ExceptionSave(&__pyx_t_11, &__pyx_t_12, &__pyx_t_13); + __Pyx_XGOTREF(__pyx_t_11); + __Pyx_XGOTREF(__pyx_t_12); + __Pyx_XGOTREF(__pyx_t_13); + /*try:*/ { + + /* "asyncpg/protocol/coreproto.pyx":743 + * + * try: + * self._connect() # <<<<<<<<<<<<<< + * except Exception as ex: + * transport.abort() + */ + __pyx_t_1 = ((struct __pyx_vtabstruct_7asyncpg_8protocol_8protocol_CoreProtocol *)__pyx_v_self->__pyx_vtab)->_connect(__pyx_v_self); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 743, __pyx_L7_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "asyncpg/protocol/coreproto.pyx":742 + * socket.TCP_NODELAY, 1) + * + * try: # <<<<<<<<<<<<<< + * self._connect() + * except Exception as ex: + */ + } + __Pyx_XDECREF(__pyx_t_11); __pyx_t_11 = 0; + __Pyx_XDECREF(__pyx_t_12); __pyx_t_12 = 0; + __Pyx_XDECREF(__pyx_t_13); __pyx_t_13 = 0; + goto __pyx_L14_try_end; + __pyx_L7_error:; + __Pyx_PyThreadState_assign + __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; + __Pyx_XDECREF(__pyx_t_10); __pyx_t_10 = 0; + __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "asyncpg/protocol/coreproto.pyx":744 + * try: + * self._connect() + * except Exception as ex: # <<<<<<<<<<<<<< + * transport.abort() + * self.con_status = CONNECTION_BAD + */ + __pyx_t_9 = __Pyx_PyErr_ExceptionMatches(((PyObject *)(&((PyTypeObject*)PyExc_Exception)[0]))); + if (__pyx_t_9) { + __Pyx_AddTraceback("asyncpg.protocol.protocol.CoreProtocol.connection_made", __pyx_clineno, __pyx_lineno, __pyx_filename); + if (__Pyx_GetException(&__pyx_t_1, &__pyx_t_6, &__pyx_t_10) < 0) __PYX_ERR(4, 744, __pyx_L9_except_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_GOTREF(__pyx_t_6); + __Pyx_GOTREF(__pyx_t_10); + __Pyx_INCREF(__pyx_t_6); + __pyx_v_ex = __pyx_t_6; + /*try:*/ { + + /* "asyncpg/protocol/coreproto.pyx":745 + * self._connect() + * except Exception as ex: + * transport.abort() # <<<<<<<<<<<<<< + * self.con_status = CONNECTION_BAD + * self._set_state(PROTOCOL_FAILED) + */ + __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_v_transport, __pyx_n_s_abort); if (unlikely(!__pyx_t_7)) __PYX_ERR(4, 745, __pyx_L20_error) + __Pyx_GOTREF(__pyx_t_7); + __pyx_t_2 = NULL; + if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_7))) { + __pyx_t_2 = PyMethod_GET_SELF(__pyx_t_7); + if (likely(__pyx_t_2)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_7); + __Pyx_INCREF(__pyx_t_2); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_7, function); + } + } + if (__pyx_t_2) { + __pyx_t_8 = __Pyx_PyObject_CallOneArg(__pyx_t_7, __pyx_t_2); if (unlikely(!__pyx_t_8)) __PYX_ERR(4, 745, __pyx_L20_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } else { + __pyx_t_8 = __Pyx_PyObject_CallNoArg(__pyx_t_7); if (unlikely(!__pyx_t_8)) __PYX_ERR(4, 745, __pyx_L20_error) + } + __Pyx_GOTREF(__pyx_t_8); + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + + /* "asyncpg/protocol/coreproto.pyx":746 + * except Exception as ex: + * transport.abort() + * self.con_status = CONNECTION_BAD # <<<<<<<<<<<<<< + * self._set_state(PROTOCOL_FAILED) + * self._on_error(ex) + */ + __pyx_v_self->con_status = __pyx_e_7asyncpg_8protocol_8protocol_CONNECTION_BAD; + + /* "asyncpg/protocol/coreproto.pyx":747 + * transport.abort() + * self.con_status = CONNECTION_BAD + * self._set_state(PROTOCOL_FAILED) # <<<<<<<<<<<<<< + * self._on_error(ex) + * + */ + __pyx_t_8 = ((struct __pyx_vtabstruct_7asyncpg_8protocol_8protocol_CoreProtocol *)__pyx_v_self->__pyx_vtab)->_set_state(__pyx_v_self, __pyx_e_7asyncpg_8protocol_8protocol_PROTOCOL_FAILED); if (unlikely(!__pyx_t_8)) __PYX_ERR(4, 747, __pyx_L20_error) + __Pyx_GOTREF(__pyx_t_8); + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + + /* "asyncpg/protocol/coreproto.pyx":748 + * self.con_status = CONNECTION_BAD + * self._set_state(PROTOCOL_FAILED) + * self._on_error(ex) # <<<<<<<<<<<<<< + * + * def connection_lost(self, exc): + */ + __pyx_t_7 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_on_error); if (unlikely(!__pyx_t_7)) __PYX_ERR(4, 748, __pyx_L20_error) + __Pyx_GOTREF(__pyx_t_7); + __pyx_t_2 = NULL; + if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_7))) { + __pyx_t_2 = PyMethod_GET_SELF(__pyx_t_7); + if (likely(__pyx_t_2)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_7); + __Pyx_INCREF(__pyx_t_2); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_7, function); + } + } + if (!__pyx_t_2) { + __pyx_t_8 = __Pyx_PyObject_CallOneArg(__pyx_t_7, __pyx_v_ex); if (unlikely(!__pyx_t_8)) __PYX_ERR(4, 748, __pyx_L20_error) + __Pyx_GOTREF(__pyx_t_8); + } else { + #if CYTHON_FAST_PYCALL + if (PyFunction_Check(__pyx_t_7)) { + PyObject *__pyx_temp[2] = {__pyx_t_2, __pyx_v_ex}; + __pyx_t_8 = __Pyx_PyFunction_FastCall(__pyx_t_7, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_8)) __PYX_ERR(4, 748, __pyx_L20_error) + __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_GOTREF(__pyx_t_8); + } else + #endif + #if CYTHON_FAST_PYCCALL + if (__Pyx_PyFastCFunction_Check(__pyx_t_7)) { + PyObject *__pyx_temp[2] = {__pyx_t_2, __pyx_v_ex}; + __pyx_t_8 = __Pyx_PyCFunction_FastCall(__pyx_t_7, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_8)) __PYX_ERR(4, 748, __pyx_L20_error) + __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_GOTREF(__pyx_t_8); + } else + #endif + { + __pyx_t_14 = PyTuple_New(1+1); if (unlikely(!__pyx_t_14)) __PYX_ERR(4, 748, __pyx_L20_error) + __Pyx_GOTREF(__pyx_t_14); + __Pyx_GIVEREF(__pyx_t_2); PyTuple_SET_ITEM(__pyx_t_14, 0, __pyx_t_2); __pyx_t_2 = NULL; + __Pyx_INCREF(__pyx_v_ex); + __Pyx_GIVEREF(__pyx_v_ex); + PyTuple_SET_ITEM(__pyx_t_14, 0+1, __pyx_v_ex); + __pyx_t_8 = __Pyx_PyObject_Call(__pyx_t_7, __pyx_t_14, NULL); if (unlikely(!__pyx_t_8)) __PYX_ERR(4, 748, __pyx_L20_error) + __Pyx_GOTREF(__pyx_t_8); + __Pyx_DECREF(__pyx_t_14); __pyx_t_14 = 0; + } + } + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + } + + /* "asyncpg/protocol/coreproto.pyx":744 + * try: + * self._connect() + * except Exception as ex: # <<<<<<<<<<<<<< + * transport.abort() + * self.con_status = CONNECTION_BAD + */ + /*finally:*/ { + /*normal exit:*/{ + __Pyx_DECREF(__pyx_v_ex); + __pyx_v_ex = NULL; + goto __pyx_L21; + } + /*exception exit:*/{ + __Pyx_PyThreadState_declare + __pyx_L20_error:; + __pyx_t_17 = 0; __pyx_t_18 = 0; __pyx_t_19 = 0; __pyx_t_20 = 0; __pyx_t_21 = 0; __pyx_t_22 = 0; + __Pyx_PyThreadState_assign + __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_XDECREF(__pyx_t_14); __pyx_t_14 = 0; + __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; + if (PY_MAJOR_VERSION >= 3) __Pyx_ExceptionSwap(&__pyx_t_20, &__pyx_t_21, &__pyx_t_22); + if ((PY_MAJOR_VERSION < 3) || unlikely(__Pyx_GetException(&__pyx_t_17, &__pyx_t_18, &__pyx_t_19) < 0)) __Pyx_ErrFetch(&__pyx_t_17, &__pyx_t_18, &__pyx_t_19); + __Pyx_XGOTREF(__pyx_t_17); + __Pyx_XGOTREF(__pyx_t_18); + __Pyx_XGOTREF(__pyx_t_19); + __Pyx_XGOTREF(__pyx_t_20); + __Pyx_XGOTREF(__pyx_t_21); + __Pyx_XGOTREF(__pyx_t_22); + __pyx_t_9 = __pyx_lineno; __pyx_t_15 = __pyx_clineno; __pyx_t_16 = __pyx_filename; + { + __Pyx_DECREF(__pyx_v_ex); + __pyx_v_ex = NULL; + } + __Pyx_PyThreadState_assign + if (PY_MAJOR_VERSION >= 3) { + __Pyx_XGIVEREF(__pyx_t_20); + __Pyx_XGIVEREF(__pyx_t_21); + __Pyx_XGIVEREF(__pyx_t_22); + __Pyx_ExceptionReset(__pyx_t_20, __pyx_t_21, __pyx_t_22); + } + __Pyx_XGIVEREF(__pyx_t_17); + __Pyx_XGIVEREF(__pyx_t_18); + __Pyx_XGIVEREF(__pyx_t_19); + __Pyx_ErrRestore(__pyx_t_17, __pyx_t_18, __pyx_t_19); + __pyx_t_17 = 0; __pyx_t_18 = 0; __pyx_t_19 = 0; __pyx_t_20 = 0; __pyx_t_21 = 0; __pyx_t_22 = 0; + __pyx_lineno = __pyx_t_9; __pyx_clineno = __pyx_t_15; __pyx_filename = __pyx_t_16; + goto __pyx_L9_except_error; + } + __pyx_L21:; + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; + goto __pyx_L8_exception_handled; + } + goto __pyx_L9_except_error; + __pyx_L9_except_error:; + + /* "asyncpg/protocol/coreproto.pyx":742 + * socket.TCP_NODELAY, 1) + * + * try: # <<<<<<<<<<<<<< + * self._connect() + * except Exception as ex: + */ + __Pyx_PyThreadState_assign + __Pyx_XGIVEREF(__pyx_t_11); + __Pyx_XGIVEREF(__pyx_t_12); + __Pyx_XGIVEREF(__pyx_t_13); + __Pyx_ExceptionReset(__pyx_t_11, __pyx_t_12, __pyx_t_13); + goto __pyx_L1_error; + __pyx_L8_exception_handled:; + __Pyx_PyThreadState_assign + __Pyx_XGIVEREF(__pyx_t_11); + __Pyx_XGIVEREF(__pyx_t_12); + __Pyx_XGIVEREF(__pyx_t_13); + __Pyx_ExceptionReset(__pyx_t_11, __pyx_t_12, __pyx_t_13); + __pyx_L14_try_end:; + } + + /* "asyncpg/protocol/coreproto.pyx":732 + * self._read_server_messages() + * + * def connection_made(self, transport): # <<<<<<<<<<<<<< + * self.transport = transport + * + */ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_6); + __Pyx_XDECREF(__pyx_t_7); + __Pyx_XDECREF(__pyx_t_8); + __Pyx_XDECREF(__pyx_t_10); + __Pyx_XDECREF(__pyx_t_14); + __Pyx_AddTraceback("asyncpg.protocol.protocol.CoreProtocol.connection_made", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XDECREF(__pyx_v_sock); + __Pyx_XDECREF(__pyx_v_ex); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "asyncpg/protocol/coreproto.pyx":750 + * self._on_error(ex) + * + * def connection_lost(self, exc): # <<<<<<<<<<<<<< + * self.con_status = CONNECTION_BAD + * self._set_state(PROTOCOL_FAILED) + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_7asyncpg_8protocol_8protocol_12CoreProtocol_7connection_lost(PyObject *__pyx_v_self, PyObject *__pyx_v_exc); /*proto*/ +static PyObject *__pyx_pw_7asyncpg_8protocol_8protocol_12CoreProtocol_7connection_lost(PyObject *__pyx_v_self, PyObject *__pyx_v_exc) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("connection_lost (wrapper)", 0); + __pyx_r = __pyx_pf_7asyncpg_8protocol_8protocol_12CoreProtocol_6connection_lost(((struct __pyx_obj_7asyncpg_8protocol_8protocol_CoreProtocol *)__pyx_v_self), ((PyObject *)__pyx_v_exc)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_7asyncpg_8protocol_8protocol_12CoreProtocol_6connection_lost(struct __pyx_obj_7asyncpg_8protocol_8protocol_CoreProtocol *__pyx_v_self, PyObject *__pyx_v_exc) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + __Pyx_RefNannySetupContext("connection_lost", 0); + + /* "asyncpg/protocol/coreproto.pyx":751 + * + * def connection_lost(self, exc): + * self.con_status = CONNECTION_BAD # <<<<<<<<<<<<<< + * self._set_state(PROTOCOL_FAILED) + * self._on_connection_lost(exc) + */ + __pyx_v_self->con_status = __pyx_e_7asyncpg_8protocol_8protocol_CONNECTION_BAD; + + /* "asyncpg/protocol/coreproto.pyx":752 + * def connection_lost(self, exc): + * self.con_status = CONNECTION_BAD + * self._set_state(PROTOCOL_FAILED) # <<<<<<<<<<<<<< + * self._on_connection_lost(exc) + * + */ + __pyx_t_1 = ((struct __pyx_vtabstruct_7asyncpg_8protocol_8protocol_CoreProtocol *)__pyx_v_self->__pyx_vtab)->_set_state(__pyx_v_self, __pyx_e_7asyncpg_8protocol_8protocol_PROTOCOL_FAILED); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 752, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "asyncpg/protocol/coreproto.pyx":753 + * self.con_status = CONNECTION_BAD + * self._set_state(PROTOCOL_FAILED) + * self._on_connection_lost(exc) # <<<<<<<<<<<<<< + * + * + */ + __pyx_t_1 = ((struct __pyx_vtabstruct_7asyncpg_8protocol_8protocol_CoreProtocol *)__pyx_v_self->__pyx_vtab)->_on_connection_lost(__pyx_v_self, __pyx_v_exc); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 753, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "asyncpg/protocol/coreproto.pyx":750 + * self._on_error(ex) + * + * def connection_lost(self, exc): # <<<<<<<<<<<<<< + * self.con_status = CONNECTION_BAD + * self._set_state(PROTOCOL_FAILED) + */ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("asyncpg.protocol.protocol.CoreProtocol.connection_lost", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "asyncpg/protocol/coreproto.pxd":89 + * dict con_args + * + * readonly int32_t backend_pid # <<<<<<<<<<<<<< + * readonly int32_t backend_secret + * + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_7asyncpg_8protocol_8protocol_12CoreProtocol_11backend_pid_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_7asyncpg_8protocol_8protocol_12CoreProtocol_11backend_pid_1__get__(PyObject *__pyx_v_self) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_r = __pyx_pf_7asyncpg_8protocol_8protocol_12CoreProtocol_11backend_pid___get__(((struct __pyx_obj_7asyncpg_8protocol_8protocol_CoreProtocol *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_7asyncpg_8protocol_8protocol_12CoreProtocol_11backend_pid___get__(struct __pyx_obj_7asyncpg_8protocol_8protocol_CoreProtocol *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + __Pyx_RefNannySetupContext("__get__", 0); + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyInt_From_int32_t(__pyx_v_self->backend_pid); if (unlikely(!__pyx_t_1)) __PYX_ERR(24, 89, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("asyncpg.protocol.protocol.CoreProtocol.backend_pid.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "asyncpg/protocol/coreproto.pxd":90 + * + * readonly int32_t backend_pid + * readonly int32_t backend_secret # <<<<<<<<<<<<<< + * + * ## Result + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_7asyncpg_8protocol_8protocol_12CoreProtocol_14backend_secret_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_7asyncpg_8protocol_8protocol_12CoreProtocol_14backend_secret_1__get__(PyObject *__pyx_v_self) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_r = __pyx_pf_7asyncpg_8protocol_8protocol_12CoreProtocol_14backend_secret___get__(((struct __pyx_obj_7asyncpg_8protocol_8protocol_CoreProtocol *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_7asyncpg_8protocol_8protocol_12CoreProtocol_14backend_secret___get__(struct __pyx_obj_7asyncpg_8protocol_8protocol_CoreProtocol *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + __Pyx_RefNannySetupContext("__get__", 0); + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyInt_From_int32_t(__pyx_v_self->backend_secret); if (unlikely(!__pyx_t_1)) __PYX_ERR(24, 90, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("asyncpg.protocol.protocol.CoreProtocol.backend_secret.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "asyncpg/protocol/prepared_stmt.pyx":11 + * cdef class PreparedStatementState: + * + * def __cinit__(self, str name, str query, BaseProtocol protocol): # <<<<<<<<<<<<<< + * self.name = name + * self.query = query + */ + +/* Python wrapper */ +static int __pyx_pw_7asyncpg_8protocol_8protocol_22PreparedStatementState_1__cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ +static int __pyx_pw_7asyncpg_8protocol_8protocol_22PreparedStatementState_1__cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { + PyObject *__pyx_v_name = 0; + PyObject *__pyx_v_query = 0; + struct __pyx_obj_7asyncpg_8protocol_8protocol_BaseProtocol *__pyx_v_protocol = 0; + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__cinit__ (wrapper)", 0); + { + static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_name,&__pyx_n_s_query,&__pyx_n_s_protocol,0}; + PyObject* values[3] = {0,0,0}; + if (unlikely(__pyx_kwds)) { + Py_ssize_t kw_args; + const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args); + switch (pos_args) { + case 3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2); + case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); + case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = PyDict_Size(__pyx_kwds); + switch (pos_args) { + case 0: + if (likely((values[0] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_name)) != 0)) kw_args--; + else goto __pyx_L5_argtuple_error; + case 1: + if (likely((values[1] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_query)) != 0)) kw_args--; + else { + __Pyx_RaiseArgtupleInvalid("__cinit__", 1, 3, 3, 1); __PYX_ERR(25, 11, __pyx_L3_error) + } + case 2: + if (likely((values[2] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_protocol)) != 0)) kw_args--; + else { + __Pyx_RaiseArgtupleInvalid("__cinit__", 1, 3, 3, 2); __PYX_ERR(25, 11, __pyx_L3_error) + } + } + if (unlikely(kw_args > 0)) { + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "__cinit__") < 0)) __PYX_ERR(25, 11, __pyx_L3_error) + } + } else if (PyTuple_GET_SIZE(__pyx_args) != 3) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + values[1] = PyTuple_GET_ITEM(__pyx_args, 1); + values[2] = PyTuple_GET_ITEM(__pyx_args, 2); + } + __pyx_v_name = ((PyObject*)values[0]); + __pyx_v_query = ((PyObject*)values[1]); + __pyx_v_protocol = ((struct __pyx_obj_7asyncpg_8protocol_8protocol_BaseProtocol *)values[2]); + } + goto __pyx_L4_argument_unpacking_done; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("__cinit__", 1, 3, 3, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(25, 11, __pyx_L3_error) + __pyx_L3_error:; + __Pyx_AddTraceback("asyncpg.protocol.protocol.PreparedStatementState.__cinit__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return -1; + __pyx_L4_argument_unpacking_done:; + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_name), (&PyUnicode_Type), 1, "name", 1))) __PYX_ERR(25, 11, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_query), (&PyUnicode_Type), 1, "query", 1))) __PYX_ERR(25, 11, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_protocol), __pyx_ptype_7asyncpg_8protocol_8protocol_BaseProtocol, 1, "protocol", 0))) __PYX_ERR(25, 11, __pyx_L1_error) + __pyx_r = __pyx_pf_7asyncpg_8protocol_8protocol_22PreparedStatementState___cinit__(((struct __pyx_obj_7asyncpg_8protocol_8protocol_PreparedStatementState *)__pyx_v_self), __pyx_v_name, __pyx_v_query, __pyx_v_protocol); + + /* function exit code */ + goto __pyx_L0; + __pyx_L1_error:; + __pyx_r = -1; + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_7asyncpg_8protocol_8protocol_22PreparedStatementState___cinit__(struct __pyx_obj_7asyncpg_8protocol_8protocol_PreparedStatementState *__pyx_v_self, PyObject *__pyx_v_name, PyObject *__pyx_v_query, struct __pyx_obj_7asyncpg_8protocol_8protocol_BaseProtocol *__pyx_v_protocol) { + int __pyx_r; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + __Pyx_RefNannySetupContext("__cinit__", 0); + + /* "asyncpg/protocol/prepared_stmt.pyx":12 + * + * def __cinit__(self, str name, str query, BaseProtocol protocol): + * self.name = name # <<<<<<<<<<<<<< + * self.query = query + * self.protocol = protocol + */ + __Pyx_INCREF(__pyx_v_name); + __Pyx_GIVEREF(__pyx_v_name); + __Pyx_GOTREF(__pyx_v_self->name); + __Pyx_DECREF(__pyx_v_self->name); + __pyx_v_self->name = __pyx_v_name; + + /* "asyncpg/protocol/prepared_stmt.pyx":13 + * def __cinit__(self, str name, str query, BaseProtocol protocol): + * self.name = name + * self.query = query # <<<<<<<<<<<<<< + * self.protocol = protocol + * self.settings = protocol.settings + */ + __Pyx_INCREF(__pyx_v_query); + __Pyx_GIVEREF(__pyx_v_query); + __Pyx_GOTREF(__pyx_v_self->query); + __Pyx_DECREF(__pyx_v_self->query); + __pyx_v_self->query = __pyx_v_query; + + /* "asyncpg/protocol/prepared_stmt.pyx":14 + * self.name = name + * self.query = query + * self.protocol = protocol # <<<<<<<<<<<<<< + * self.settings = protocol.settings + * self.row_desc = self.parameters_desc = None + */ + __Pyx_INCREF(((PyObject *)__pyx_v_protocol)); + __Pyx_GIVEREF(((PyObject *)__pyx_v_protocol)); + __Pyx_GOTREF(__pyx_v_self->protocol); + __Pyx_DECREF(((PyObject *)__pyx_v_self->protocol)); + __pyx_v_self->protocol = __pyx_v_protocol; + + /* "asyncpg/protocol/prepared_stmt.pyx":15 + * self.query = query + * self.protocol = protocol + * self.settings = protocol.settings # <<<<<<<<<<<<<< + * self.row_desc = self.parameters_desc = None + * self.args_codecs = self.rows_codecs = None + */ + __pyx_t_1 = ((PyObject *)__pyx_v_protocol->settings); + __Pyx_INCREF(__pyx_t_1); + __Pyx_GIVEREF(__pyx_t_1); + __Pyx_GOTREF(__pyx_v_self->settings); + __Pyx_DECREF(((PyObject *)__pyx_v_self->settings)); + __pyx_v_self->settings = ((struct __pyx_obj_7asyncpg_8protocol_8protocol_ConnectionSettings *)__pyx_t_1); + __pyx_t_1 = 0; + + /* "asyncpg/protocol/prepared_stmt.pyx":16 + * self.protocol = protocol + * self.settings = protocol.settings + * self.row_desc = self.parameters_desc = None # <<<<<<<<<<<<<< + * self.args_codecs = self.rows_codecs = None + * self.args_num = self.cols_num = 0 + */ + __Pyx_INCREF(Py_None); + __Pyx_GIVEREF(Py_None); + __Pyx_GOTREF(__pyx_v_self->row_desc); + __Pyx_DECREF(__pyx_v_self->row_desc); + __pyx_v_self->row_desc = ((PyObject*)Py_None); + __Pyx_INCREF(Py_None); + __Pyx_GIVEREF(Py_None); + __Pyx_GOTREF(__pyx_v_self->parameters_desc); + __Pyx_DECREF(__pyx_v_self->parameters_desc); + __pyx_v_self->parameters_desc = ((PyObject*)Py_None); + + /* "asyncpg/protocol/prepared_stmt.pyx":17 + * self.settings = protocol.settings + * self.row_desc = self.parameters_desc = None + * self.args_codecs = self.rows_codecs = None # <<<<<<<<<<<<<< + * self.args_num = self.cols_num = 0 + * self.cols_desc = None + */ + __Pyx_INCREF(Py_None); + __Pyx_GIVEREF(Py_None); + __Pyx_GOTREF(__pyx_v_self->args_codecs); + __Pyx_DECREF(__pyx_v_self->args_codecs); + __pyx_v_self->args_codecs = ((PyObject*)Py_None); + __Pyx_INCREF(Py_None); + __Pyx_GIVEREF(Py_None); + __Pyx_GOTREF(__pyx_v_self->rows_codecs); + __Pyx_DECREF(__pyx_v_self->rows_codecs); + __pyx_v_self->rows_codecs = ((PyObject*)Py_None); + + /* "asyncpg/protocol/prepared_stmt.pyx":18 + * self.row_desc = self.parameters_desc = None + * self.args_codecs = self.rows_codecs = None + * self.args_num = self.cols_num = 0 # <<<<<<<<<<<<<< + * self.cols_desc = None + * self.closed = False + */ + __pyx_v_self->args_num = 0; + __pyx_v_self->cols_num = 0; + + /* "asyncpg/protocol/prepared_stmt.pyx":19 + * self.args_codecs = self.rows_codecs = None + * self.args_num = self.cols_num = 0 + * self.cols_desc = None # <<<<<<<<<<<<<< + * self.closed = False + * self.refs = 0 + */ + __Pyx_INCREF(Py_None); + __Pyx_GIVEREF(Py_None); + __Pyx_GOTREF(__pyx_v_self->cols_desc); + __Pyx_DECREF(__pyx_v_self->cols_desc); + __pyx_v_self->cols_desc = Py_None; + + /* "asyncpg/protocol/prepared_stmt.pyx":20 + * self.args_num = self.cols_num = 0 + * self.cols_desc = None + * self.closed = False # <<<<<<<<<<<<<< + * self.refs = 0 + * self.buffer = FastReadBuffer.new() + */ + __pyx_v_self->closed = 0; + + /* "asyncpg/protocol/prepared_stmt.pyx":21 + * self.cols_desc = None + * self.closed = False + * self.refs = 0 # <<<<<<<<<<<<<< + * self.buffer = FastReadBuffer.new() + * + */ + __pyx_v_self->refs = 0; + + /* "asyncpg/protocol/prepared_stmt.pyx":22 + * self.closed = False + * self.refs = 0 + * self.buffer = FastReadBuffer.new() # <<<<<<<<<<<<<< + * + * def _get_parameters(self): + */ + __pyx_t_1 = ((PyObject *)__pyx_f_7asyncpg_8protocol_8protocol_14FastReadBuffer_new()); if (unlikely(!__pyx_t_1)) __PYX_ERR(25, 22, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_GIVEREF(__pyx_t_1); + __Pyx_GOTREF(__pyx_v_self->buffer); + __Pyx_DECREF(((PyObject *)__pyx_v_self->buffer)); + __pyx_v_self->buffer = ((struct __pyx_obj_7asyncpg_8protocol_8protocol_FastReadBuffer *)__pyx_t_1); + __pyx_t_1 = 0; + + /* "asyncpg/protocol/prepared_stmt.pyx":11 + * cdef class PreparedStatementState: + * + * def __cinit__(self, str name, str query, BaseProtocol protocol): # <<<<<<<<<<<<<< + * self.name = name + * self.query = query + */ + + /* function exit code */ + __pyx_r = 0; + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("asyncpg.protocol.protocol.PreparedStatementState.__cinit__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = -1; + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "asyncpg/protocol/prepared_stmt.pyx":24 + * self.buffer = FastReadBuffer.new() + * + * def _get_parameters(self): # <<<<<<<<<<<<<< + * cdef Codec codec + * + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_7asyncpg_8protocol_8protocol_22PreparedStatementState_3_get_parameters(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/ +static PyObject *__pyx_pw_7asyncpg_8protocol_8protocol_22PreparedStatementState_3_get_parameters(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("_get_parameters (wrapper)", 0); + __pyx_r = __pyx_pf_7asyncpg_8protocol_8protocol_22PreparedStatementState_2_get_parameters(((struct __pyx_obj_7asyncpg_8protocol_8protocol_PreparedStatementState *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_7asyncpg_8protocol_8protocol_22PreparedStatementState_2_get_parameters(struct __pyx_obj_7asyncpg_8protocol_8protocol_PreparedStatementState *__pyx_v_self) { + struct __pyx_obj_7asyncpg_8protocol_8protocol_Codec *__pyx_v_codec = 0; + PyObject *__pyx_v_result = NULL; + PyObject *__pyx_v_oid = NULL; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + Py_ssize_t __pyx_t_2; + PyObject *__pyx_t_3 = NULL; + uint32_t __pyx_t_4; + int __pyx_t_5; + int __pyx_t_6; + PyObject *__pyx_t_7 = NULL; + PyObject *__pyx_t_8 = NULL; + int __pyx_t_9; + PyObject *__pyx_t_10 = NULL; + int __pyx_t_11; + __Pyx_RefNannySetupContext("_get_parameters", 0); + + /* "asyncpg/protocol/prepared_stmt.pyx":27 + * cdef Codec codec + * + * result = [] # <<<<<<<<<<<<<< + * for oid in self.parameters_desc: + * codec = self.settings.get_data_codec(oid) + */ + __pyx_t_1 = PyList_New(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(25, 27, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_v_result = ((PyObject*)__pyx_t_1); + __pyx_t_1 = 0; + + /* "asyncpg/protocol/prepared_stmt.pyx":28 + * + * result = [] + * for oid in self.parameters_desc: # <<<<<<<<<<<<<< + * codec = self.settings.get_data_codec(oid) + * if codec is None: + */ + if (unlikely(__pyx_v_self->parameters_desc == Py_None)) { + PyErr_SetString(PyExc_TypeError, "'NoneType' object is not iterable"); + __PYX_ERR(25, 28, __pyx_L1_error) + } + __pyx_t_1 = __pyx_v_self->parameters_desc; __Pyx_INCREF(__pyx_t_1); __pyx_t_2 = 0; + for (;;) { + if (__pyx_t_2 >= PyList_GET_SIZE(__pyx_t_1)) break; + #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + __pyx_t_3 = PyList_GET_ITEM(__pyx_t_1, __pyx_t_2); __Pyx_INCREF(__pyx_t_3); __pyx_t_2++; if (unlikely(0 < 0)) __PYX_ERR(25, 28, __pyx_L1_error) + #else + __pyx_t_3 = PySequence_ITEM(__pyx_t_1, __pyx_t_2); __pyx_t_2++; if (unlikely(!__pyx_t_3)) __PYX_ERR(25, 28, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + #endif + __Pyx_XDECREF_SET(__pyx_v_oid, __pyx_t_3); + __pyx_t_3 = 0; + + /* "asyncpg/protocol/prepared_stmt.pyx":29 + * result = [] + * for oid in self.parameters_desc: + * codec = self.settings.get_data_codec(oid) # <<<<<<<<<<<<<< + * if codec is None: + * raise RuntimeError + */ + __pyx_t_4 = __Pyx_PyInt_As_uint32_t(__pyx_v_oid); if (unlikely((__pyx_t_4 == ((uint32_t)-1)) && PyErr_Occurred())) __PYX_ERR(25, 29, __pyx_L1_error) + __pyx_t_3 = ((PyObject *)__pyx_f_7asyncpg_8protocol_8protocol_18ConnectionSettings_get_data_codec(__pyx_v_self->settings, __pyx_t_4, 0, NULL)); if (unlikely(!__pyx_t_3)) __PYX_ERR(25, 29, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_XDECREF_SET(__pyx_v_codec, ((struct __pyx_obj_7asyncpg_8protocol_8protocol_Codec *)__pyx_t_3)); + __pyx_t_3 = 0; + + /* "asyncpg/protocol/prepared_stmt.pyx":30 + * for oid in self.parameters_desc: + * codec = self.settings.get_data_codec(oid) + * if codec is None: # <<<<<<<<<<<<<< + * raise RuntimeError + * result.append(apg_types.Type( + */ + __pyx_t_5 = (((PyObject *)__pyx_v_codec) == Py_None); + __pyx_t_6 = (__pyx_t_5 != 0); + if (__pyx_t_6) { + + /* "asyncpg/protocol/prepared_stmt.pyx":31 + * codec = self.settings.get_data_codec(oid) + * if codec is None: + * raise RuntimeError # <<<<<<<<<<<<<< + * result.append(apg_types.Type( + * oid, codec.name, codec.kind, codec.schema)) + */ + __Pyx_Raise(__pyx_builtin_RuntimeError, 0, 0, 0); + __PYX_ERR(25, 31, __pyx_L1_error) + + /* "asyncpg/protocol/prepared_stmt.pyx":30 + * for oid in self.parameters_desc: + * codec = self.settings.get_data_codec(oid) + * if codec is None: # <<<<<<<<<<<<<< + * raise RuntimeError + * result.append(apg_types.Type( + */ + } + + /* "asyncpg/protocol/prepared_stmt.pyx":32 + * if codec is None: + * raise RuntimeError + * result.append(apg_types.Type( # <<<<<<<<<<<<<< + * oid, codec.name, codec.kind, codec.schema)) + * + */ + __pyx_t_7 = __Pyx_GetModuleGlobalName(__pyx_n_s_apg_types); if (unlikely(!__pyx_t_7)) __PYX_ERR(25, 32, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __pyx_t_8 = __Pyx_PyObject_GetAttrStr(__pyx_t_7, __pyx_n_s_Type); if (unlikely(!__pyx_t_8)) __PYX_ERR(25, 32, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + + /* "asyncpg/protocol/prepared_stmt.pyx":33 + * raise RuntimeError + * result.append(apg_types.Type( + * oid, codec.name, codec.kind, codec.schema)) # <<<<<<<<<<<<<< + * + * return tuple(result) + */ + __pyx_t_7 = NULL; + __pyx_t_9 = 0; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_8))) { + __pyx_t_7 = PyMethod_GET_SELF(__pyx_t_8); + if (likely(__pyx_t_7)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_8); + __Pyx_INCREF(__pyx_t_7); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_8, function); + __pyx_t_9 = 1; + } + } + #if CYTHON_FAST_PYCALL + if (PyFunction_Check(__pyx_t_8)) { + PyObject *__pyx_temp[5] = {__pyx_t_7, __pyx_v_oid, __pyx_v_codec->name, __pyx_v_codec->kind, __pyx_v_codec->schema}; + __pyx_t_3 = __Pyx_PyFunction_FastCall(__pyx_t_8, __pyx_temp+1-__pyx_t_9, 4+__pyx_t_9); if (unlikely(!__pyx_t_3)) __PYX_ERR(25, 32, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_GOTREF(__pyx_t_3); + } else + #endif + #if CYTHON_FAST_PYCCALL + if (__Pyx_PyFastCFunction_Check(__pyx_t_8)) { + PyObject *__pyx_temp[5] = {__pyx_t_7, __pyx_v_oid, __pyx_v_codec->name, __pyx_v_codec->kind, __pyx_v_codec->schema}; + __pyx_t_3 = __Pyx_PyCFunction_FastCall(__pyx_t_8, __pyx_temp+1-__pyx_t_9, 4+__pyx_t_9); if (unlikely(!__pyx_t_3)) __PYX_ERR(25, 32, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_GOTREF(__pyx_t_3); + } else + #endif + { + __pyx_t_10 = PyTuple_New(4+__pyx_t_9); if (unlikely(!__pyx_t_10)) __PYX_ERR(25, 32, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_10); + if (__pyx_t_7) { + __Pyx_GIVEREF(__pyx_t_7); PyTuple_SET_ITEM(__pyx_t_10, 0, __pyx_t_7); __pyx_t_7 = NULL; + } + __Pyx_INCREF(__pyx_v_oid); + __Pyx_GIVEREF(__pyx_v_oid); + PyTuple_SET_ITEM(__pyx_t_10, 0+__pyx_t_9, __pyx_v_oid); + __Pyx_INCREF(__pyx_v_codec->name); + __Pyx_GIVEREF(__pyx_v_codec->name); + PyTuple_SET_ITEM(__pyx_t_10, 1+__pyx_t_9, __pyx_v_codec->name); + __Pyx_INCREF(__pyx_v_codec->kind); + __Pyx_GIVEREF(__pyx_v_codec->kind); + PyTuple_SET_ITEM(__pyx_t_10, 2+__pyx_t_9, __pyx_v_codec->kind); + __Pyx_INCREF(__pyx_v_codec->schema); + __Pyx_GIVEREF(__pyx_v_codec->schema); + PyTuple_SET_ITEM(__pyx_t_10, 3+__pyx_t_9, __pyx_v_codec->schema); + __pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_8, __pyx_t_10, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(25, 32, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; + } + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + + /* "asyncpg/protocol/prepared_stmt.pyx":32 + * if codec is None: + * raise RuntimeError + * result.append(apg_types.Type( # <<<<<<<<<<<<<< + * oid, codec.name, codec.kind, codec.schema)) + * + */ + __pyx_t_11 = __Pyx_PyList_Append(__pyx_v_result, __pyx_t_3); if (unlikely(__pyx_t_11 == -1)) __PYX_ERR(25, 32, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + + /* "asyncpg/protocol/prepared_stmt.pyx":28 + * + * result = [] + * for oid in self.parameters_desc: # <<<<<<<<<<<<<< + * codec = self.settings.get_data_codec(oid) + * if codec is None: + */ + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "asyncpg/protocol/prepared_stmt.pyx":35 + * oid, codec.name, codec.kind, codec.schema)) + * + * return tuple(result) # <<<<<<<<<<<<<< + * + * def _get_attributes(self): + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = PyList_AsTuple(__pyx_v_result); if (unlikely(!__pyx_t_1)) __PYX_ERR(25, 35, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "asyncpg/protocol/prepared_stmt.pyx":24 + * self.buffer = FastReadBuffer.new() + * + * def _get_parameters(self): # <<<<<<<<<<<<<< + * cdef Codec codec + * + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_7); + __Pyx_XDECREF(__pyx_t_8); + __Pyx_XDECREF(__pyx_t_10); + __Pyx_AddTraceback("asyncpg.protocol.protocol.PreparedStatementState._get_parameters", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XDECREF((PyObject *)__pyx_v_codec); + __Pyx_XDECREF(__pyx_v_result); + __Pyx_XDECREF(__pyx_v_oid); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "asyncpg/protocol/prepared_stmt.pyx":37 + * return tuple(result) + * + * def _get_attributes(self): # <<<<<<<<<<<<<< + * cdef Codec codec + * + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_7asyncpg_8protocol_8protocol_22PreparedStatementState_5_get_attributes(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/ +static PyObject *__pyx_pw_7asyncpg_8protocol_8protocol_22PreparedStatementState_5_get_attributes(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("_get_attributes (wrapper)", 0); + __pyx_r = __pyx_pf_7asyncpg_8protocol_8protocol_22PreparedStatementState_4_get_attributes(((struct __pyx_obj_7asyncpg_8protocol_8protocol_PreparedStatementState *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_7asyncpg_8protocol_8protocol_22PreparedStatementState_4_get_attributes(struct __pyx_obj_7asyncpg_8protocol_8protocol_PreparedStatementState *__pyx_v_self) { + struct __pyx_obj_7asyncpg_8protocol_8protocol_Codec *__pyx_v_codec = 0; + PyObject *__pyx_v_result = NULL; + PyObject *__pyx_v_d = NULL; + PyObject *__pyx_v_name = NULL; + PyObject *__pyx_v_oid = NULL; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + Py_ssize_t __pyx_t_2; + PyObject *__pyx_t_3 = NULL; + uint32_t __pyx_t_4; + int __pyx_t_5; + int __pyx_t_6; + PyObject *__pyx_t_7 = NULL; + PyObject *__pyx_t_8 = NULL; + PyObject *__pyx_t_9 = NULL; + PyObject *__pyx_t_10 = NULL; + int __pyx_t_11; + PyObject *__pyx_t_12 = NULL; + int __pyx_t_13; + __Pyx_RefNannySetupContext("_get_attributes", 0); + + /* "asyncpg/protocol/prepared_stmt.pyx":40 + * cdef Codec codec + * + * result = [] # <<<<<<<<<<<<<< + * for d in self.row_desc: + * name = d[0] + */ + __pyx_t_1 = PyList_New(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(25, 40, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_v_result = ((PyObject*)__pyx_t_1); + __pyx_t_1 = 0; + + /* "asyncpg/protocol/prepared_stmt.pyx":41 + * + * result = [] + * for d in self.row_desc: # <<<<<<<<<<<<<< + * name = d[0] + * oid = d[3] + */ + if (unlikely(__pyx_v_self->row_desc == Py_None)) { + PyErr_SetString(PyExc_TypeError, "'NoneType' object is not iterable"); + __PYX_ERR(25, 41, __pyx_L1_error) + } + __pyx_t_1 = __pyx_v_self->row_desc; __Pyx_INCREF(__pyx_t_1); __pyx_t_2 = 0; + for (;;) { + if (__pyx_t_2 >= PyList_GET_SIZE(__pyx_t_1)) break; + #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + __pyx_t_3 = PyList_GET_ITEM(__pyx_t_1, __pyx_t_2); __Pyx_INCREF(__pyx_t_3); __pyx_t_2++; if (unlikely(0 < 0)) __PYX_ERR(25, 41, __pyx_L1_error) + #else + __pyx_t_3 = PySequence_ITEM(__pyx_t_1, __pyx_t_2); __pyx_t_2++; if (unlikely(!__pyx_t_3)) __PYX_ERR(25, 41, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + #endif + __Pyx_XDECREF_SET(__pyx_v_d, __pyx_t_3); + __pyx_t_3 = 0; + + /* "asyncpg/protocol/prepared_stmt.pyx":42 + * result = [] + * for d in self.row_desc: + * name = d[0] # <<<<<<<<<<<<<< + * oid = d[3] + * + */ + __pyx_t_3 = __Pyx_GetItemInt(__pyx_v_d, 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_3)) __PYX_ERR(25, 42, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_XDECREF_SET(__pyx_v_name, __pyx_t_3); + __pyx_t_3 = 0; + + /* "asyncpg/protocol/prepared_stmt.pyx":43 + * for d in self.row_desc: + * name = d[0] + * oid = d[3] # <<<<<<<<<<<<<< + * + * codec = self.settings.get_data_codec(oid) + */ + __pyx_t_3 = __Pyx_GetItemInt(__pyx_v_d, 3, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_3)) __PYX_ERR(25, 43, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_XDECREF_SET(__pyx_v_oid, __pyx_t_3); + __pyx_t_3 = 0; + + /* "asyncpg/protocol/prepared_stmt.pyx":45 + * oid = d[3] + * + * codec = self.settings.get_data_codec(oid) # <<<<<<<<<<<<<< + * if codec is None: + * raise RuntimeError + */ + __pyx_t_4 = __Pyx_PyInt_As_uint32_t(__pyx_v_oid); if (unlikely((__pyx_t_4 == ((uint32_t)-1)) && PyErr_Occurred())) __PYX_ERR(25, 45, __pyx_L1_error) + __pyx_t_3 = ((PyObject *)__pyx_f_7asyncpg_8protocol_8protocol_18ConnectionSettings_get_data_codec(__pyx_v_self->settings, __pyx_t_4, 0, NULL)); if (unlikely(!__pyx_t_3)) __PYX_ERR(25, 45, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_XDECREF_SET(__pyx_v_codec, ((struct __pyx_obj_7asyncpg_8protocol_8protocol_Codec *)__pyx_t_3)); + __pyx_t_3 = 0; + + /* "asyncpg/protocol/prepared_stmt.pyx":46 + * + * codec = self.settings.get_data_codec(oid) + * if codec is None: # <<<<<<<<<<<<<< + * raise RuntimeError + * + */ + __pyx_t_5 = (((PyObject *)__pyx_v_codec) == Py_None); + __pyx_t_6 = (__pyx_t_5 != 0); + if (__pyx_t_6) { + + /* "asyncpg/protocol/prepared_stmt.pyx":47 + * codec = self.settings.get_data_codec(oid) + * if codec is None: + * raise RuntimeError # <<<<<<<<<<<<<< + * + * name = name.decode(self.settings._encoding) + */ + __Pyx_Raise(__pyx_builtin_RuntimeError, 0, 0, 0); + __PYX_ERR(25, 47, __pyx_L1_error) + + /* "asyncpg/protocol/prepared_stmt.pyx":46 + * + * codec = self.settings.get_data_codec(oid) + * if codec is None: # <<<<<<<<<<<<<< + * raise RuntimeError + * + */ + } + + /* "asyncpg/protocol/prepared_stmt.pyx":49 + * raise RuntimeError + * + * name = name.decode(self.settings._encoding) # <<<<<<<<<<<<<< + * + * result.append( + */ + __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_v_name, __pyx_n_s_decode); if (unlikely(!__pyx_t_7)) __PYX_ERR(25, 49, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __pyx_t_8 = NULL; + if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_7))) { + __pyx_t_8 = PyMethod_GET_SELF(__pyx_t_7); + if (likely(__pyx_t_8)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_7); + __Pyx_INCREF(__pyx_t_8); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_7, function); + } + } + if (!__pyx_t_8) { + __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_t_7, __pyx_v_self->settings->_encoding); if (unlikely(!__pyx_t_3)) __PYX_ERR(25, 49, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + } else { + #if CYTHON_FAST_PYCALL + if (PyFunction_Check(__pyx_t_7)) { + PyObject *__pyx_temp[2] = {__pyx_t_8, __pyx_v_self->settings->_encoding}; + __pyx_t_3 = __Pyx_PyFunction_FastCall(__pyx_t_7, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_3)) __PYX_ERR(25, 49, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; + __Pyx_GOTREF(__pyx_t_3); + } else + #endif + #if CYTHON_FAST_PYCCALL + if (__Pyx_PyFastCFunction_Check(__pyx_t_7)) { + PyObject *__pyx_temp[2] = {__pyx_t_8, __pyx_v_self->settings->_encoding}; + __pyx_t_3 = __Pyx_PyCFunction_FastCall(__pyx_t_7, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_3)) __PYX_ERR(25, 49, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; + __Pyx_GOTREF(__pyx_t_3); + } else + #endif + { + __pyx_t_9 = PyTuple_New(1+1); if (unlikely(!__pyx_t_9)) __PYX_ERR(25, 49, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_9); + __Pyx_GIVEREF(__pyx_t_8); PyTuple_SET_ITEM(__pyx_t_9, 0, __pyx_t_8); __pyx_t_8 = NULL; + __Pyx_INCREF(__pyx_v_self->settings->_encoding); + __Pyx_GIVEREF(__pyx_v_self->settings->_encoding); + PyTuple_SET_ITEM(__pyx_t_9, 0+1, __pyx_v_self->settings->_encoding); + __pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_7, __pyx_t_9, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(25, 49, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + } + } + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_DECREF_SET(__pyx_v_name, __pyx_t_3); + __pyx_t_3 = 0; + + /* "asyncpg/protocol/prepared_stmt.pyx":52 + * + * result.append( + * apg_types.Attribute(name, # <<<<<<<<<<<<<< + * apg_types.Type(oid, codec.name, codec.kind, codec.schema))) + * + */ + __pyx_t_7 = __Pyx_GetModuleGlobalName(__pyx_n_s_apg_types); if (unlikely(!__pyx_t_7)) __PYX_ERR(25, 52, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __pyx_t_9 = __Pyx_PyObject_GetAttrStr(__pyx_t_7, __pyx_n_s_Attribute); if (unlikely(!__pyx_t_9)) __PYX_ERR(25, 52, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_9); + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + + /* "asyncpg/protocol/prepared_stmt.pyx":53 + * result.append( + * apg_types.Attribute(name, + * apg_types.Type(oid, codec.name, codec.kind, codec.schema))) # <<<<<<<<<<<<<< + * + * return tuple(result) + */ + __pyx_t_8 = __Pyx_GetModuleGlobalName(__pyx_n_s_apg_types); if (unlikely(!__pyx_t_8)) __PYX_ERR(25, 53, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __pyx_t_10 = __Pyx_PyObject_GetAttrStr(__pyx_t_8, __pyx_n_s_Type); if (unlikely(!__pyx_t_10)) __PYX_ERR(25, 53, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_10); + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + __pyx_t_8 = NULL; + __pyx_t_11 = 0; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_10))) { + __pyx_t_8 = PyMethod_GET_SELF(__pyx_t_10); + if (likely(__pyx_t_8)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_10); + __Pyx_INCREF(__pyx_t_8); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_10, function); + __pyx_t_11 = 1; + } + } + #if CYTHON_FAST_PYCALL + if (PyFunction_Check(__pyx_t_10)) { + PyObject *__pyx_temp[5] = {__pyx_t_8, __pyx_v_oid, __pyx_v_codec->name, __pyx_v_codec->kind, __pyx_v_codec->schema}; + __pyx_t_7 = __Pyx_PyFunction_FastCall(__pyx_t_10, __pyx_temp+1-__pyx_t_11, 4+__pyx_t_11); if (unlikely(!__pyx_t_7)) __PYX_ERR(25, 53, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; + __Pyx_GOTREF(__pyx_t_7); + } else + #endif + #if CYTHON_FAST_PYCCALL + if (__Pyx_PyFastCFunction_Check(__pyx_t_10)) { + PyObject *__pyx_temp[5] = {__pyx_t_8, __pyx_v_oid, __pyx_v_codec->name, __pyx_v_codec->kind, __pyx_v_codec->schema}; + __pyx_t_7 = __Pyx_PyCFunction_FastCall(__pyx_t_10, __pyx_temp+1-__pyx_t_11, 4+__pyx_t_11); if (unlikely(!__pyx_t_7)) __PYX_ERR(25, 53, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; + __Pyx_GOTREF(__pyx_t_7); + } else + #endif + { + __pyx_t_12 = PyTuple_New(4+__pyx_t_11); if (unlikely(!__pyx_t_12)) __PYX_ERR(25, 53, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_12); + if (__pyx_t_8) { + __Pyx_GIVEREF(__pyx_t_8); PyTuple_SET_ITEM(__pyx_t_12, 0, __pyx_t_8); __pyx_t_8 = NULL; + } + __Pyx_INCREF(__pyx_v_oid); + __Pyx_GIVEREF(__pyx_v_oid); + PyTuple_SET_ITEM(__pyx_t_12, 0+__pyx_t_11, __pyx_v_oid); + __Pyx_INCREF(__pyx_v_codec->name); + __Pyx_GIVEREF(__pyx_v_codec->name); + PyTuple_SET_ITEM(__pyx_t_12, 1+__pyx_t_11, __pyx_v_codec->name); + __Pyx_INCREF(__pyx_v_codec->kind); + __Pyx_GIVEREF(__pyx_v_codec->kind); + PyTuple_SET_ITEM(__pyx_t_12, 2+__pyx_t_11, __pyx_v_codec->kind); + __Pyx_INCREF(__pyx_v_codec->schema); + __Pyx_GIVEREF(__pyx_v_codec->schema); + PyTuple_SET_ITEM(__pyx_t_12, 3+__pyx_t_11, __pyx_v_codec->schema); + __pyx_t_7 = __Pyx_PyObject_Call(__pyx_t_10, __pyx_t_12, NULL); if (unlikely(!__pyx_t_7)) __PYX_ERR(25, 53, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0; + } + __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; + __pyx_t_10 = NULL; + __pyx_t_11 = 0; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_9))) { + __pyx_t_10 = PyMethod_GET_SELF(__pyx_t_9); + if (likely(__pyx_t_10)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_9); + __Pyx_INCREF(__pyx_t_10); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_9, function); + __pyx_t_11 = 1; + } + } + #if CYTHON_FAST_PYCALL + if (PyFunction_Check(__pyx_t_9)) { + PyObject *__pyx_temp[3] = {__pyx_t_10, __pyx_v_name, __pyx_t_7}; + __pyx_t_3 = __Pyx_PyFunction_FastCall(__pyx_t_9, __pyx_temp+1-__pyx_t_11, 2+__pyx_t_11); if (unlikely(!__pyx_t_3)) __PYX_ERR(25, 52, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_10); __pyx_t_10 = 0; + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + } else + #endif + #if CYTHON_FAST_PYCCALL + if (__Pyx_PyFastCFunction_Check(__pyx_t_9)) { + PyObject *__pyx_temp[3] = {__pyx_t_10, __pyx_v_name, __pyx_t_7}; + __pyx_t_3 = __Pyx_PyCFunction_FastCall(__pyx_t_9, __pyx_temp+1-__pyx_t_11, 2+__pyx_t_11); if (unlikely(!__pyx_t_3)) __PYX_ERR(25, 52, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_10); __pyx_t_10 = 0; + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + } else + #endif + { + __pyx_t_12 = PyTuple_New(2+__pyx_t_11); if (unlikely(!__pyx_t_12)) __PYX_ERR(25, 52, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_12); + if (__pyx_t_10) { + __Pyx_GIVEREF(__pyx_t_10); PyTuple_SET_ITEM(__pyx_t_12, 0, __pyx_t_10); __pyx_t_10 = NULL; + } + __Pyx_INCREF(__pyx_v_name); + __Pyx_GIVEREF(__pyx_v_name); + PyTuple_SET_ITEM(__pyx_t_12, 0+__pyx_t_11, __pyx_v_name); + __Pyx_GIVEREF(__pyx_t_7); + PyTuple_SET_ITEM(__pyx_t_12, 1+__pyx_t_11, __pyx_t_7); + __pyx_t_7 = 0; + __pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_9, __pyx_t_12, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(25, 52, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0; + } + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + + /* "asyncpg/protocol/prepared_stmt.pyx":51 + * name = name.decode(self.settings._encoding) + * + * result.append( # <<<<<<<<<<<<<< + * apg_types.Attribute(name, + * apg_types.Type(oid, codec.name, codec.kind, codec.schema))) + */ + __pyx_t_13 = __Pyx_PyList_Append(__pyx_v_result, __pyx_t_3); if (unlikely(__pyx_t_13 == -1)) __PYX_ERR(25, 51, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + + /* "asyncpg/protocol/prepared_stmt.pyx":41 + * + * result = [] + * for d in self.row_desc: # <<<<<<<<<<<<<< + * name = d[0] + * oid = d[3] + */ + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "asyncpg/protocol/prepared_stmt.pyx":55 + * apg_types.Type(oid, codec.name, codec.kind, codec.schema))) + * + * return tuple(result) # <<<<<<<<<<<<<< + * + * def _init_types(self): + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = PyList_AsTuple(__pyx_v_result); if (unlikely(!__pyx_t_1)) __PYX_ERR(25, 55, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "asyncpg/protocol/prepared_stmt.pyx":37 + * return tuple(result) + * + * def _get_attributes(self): # <<<<<<<<<<<<<< + * cdef Codec codec + * + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_7); + __Pyx_XDECREF(__pyx_t_8); + __Pyx_XDECREF(__pyx_t_9); + __Pyx_XDECREF(__pyx_t_10); + __Pyx_XDECREF(__pyx_t_12); + __Pyx_AddTraceback("asyncpg.protocol.protocol.PreparedStatementState._get_attributes", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XDECREF((PyObject *)__pyx_v_codec); + __Pyx_XDECREF(__pyx_v_result); + __Pyx_XDECREF(__pyx_v_d); + __Pyx_XDECREF(__pyx_v_name); + __Pyx_XDECREF(__pyx_v_oid); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "asyncpg/protocol/prepared_stmt.pyx":57 + * return tuple(result) + * + * def _init_types(self): # <<<<<<<<<<<<<< + * cdef: + * Codec codec + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_7asyncpg_8protocol_8protocol_22PreparedStatementState_7_init_types(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/ +static PyObject *__pyx_pw_7asyncpg_8protocol_8protocol_22PreparedStatementState_7_init_types(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("_init_types (wrapper)", 0); + __pyx_r = __pyx_pf_7asyncpg_8protocol_8protocol_22PreparedStatementState_6_init_types(((struct __pyx_obj_7asyncpg_8protocol_8protocol_PreparedStatementState *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_7asyncpg_8protocol_8protocol_22PreparedStatementState_6_init_types(struct __pyx_obj_7asyncpg_8protocol_8protocol_PreparedStatementState *__pyx_v_self) { + struct __pyx_obj_7asyncpg_8protocol_8protocol_Codec *__pyx_v_codec = 0; + PyObject *__pyx_v_result = 0; + PyObject *__pyx_v_p_oid = NULL; + PyObject *__pyx_v_rdesc = NULL; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_t_2; + Py_ssize_t __pyx_t_3; + PyObject *__pyx_t_4 = NULL; + uint32_t __pyx_t_5; + int __pyx_t_6; + int __pyx_t_7; + int __pyx_t_8; + __Pyx_RefNannySetupContext("_init_types", 0); + + /* "asyncpg/protocol/prepared_stmt.pyx":60 + * cdef: + * Codec codec + * set result = set() # <<<<<<<<<<<<<< + * + * if self.parameters_desc: + */ + __pyx_t_1 = PySet_New(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(25, 60, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_v_result = ((PyObject*)__pyx_t_1); + __pyx_t_1 = 0; + + /* "asyncpg/protocol/prepared_stmt.pyx":62 + * set result = set() + * + * if self.parameters_desc: # <<<<<<<<<<<<<< + * for p_oid in self.parameters_desc: + * codec = self.settings.get_data_codec(p_oid) + */ + __pyx_t_2 = (__pyx_v_self->parameters_desc != Py_None) && (PyList_GET_SIZE(__pyx_v_self->parameters_desc) != 0); + if (__pyx_t_2) { + + /* "asyncpg/protocol/prepared_stmt.pyx":63 + * + * if self.parameters_desc: + * for p_oid in self.parameters_desc: # <<<<<<<<<<<<<< + * codec = self.settings.get_data_codec(p_oid) + * if codec is None or not codec.has_encoder(): + */ + if (unlikely(__pyx_v_self->parameters_desc == Py_None)) { + PyErr_SetString(PyExc_TypeError, "'NoneType' object is not iterable"); + __PYX_ERR(25, 63, __pyx_L1_error) + } + __pyx_t_1 = __pyx_v_self->parameters_desc; __Pyx_INCREF(__pyx_t_1); __pyx_t_3 = 0; + for (;;) { + if (__pyx_t_3 >= PyList_GET_SIZE(__pyx_t_1)) break; + #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + __pyx_t_4 = PyList_GET_ITEM(__pyx_t_1, __pyx_t_3); __Pyx_INCREF(__pyx_t_4); __pyx_t_3++; if (unlikely(0 < 0)) __PYX_ERR(25, 63, __pyx_L1_error) + #else + __pyx_t_4 = PySequence_ITEM(__pyx_t_1, __pyx_t_3); __pyx_t_3++; if (unlikely(!__pyx_t_4)) __PYX_ERR(25, 63, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + #endif + __Pyx_XDECREF_SET(__pyx_v_p_oid, __pyx_t_4); + __pyx_t_4 = 0; + + /* "asyncpg/protocol/prepared_stmt.pyx":64 + * if self.parameters_desc: + * for p_oid in self.parameters_desc: + * codec = self.settings.get_data_codec(p_oid) # <<<<<<<<<<<<<< + * if codec is None or not codec.has_encoder(): + * result.add(p_oid) + */ + __pyx_t_5 = __Pyx_PyInt_As_uint32_t(__pyx_v_p_oid); if (unlikely((__pyx_t_5 == ((uint32_t)-1)) && PyErr_Occurred())) __PYX_ERR(25, 64, __pyx_L1_error) + __pyx_t_4 = ((PyObject *)__pyx_f_7asyncpg_8protocol_8protocol_18ConnectionSettings_get_data_codec(__pyx_v_self->settings, ((uint32_t)__pyx_t_5), 0, NULL)); if (unlikely(!__pyx_t_4)) __PYX_ERR(25, 64, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_XDECREF_SET(__pyx_v_codec, ((struct __pyx_obj_7asyncpg_8protocol_8protocol_Codec *)__pyx_t_4)); + __pyx_t_4 = 0; + + /* "asyncpg/protocol/prepared_stmt.pyx":65 + * for p_oid in self.parameters_desc: + * codec = self.settings.get_data_codec(p_oid) + * if codec is None or not codec.has_encoder(): # <<<<<<<<<<<<<< + * result.add(p_oid) + * + */ + __pyx_t_6 = (((PyObject *)__pyx_v_codec) == Py_None); + __pyx_t_7 = (__pyx_t_6 != 0); + if (!__pyx_t_7) { + } else { + __pyx_t_2 = __pyx_t_7; + goto __pyx_L7_bool_binop_done; + } + __pyx_t_4 = __pyx_f_7asyncpg_8protocol_8protocol_5Codec_has_encoder(__pyx_v_codec); if (unlikely(!__pyx_t_4)) __PYX_ERR(25, 65, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_7 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_7 < 0)) __PYX_ERR(25, 65, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_6 = ((!__pyx_t_7) != 0); + __pyx_t_2 = __pyx_t_6; + __pyx_L7_bool_binop_done:; + if (__pyx_t_2) { + + /* "asyncpg/protocol/prepared_stmt.pyx":66 + * codec = self.settings.get_data_codec(p_oid) + * if codec is None or not codec.has_encoder(): + * result.add(p_oid) # <<<<<<<<<<<<<< + * + * if self.row_desc: + */ + __pyx_t_8 = PySet_Add(__pyx_v_result, __pyx_v_p_oid); if (unlikely(__pyx_t_8 == -1)) __PYX_ERR(25, 66, __pyx_L1_error) + + /* "asyncpg/protocol/prepared_stmt.pyx":65 + * for p_oid in self.parameters_desc: + * codec = self.settings.get_data_codec(p_oid) + * if codec is None or not codec.has_encoder(): # <<<<<<<<<<<<<< + * result.add(p_oid) + * + */ + } + + /* "asyncpg/protocol/prepared_stmt.pyx":63 + * + * if self.parameters_desc: + * for p_oid in self.parameters_desc: # <<<<<<<<<<<<<< + * codec = self.settings.get_data_codec(p_oid) + * if codec is None or not codec.has_encoder(): + */ + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "asyncpg/protocol/prepared_stmt.pyx":62 + * set result = set() + * + * if self.parameters_desc: # <<<<<<<<<<<<<< + * for p_oid in self.parameters_desc: + * codec = self.settings.get_data_codec(p_oid) + */ + } + + /* "asyncpg/protocol/prepared_stmt.pyx":68 + * result.add(p_oid) + * + * if self.row_desc: # <<<<<<<<<<<<<< + * for rdesc in self.row_desc: + * codec = self.settings.get_data_codec((rdesc[3])) + */ + __pyx_t_2 = (__pyx_v_self->row_desc != Py_None) && (PyList_GET_SIZE(__pyx_v_self->row_desc) != 0); + if (__pyx_t_2) { + + /* "asyncpg/protocol/prepared_stmt.pyx":69 + * + * if self.row_desc: + * for rdesc in self.row_desc: # <<<<<<<<<<<<<< + * codec = self.settings.get_data_codec((rdesc[3])) + * if codec is None or not codec.has_decoder(): + */ + if (unlikely(__pyx_v_self->row_desc == Py_None)) { + PyErr_SetString(PyExc_TypeError, "'NoneType' object is not iterable"); + __PYX_ERR(25, 69, __pyx_L1_error) + } + __pyx_t_1 = __pyx_v_self->row_desc; __Pyx_INCREF(__pyx_t_1); __pyx_t_3 = 0; + for (;;) { + if (__pyx_t_3 >= PyList_GET_SIZE(__pyx_t_1)) break; + #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + __pyx_t_4 = PyList_GET_ITEM(__pyx_t_1, __pyx_t_3); __Pyx_INCREF(__pyx_t_4); __pyx_t_3++; if (unlikely(0 < 0)) __PYX_ERR(25, 69, __pyx_L1_error) + #else + __pyx_t_4 = PySequence_ITEM(__pyx_t_1, __pyx_t_3); __pyx_t_3++; if (unlikely(!__pyx_t_4)) __PYX_ERR(25, 69, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + #endif + __Pyx_XDECREF_SET(__pyx_v_rdesc, __pyx_t_4); + __pyx_t_4 = 0; + + /* "asyncpg/protocol/prepared_stmt.pyx":70 + * if self.row_desc: + * for rdesc in self.row_desc: + * codec = self.settings.get_data_codec((rdesc[3])) # <<<<<<<<<<<<<< + * if codec is None or not codec.has_decoder(): + * result.add(rdesc[3]) + */ + __pyx_t_4 = __Pyx_GetItemInt(__pyx_v_rdesc, 3, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_4)) __PYX_ERR(25, 70, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_5 = __Pyx_PyInt_As_uint32_t(__pyx_t_4); if (unlikely((__pyx_t_5 == ((uint32_t)-1)) && PyErr_Occurred())) __PYX_ERR(25, 70, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_4 = ((PyObject *)__pyx_f_7asyncpg_8protocol_8protocol_18ConnectionSettings_get_data_codec(__pyx_v_self->settings, ((uint32_t)__pyx_t_5), 0, NULL)); if (unlikely(!__pyx_t_4)) __PYX_ERR(25, 70, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_XDECREF_SET(__pyx_v_codec, ((struct __pyx_obj_7asyncpg_8protocol_8protocol_Codec *)__pyx_t_4)); + __pyx_t_4 = 0; + + /* "asyncpg/protocol/prepared_stmt.pyx":71 + * for rdesc in self.row_desc: + * codec = self.settings.get_data_codec((rdesc[3])) + * if codec is None or not codec.has_decoder(): # <<<<<<<<<<<<<< + * result.add(rdesc[3]) + * + */ + __pyx_t_6 = (((PyObject *)__pyx_v_codec) == Py_None); + __pyx_t_7 = (__pyx_t_6 != 0); + if (!__pyx_t_7) { + } else { + __pyx_t_2 = __pyx_t_7; + goto __pyx_L13_bool_binop_done; + } + __pyx_t_4 = __pyx_f_7asyncpg_8protocol_8protocol_5Codec_has_decoder(__pyx_v_codec); if (unlikely(!__pyx_t_4)) __PYX_ERR(25, 71, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_7 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_7 < 0)) __PYX_ERR(25, 71, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_6 = ((!__pyx_t_7) != 0); + __pyx_t_2 = __pyx_t_6; + __pyx_L13_bool_binop_done:; + if (__pyx_t_2) { + + /* "asyncpg/protocol/prepared_stmt.pyx":72 + * codec = self.settings.get_data_codec((rdesc[3])) + * if codec is None or not codec.has_decoder(): + * result.add(rdesc[3]) # <<<<<<<<<<<<<< + * + * if len(result): + */ + __pyx_t_4 = __Pyx_GetItemInt(__pyx_v_rdesc, 3, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_4)) __PYX_ERR(25, 72, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_8 = PySet_Add(__pyx_v_result, __pyx_t_4); if (unlikely(__pyx_t_8 == -1)) __PYX_ERR(25, 72, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + + /* "asyncpg/protocol/prepared_stmt.pyx":71 + * for rdesc in self.row_desc: + * codec = self.settings.get_data_codec((rdesc[3])) + * if codec is None or not codec.has_decoder(): # <<<<<<<<<<<<<< + * result.add(rdesc[3]) + * + */ + } + + /* "asyncpg/protocol/prepared_stmt.pyx":69 + * + * if self.row_desc: + * for rdesc in self.row_desc: # <<<<<<<<<<<<<< + * codec = self.settings.get_data_codec((rdesc[3])) + * if codec is None or not codec.has_decoder(): + */ + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "asyncpg/protocol/prepared_stmt.pyx":68 + * result.add(p_oid) + * + * if self.row_desc: # <<<<<<<<<<<<<< + * for rdesc in self.row_desc: + * codec = self.settings.get_data_codec((rdesc[3])) + */ + } + + /* "asyncpg/protocol/prepared_stmt.pyx":74 + * result.add(rdesc[3]) + * + * if len(result): # <<<<<<<<<<<<<< + * return result + * else: + */ + __pyx_t_3 = PySet_GET_SIZE(__pyx_v_result); if (unlikely(__pyx_t_3 == -1)) __PYX_ERR(25, 74, __pyx_L1_error) + __pyx_t_2 = (__pyx_t_3 != 0); + if (__pyx_t_2) { + + /* "asyncpg/protocol/prepared_stmt.pyx":75 + * + * if len(result): + * return result # <<<<<<<<<<<<<< + * else: + * return True + */ + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(__pyx_v_result); + __pyx_r = __pyx_v_result; + goto __pyx_L0; + + /* "asyncpg/protocol/prepared_stmt.pyx":74 + * result.add(rdesc[3]) + * + * if len(result): # <<<<<<<<<<<<<< + * return result + * else: + */ + } + + /* "asyncpg/protocol/prepared_stmt.pyx":77 + * return result + * else: + * return True # <<<<<<<<<<<<<< + * + * def attach(self): + */ + /*else*/ { + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(Py_True); + __pyx_r = Py_True; + goto __pyx_L0; + } + + /* "asyncpg/protocol/prepared_stmt.pyx":57 + * return tuple(result) + * + * def _init_types(self): # <<<<<<<<<<<<<< + * cdef: + * Codec codec + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_AddTraceback("asyncpg.protocol.protocol.PreparedStatementState._init_types", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XDECREF((PyObject *)__pyx_v_codec); + __Pyx_XDECREF(__pyx_v_result); + __Pyx_XDECREF(__pyx_v_p_oid); + __Pyx_XDECREF(__pyx_v_rdesc); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "asyncpg/protocol/prepared_stmt.pyx":79 + * return True + * + * def attach(self): # <<<<<<<<<<<<<< + * self.refs += 1 + * + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_7asyncpg_8protocol_8protocol_22PreparedStatementState_9attach(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/ +static PyObject *__pyx_pw_7asyncpg_8protocol_8protocol_22PreparedStatementState_9attach(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("attach (wrapper)", 0); + __pyx_r = __pyx_pf_7asyncpg_8protocol_8protocol_22PreparedStatementState_8attach(((struct __pyx_obj_7asyncpg_8protocol_8protocol_PreparedStatementState *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_7asyncpg_8protocol_8protocol_22PreparedStatementState_8attach(struct __pyx_obj_7asyncpg_8protocol_8protocol_PreparedStatementState *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("attach", 0); + + /* "asyncpg/protocol/prepared_stmt.pyx":80 + * + * def attach(self): + * self.refs += 1 # <<<<<<<<<<<<<< + * + * def detach(self): + */ + __pyx_v_self->refs = (__pyx_v_self->refs + 1); + + /* "asyncpg/protocol/prepared_stmt.pyx":79 + * return True + * + * def attach(self): # <<<<<<<<<<<<<< + * self.refs += 1 + * + */ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "asyncpg/protocol/prepared_stmt.pyx":82 + * self.refs += 1 + * + * def detach(self): # <<<<<<<<<<<<<< + * self.refs -= 1 + * + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_7asyncpg_8protocol_8protocol_22PreparedStatementState_11detach(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/ +static PyObject *__pyx_pw_7asyncpg_8protocol_8protocol_22PreparedStatementState_11detach(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("detach (wrapper)", 0); + __pyx_r = __pyx_pf_7asyncpg_8protocol_8protocol_22PreparedStatementState_10detach(((struct __pyx_obj_7asyncpg_8protocol_8protocol_PreparedStatementState *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_7asyncpg_8protocol_8protocol_22PreparedStatementState_10detach(struct __pyx_obj_7asyncpg_8protocol_8protocol_PreparedStatementState *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("detach", 0); + + /* "asyncpg/protocol/prepared_stmt.pyx":83 + * + * def detach(self): + * self.refs -= 1 # <<<<<<<<<<<<<< + * + * def mark_closed(self): + */ + __pyx_v_self->refs = (__pyx_v_self->refs - 1); + + /* "asyncpg/protocol/prepared_stmt.pyx":82 + * self.refs += 1 + * + * def detach(self): # <<<<<<<<<<<<<< + * self.refs -= 1 + * + */ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "asyncpg/protocol/prepared_stmt.pyx":85 + * self.refs -= 1 + * + * def mark_closed(self): # <<<<<<<<<<<<<< + * self.closed = True + * + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_7asyncpg_8protocol_8protocol_22PreparedStatementState_13mark_closed(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/ +static PyObject *__pyx_pw_7asyncpg_8protocol_8protocol_22PreparedStatementState_13mark_closed(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("mark_closed (wrapper)", 0); + __pyx_r = __pyx_pf_7asyncpg_8protocol_8protocol_22PreparedStatementState_12mark_closed(((struct __pyx_obj_7asyncpg_8protocol_8protocol_PreparedStatementState *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_7asyncpg_8protocol_8protocol_22PreparedStatementState_12mark_closed(struct __pyx_obj_7asyncpg_8protocol_8protocol_PreparedStatementState *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("mark_closed", 0); + + /* "asyncpg/protocol/prepared_stmt.pyx":86 + * + * def mark_closed(self): + * self.closed = True # <<<<<<<<<<<<<< + * + * cdef _encode_bind_msg(self, args): + */ + __pyx_v_self->closed = 1; + + /* "asyncpg/protocol/prepared_stmt.pyx":85 + * self.refs -= 1 + * + * def mark_closed(self): # <<<<<<<<<<<<<< + * self.closed = True + * + */ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "asyncpg/protocol/prepared_stmt.pyx":88 + * self.closed = True + * + * cdef _encode_bind_msg(self, args): # <<<<<<<<<<<<<< + * cdef: + * int idx + */ + +static PyObject *__pyx_f_7asyncpg_8protocol_8protocol_22PreparedStatementState__encode_bind_msg(struct __pyx_obj_7asyncpg_8protocol_8protocol_PreparedStatementState *__pyx_v_self, PyObject *__pyx_v_args) { + int __pyx_v_idx; + struct __pyx_obj_7asyncpg_8protocol_8protocol_WriteBuffer *__pyx_v_writer = 0; + struct __pyx_obj_7asyncpg_8protocol_8protocol_Codec *__pyx_v_codec = 0; + PyObject *__pyx_v_arg = NULL; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + Py_ssize_t __pyx_t_2; + int __pyx_t_3; + PyObject *__pyx_t_4 = NULL; + PyObject *__pyx_t_5 = NULL; + PyObject *__pyx_t_6 = NULL; + PyObject *__pyx_t_7 = NULL; + int __pyx_t_8; + PyObject *__pyx_t_9 = NULL; + int16_t __pyx_t_10; + int __pyx_t_11; + __Pyx_RefNannySetupContext("_encode_bind_msg", 0); + + /* "asyncpg/protocol/prepared_stmt.pyx":94 + * Codec codec + * + * self._ensure_args_encoder() # <<<<<<<<<<<<<< + * self._ensure_rows_decoder() + * + */ + __pyx_t_1 = __pyx_f_7asyncpg_8protocol_8protocol_22PreparedStatementState__ensure_args_encoder(__pyx_v_self); if (unlikely(!__pyx_t_1)) __PYX_ERR(25, 94, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "asyncpg/protocol/prepared_stmt.pyx":95 + * + * self._ensure_args_encoder() + * self._ensure_rows_decoder() # <<<<<<<<<<<<<< + * + * writer = WriteBuffer.new() + */ + __pyx_t_1 = __pyx_f_7asyncpg_8protocol_8protocol_22PreparedStatementState__ensure_rows_decoder(__pyx_v_self); if (unlikely(!__pyx_t_1)) __PYX_ERR(25, 95, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "asyncpg/protocol/prepared_stmt.pyx":97 + * self._ensure_rows_decoder() + * + * writer = WriteBuffer.new() # <<<<<<<<<<<<<< + * + * if self.args_num != len(args): + */ + __pyx_t_1 = ((PyObject *)__pyx_f_7asyncpg_8protocol_8protocol_11WriteBuffer_new()); if (unlikely(!__pyx_t_1)) __PYX_ERR(25, 97, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_v_writer = ((struct __pyx_obj_7asyncpg_8protocol_8protocol_WriteBuffer *)__pyx_t_1); + __pyx_t_1 = 0; + + /* "asyncpg/protocol/prepared_stmt.pyx":99 + * writer = WriteBuffer.new() + * + * if self.args_num != len(args): # <<<<<<<<<<<<<< + * raise ValueError( + * 'number of arguments ({}) does not match ' + */ + __pyx_t_2 = PyObject_Length(__pyx_v_args); if (unlikely(__pyx_t_2 == -1)) __PYX_ERR(25, 99, __pyx_L1_error) + __pyx_t_3 = ((__pyx_v_self->args_num != __pyx_t_2) != 0); + if (__pyx_t_3) { + + /* "asyncpg/protocol/prepared_stmt.pyx":102 + * raise ValueError( + * 'number of arguments ({}) does not match ' + * 'number of parameters ({})'.format( # <<<<<<<<<<<<<< + * len(args), self.args_num)) + * + */ + __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_kp_u_number_of_arguments_does_not_mat, __pyx_n_s_format); if (unlikely(!__pyx_t_4)) __PYX_ERR(25, 102, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + + /* "asyncpg/protocol/prepared_stmt.pyx":103 + * 'number of arguments ({}) does not match ' + * 'number of parameters ({})'.format( + * len(args), self.args_num)) # <<<<<<<<<<<<<< + * + * if self.have_text_args: + */ + __pyx_t_2 = PyObject_Length(__pyx_v_args); if (unlikely(__pyx_t_2 == -1)) __PYX_ERR(25, 103, __pyx_L1_error) + __pyx_t_5 = PyInt_FromSsize_t(__pyx_t_2); if (unlikely(!__pyx_t_5)) __PYX_ERR(25, 103, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_6 = __Pyx_PyInt_From_int16_t(__pyx_v_self->args_num); if (unlikely(!__pyx_t_6)) __PYX_ERR(25, 103, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_7 = NULL; + __pyx_t_8 = 0; + if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_4))) { + __pyx_t_7 = PyMethod_GET_SELF(__pyx_t_4); + if (likely(__pyx_t_7)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4); + __Pyx_INCREF(__pyx_t_7); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_4, function); + __pyx_t_8 = 1; + } + } + #if CYTHON_FAST_PYCALL + if (PyFunction_Check(__pyx_t_4)) { + PyObject *__pyx_temp[3] = {__pyx_t_7, __pyx_t_5, __pyx_t_6}; + __pyx_t_1 = __Pyx_PyFunction_FastCall(__pyx_t_4, __pyx_temp+1-__pyx_t_8, 2+__pyx_t_8); if (unlikely(!__pyx_t_1)) __PYX_ERR(25, 102, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + } else + #endif + #if CYTHON_FAST_PYCCALL + if (__Pyx_PyFastCFunction_Check(__pyx_t_4)) { + PyObject *__pyx_temp[3] = {__pyx_t_7, __pyx_t_5, __pyx_t_6}; + __pyx_t_1 = __Pyx_PyCFunction_FastCall(__pyx_t_4, __pyx_temp+1-__pyx_t_8, 2+__pyx_t_8); if (unlikely(!__pyx_t_1)) __PYX_ERR(25, 102, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + } else + #endif + { + __pyx_t_9 = PyTuple_New(2+__pyx_t_8); if (unlikely(!__pyx_t_9)) __PYX_ERR(25, 102, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_9); + if (__pyx_t_7) { + __Pyx_GIVEREF(__pyx_t_7); PyTuple_SET_ITEM(__pyx_t_9, 0, __pyx_t_7); __pyx_t_7 = NULL; + } + __Pyx_GIVEREF(__pyx_t_5); + PyTuple_SET_ITEM(__pyx_t_9, 0+__pyx_t_8, __pyx_t_5); + __Pyx_GIVEREF(__pyx_t_6); + PyTuple_SET_ITEM(__pyx_t_9, 1+__pyx_t_8, __pyx_t_6); + __pyx_t_5 = 0; + __pyx_t_6 = 0; + __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_4, __pyx_t_9, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(25, 102, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + } + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + + /* "asyncpg/protocol/prepared_stmt.pyx":100 + * + * if self.args_num != len(args): + * raise ValueError( # <<<<<<<<<<<<<< + * 'number of arguments ({}) does not match ' + * 'number of parameters ({})'.format( + */ + __pyx_t_4 = PyTuple_New(1); if (unlikely(!__pyx_t_4)) __PYX_ERR(25, 100, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_GIVEREF(__pyx_t_1); + PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_1); + __pyx_t_1 = 0; + __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_t_4, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(25, 100, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_Raise(__pyx_t_1, 0, 0, 0); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __PYX_ERR(25, 100, __pyx_L1_error) + + /* "asyncpg/protocol/prepared_stmt.pyx":99 + * writer = WriteBuffer.new() + * + * if self.args_num != len(args): # <<<<<<<<<<<<<< + * raise ValueError( + * 'number of arguments ({}) does not match ' + */ + } + + /* "asyncpg/protocol/prepared_stmt.pyx":105 + * len(args), self.args_num)) + * + * if self.have_text_args: # <<<<<<<<<<<<<< + * writer.write_int16(self.args_num) + * for idx from 0 <= idx < self.args_num: + */ + __pyx_t_3 = (__pyx_v_self->have_text_args != 0); + if (__pyx_t_3) { + + /* "asyncpg/protocol/prepared_stmt.pyx":106 + * + * if self.have_text_args: + * writer.write_int16(self.args_num) # <<<<<<<<<<<<<< + * for idx from 0 <= idx < self.args_num: + * codec = (self.args_codecs[idx]) + */ + __pyx_t_1 = __pyx_f_7asyncpg_8protocol_8protocol_11WriteBuffer_write_int16(__pyx_v_writer, __pyx_v_self->args_num); if (unlikely(!__pyx_t_1)) __PYX_ERR(25, 106, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "asyncpg/protocol/prepared_stmt.pyx":107 + * if self.have_text_args: + * writer.write_int16(self.args_num) + * for idx from 0 <= idx < self.args_num: # <<<<<<<<<<<<<< + * codec = (self.args_codecs[idx]) + * writer.write_int16(codec.format) + */ + __pyx_t_10 = __pyx_v_self->args_num; + for (__pyx_v_idx = 0; __pyx_v_idx < __pyx_t_10; __pyx_v_idx++) { + + /* "asyncpg/protocol/prepared_stmt.pyx":108 + * writer.write_int16(self.args_num) + * for idx from 0 <= idx < self.args_num: + * codec = (self.args_codecs[idx]) # <<<<<<<<<<<<<< + * writer.write_int16(codec.format) + * else: + */ + if (unlikely(__pyx_v_self->args_codecs == Py_None)) { + PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable"); + __PYX_ERR(25, 108, __pyx_L1_error) + } + __pyx_t_1 = __Pyx_GetItemInt_Tuple(__pyx_v_self->args_codecs, __pyx_v_idx, int, 1, __Pyx_PyInt_From_int, 0, 1, 1); if (unlikely(!__pyx_t_1)) __PYX_ERR(25, 108, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_4 = __pyx_t_1; + __Pyx_INCREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_XDECREF_SET(__pyx_v_codec, ((struct __pyx_obj_7asyncpg_8protocol_8protocol_Codec *)__pyx_t_4)); + __pyx_t_4 = 0; + + /* "asyncpg/protocol/prepared_stmt.pyx":109 + * for idx from 0 <= idx < self.args_num: + * codec = (self.args_codecs[idx]) + * writer.write_int16(codec.format) # <<<<<<<<<<<<<< + * else: + * # All arguments are in binary format + */ + __pyx_t_4 = __pyx_f_7asyncpg_8protocol_8protocol_11WriteBuffer_write_int16(__pyx_v_writer, __pyx_v_codec->format); if (unlikely(!__pyx_t_4)) __PYX_ERR(25, 109, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + } + + /* "asyncpg/protocol/prepared_stmt.pyx":105 + * len(args), self.args_num)) + * + * if self.have_text_args: # <<<<<<<<<<<<<< + * writer.write_int16(self.args_num) + * for idx from 0 <= idx < self.args_num: + */ + goto __pyx_L4; + } + + /* "asyncpg/protocol/prepared_stmt.pyx":112 + * else: + * # All arguments are in binary format + * writer.write_int32(0x00010001) # <<<<<<<<<<<<<< + * + * writer.write_int16(self.args_num) + */ + /*else*/ { + __pyx_t_4 = __pyx_f_7asyncpg_8protocol_8protocol_11WriteBuffer_write_int32(__pyx_v_writer, 0x00010001); if (unlikely(!__pyx_t_4)) __PYX_ERR(25, 112, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + } + __pyx_L4:; + + /* "asyncpg/protocol/prepared_stmt.pyx":114 + * writer.write_int32(0x00010001) + * + * writer.write_int16(self.args_num) # <<<<<<<<<<<<<< + * + * for idx from 0 <= idx < self.args_num: + */ + __pyx_t_4 = __pyx_f_7asyncpg_8protocol_8protocol_11WriteBuffer_write_int16(__pyx_v_writer, __pyx_v_self->args_num); if (unlikely(!__pyx_t_4)) __PYX_ERR(25, 114, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + + /* "asyncpg/protocol/prepared_stmt.pyx":116 + * writer.write_int16(self.args_num) + * + * for idx from 0 <= idx < self.args_num: # <<<<<<<<<<<<<< + * arg = args[idx] + * if arg is None: + */ + __pyx_t_10 = __pyx_v_self->args_num; + for (__pyx_v_idx = 0; __pyx_v_idx < __pyx_t_10; __pyx_v_idx++) { + + /* "asyncpg/protocol/prepared_stmt.pyx":117 + * + * for idx from 0 <= idx < self.args_num: + * arg = args[idx] # <<<<<<<<<<<<<< + * if arg is None: + * writer.write_int32(-1) + */ + __pyx_t_4 = __Pyx_GetItemInt(__pyx_v_args, __pyx_v_idx, int, 1, __Pyx_PyInt_From_int, 0, 1, 1); if (unlikely(!__pyx_t_4)) __PYX_ERR(25, 117, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_XDECREF_SET(__pyx_v_arg, __pyx_t_4); + __pyx_t_4 = 0; + + /* "asyncpg/protocol/prepared_stmt.pyx":118 + * for idx from 0 <= idx < self.args_num: + * arg = args[idx] + * if arg is None: # <<<<<<<<<<<<<< + * writer.write_int32(-1) + * else: + */ + __pyx_t_3 = (__pyx_v_arg == Py_None); + __pyx_t_11 = (__pyx_t_3 != 0); + if (__pyx_t_11) { + + /* "asyncpg/protocol/prepared_stmt.pyx":119 + * arg = args[idx] + * if arg is None: + * writer.write_int32(-1) # <<<<<<<<<<<<<< + * else: + * codec = (self.args_codecs[idx]) + */ + __pyx_t_4 = __pyx_f_7asyncpg_8protocol_8protocol_11WriteBuffer_write_int32(__pyx_v_writer, -1); if (unlikely(!__pyx_t_4)) __PYX_ERR(25, 119, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + + /* "asyncpg/protocol/prepared_stmt.pyx":118 + * for idx from 0 <= idx < self.args_num: + * arg = args[idx] + * if arg is None: # <<<<<<<<<<<<<< + * writer.write_int32(-1) + * else: + */ + goto __pyx_L9; + } + + /* "asyncpg/protocol/prepared_stmt.pyx":121 + * writer.write_int32(-1) + * else: + * codec = (self.args_codecs[idx]) # <<<<<<<<<<<<<< + * codec.encode(self.settings, writer, arg) + * + */ + /*else*/ { + if (unlikely(__pyx_v_self->args_codecs == Py_None)) { + PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable"); + __PYX_ERR(25, 121, __pyx_L1_error) + } + __pyx_t_4 = __Pyx_GetItemInt_Tuple(__pyx_v_self->args_codecs, __pyx_v_idx, int, 1, __Pyx_PyInt_From_int, 0, 1, 1); if (unlikely(!__pyx_t_4)) __PYX_ERR(25, 121, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_1 = __pyx_t_4; + __Pyx_INCREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_XDECREF_SET(__pyx_v_codec, ((struct __pyx_obj_7asyncpg_8protocol_8protocol_Codec *)__pyx_t_1)); + __pyx_t_1 = 0; + + /* "asyncpg/protocol/prepared_stmt.pyx":122 + * else: + * codec = (self.args_codecs[idx]) + * codec.encode(self.settings, writer, arg) # <<<<<<<<<<<<<< + * + * if self.have_text_cols: + */ + __pyx_t_1 = ((PyObject *)__pyx_v_self->settings); + __Pyx_INCREF(__pyx_t_1); + __pyx_t_4 = __pyx_f_7asyncpg_8protocol_8protocol_5Codec_encode(__pyx_v_codec, ((struct __pyx_obj_7asyncpg_8protocol_8protocol_ConnectionSettings *)__pyx_t_1), __pyx_v_writer, __pyx_v_arg); if (unlikely(!__pyx_t_4)) __PYX_ERR(25, 122, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + } + __pyx_L9:; + } + + /* "asyncpg/protocol/prepared_stmt.pyx":124 + * codec.encode(self.settings, writer, arg) + * + * if self.have_text_cols: # <<<<<<<<<<<<<< + * writer.write_int16(self.cols_num) + * for idx from 0 <= idx < self.cols_num: + */ + __pyx_t_11 = (__pyx_v_self->have_text_cols != 0); + if (__pyx_t_11) { + + /* "asyncpg/protocol/prepared_stmt.pyx":125 + * + * if self.have_text_cols: + * writer.write_int16(self.cols_num) # <<<<<<<<<<<<<< + * for idx from 0 <= idx < self.cols_num: + * codec = (self.rows_codecs[idx]) + */ + __pyx_t_4 = __pyx_f_7asyncpg_8protocol_8protocol_11WriteBuffer_write_int16(__pyx_v_writer, __pyx_v_self->cols_num); if (unlikely(!__pyx_t_4)) __PYX_ERR(25, 125, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + + /* "asyncpg/protocol/prepared_stmt.pyx":126 + * if self.have_text_cols: + * writer.write_int16(self.cols_num) + * for idx from 0 <= idx < self.cols_num: # <<<<<<<<<<<<<< + * codec = (self.rows_codecs[idx]) + * writer.write_int16(codec.format) + */ + __pyx_t_10 = __pyx_v_self->cols_num; + for (__pyx_v_idx = 0; __pyx_v_idx < __pyx_t_10; __pyx_v_idx++) { + + /* "asyncpg/protocol/prepared_stmt.pyx":127 + * writer.write_int16(self.cols_num) + * for idx from 0 <= idx < self.cols_num: + * codec = (self.rows_codecs[idx]) # <<<<<<<<<<<<<< + * writer.write_int16(codec.format) + * else: + */ + if (unlikely(__pyx_v_self->rows_codecs == Py_None)) { + PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable"); + __PYX_ERR(25, 127, __pyx_L1_error) + } + __pyx_t_4 = __Pyx_GetItemInt_Tuple(__pyx_v_self->rows_codecs, __pyx_v_idx, int, 1, __Pyx_PyInt_From_int, 0, 1, 1); if (unlikely(!__pyx_t_4)) __PYX_ERR(25, 127, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_1 = __pyx_t_4; + __Pyx_INCREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_XDECREF_SET(__pyx_v_codec, ((struct __pyx_obj_7asyncpg_8protocol_8protocol_Codec *)__pyx_t_1)); + __pyx_t_1 = 0; + + /* "asyncpg/protocol/prepared_stmt.pyx":128 + * for idx from 0 <= idx < self.cols_num: + * codec = (self.rows_codecs[idx]) + * writer.write_int16(codec.format) # <<<<<<<<<<<<<< + * else: + * # All columns are in binary format + */ + __pyx_t_1 = __pyx_f_7asyncpg_8protocol_8protocol_11WriteBuffer_write_int16(__pyx_v_writer, __pyx_v_codec->format); if (unlikely(!__pyx_t_1)) __PYX_ERR(25, 128, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + } + + /* "asyncpg/protocol/prepared_stmt.pyx":124 + * codec.encode(self.settings, writer, arg) + * + * if self.have_text_cols: # <<<<<<<<<<<<<< + * writer.write_int16(self.cols_num) + * for idx from 0 <= idx < self.cols_num: + */ + goto __pyx_L10; + } + + /* "asyncpg/protocol/prepared_stmt.pyx":131 + * else: + * # All columns are in binary format + * writer.write_int32(0x00010001) # <<<<<<<<<<<<<< + * + * return writer + */ + /*else*/ { + __pyx_t_1 = __pyx_f_7asyncpg_8protocol_8protocol_11WriteBuffer_write_int32(__pyx_v_writer, 0x00010001); if (unlikely(!__pyx_t_1)) __PYX_ERR(25, 131, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + } + __pyx_L10:; + + /* "asyncpg/protocol/prepared_stmt.pyx":133 + * writer.write_int32(0x00010001) + * + * return writer # <<<<<<<<<<<<<< + * + * cdef _ensure_rows_decoder(self): + */ + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(((PyObject *)__pyx_v_writer)); + __pyx_r = ((PyObject *)__pyx_v_writer); + goto __pyx_L0; + + /* "asyncpg/protocol/prepared_stmt.pyx":88 + * self.closed = True + * + * cdef _encode_bind_msg(self, args): # <<<<<<<<<<<<<< + * cdef: + * int idx + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_XDECREF(__pyx_t_6); + __Pyx_XDECREF(__pyx_t_7); + __Pyx_XDECREF(__pyx_t_9); + __Pyx_AddTraceback("asyncpg.protocol.protocol.PreparedStatementState._encode_bind_msg", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XDECREF((PyObject *)__pyx_v_writer); + __Pyx_XDECREF((PyObject *)__pyx_v_codec); + __Pyx_XDECREF(__pyx_v_arg); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "asyncpg/protocol/prepared_stmt.pyx":135 + * return writer + * + * cdef _ensure_rows_decoder(self): # <<<<<<<<<<<<<< + * cdef: + * list cols_names + */ + +static PyObject *__pyx_f_7asyncpg_8protocol_8protocol_22PreparedStatementState__ensure_rows_decoder(struct __pyx_obj_7asyncpg_8protocol_8protocol_PreparedStatementState *__pyx_v_self) { + PyObject *__pyx_v_cols_names = 0; + PyObject *__pyx_v_cols_mapping = 0; + PyObject *__pyx_v_row = 0; + int __pyx_v_oid; + struct __pyx_obj_7asyncpg_8protocol_8protocol_Codec *__pyx_v_codec = 0; + PyObject *__pyx_v_codecs = 0; + long __pyx_v_i; + PyObject *__pyx_v_col_name = NULL; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + int __pyx_t_2; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + PyObject *__pyx_t_5 = NULL; + int16_t __pyx_t_6; + PyObject *__pyx_t_7 = NULL; + int __pyx_t_8; + int __pyx_t_9; + int __pyx_t_10; + PyObject *__pyx_t_11 = NULL; + __Pyx_RefNannySetupContext("_ensure_rows_decoder", 0); + + /* "asyncpg/protocol/prepared_stmt.pyx":144 + * list codecs + * + * if self.cols_desc is not None: # <<<<<<<<<<<<<< + * return + * + */ + __pyx_t_1 = (__pyx_v_self->cols_desc != Py_None); + __pyx_t_2 = (__pyx_t_1 != 0); + if (__pyx_t_2) { + + /* "asyncpg/protocol/prepared_stmt.pyx":145 + * + * if self.cols_desc is not None: + * return # <<<<<<<<<<<<<< + * + * if self.cols_num == 0: + */ + __Pyx_XDECREF(__pyx_r); + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + + /* "asyncpg/protocol/prepared_stmt.pyx":144 + * list codecs + * + * if self.cols_desc is not None: # <<<<<<<<<<<<<< + * return + * + */ + } + + /* "asyncpg/protocol/prepared_stmt.pyx":147 + * return + * + * if self.cols_num == 0: # <<<<<<<<<<<<<< + * self.cols_desc = record.ApgRecordDesc_New({}, ()) + * return + */ + __pyx_t_2 = ((__pyx_v_self->cols_num == 0) != 0); + if (__pyx_t_2) { + + /* "asyncpg/protocol/prepared_stmt.pyx":148 + * + * if self.cols_num == 0: + * self.cols_desc = record.ApgRecordDesc_New({}, ()) # <<<<<<<<<<<<<< + * return + * + */ + __pyx_t_3 = PyDict_New(); if (unlikely(!__pyx_t_3)) __PYX_ERR(25, 148, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = ApgRecordDesc_New(__pyx_t_3, __pyx_empty_tuple); if (unlikely(!__pyx_t_4)) __PYX_ERR(25, 148, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_GIVEREF(__pyx_t_4); + __Pyx_GOTREF(__pyx_v_self->cols_desc); + __Pyx_DECREF(__pyx_v_self->cols_desc); + __pyx_v_self->cols_desc = __pyx_t_4; + __pyx_t_4 = 0; + + /* "asyncpg/protocol/prepared_stmt.pyx":149 + * if self.cols_num == 0: + * self.cols_desc = record.ApgRecordDesc_New({}, ()) + * return # <<<<<<<<<<<<<< + * + * cols_mapping = collections.OrderedDict() + */ + __Pyx_XDECREF(__pyx_r); + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + + /* "asyncpg/protocol/prepared_stmt.pyx":147 + * return + * + * if self.cols_num == 0: # <<<<<<<<<<<<<< + * self.cols_desc = record.ApgRecordDesc_New({}, ()) + * return + */ + } + + /* "asyncpg/protocol/prepared_stmt.pyx":151 + * return + * + * cols_mapping = collections.OrderedDict() # <<<<<<<<<<<<<< + * cols_names = [] + * codecs = [] + */ + __pyx_t_3 = __Pyx_GetModuleGlobalName(__pyx_n_s_collections); if (unlikely(!__pyx_t_3)) __PYX_ERR(25, 151, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_OrderedDict); if (unlikely(!__pyx_t_5)) __PYX_ERR(25, 151, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_3 = NULL; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_5))) { + __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_5); + if (likely(__pyx_t_3)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_5); + __Pyx_INCREF(__pyx_t_3); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_5, function); + } + } + if (__pyx_t_3) { + __pyx_t_4 = __Pyx_PyObject_CallOneArg(__pyx_t_5, __pyx_t_3); if (unlikely(!__pyx_t_4)) __PYX_ERR(25, 151, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + } else { + __pyx_t_4 = __Pyx_PyObject_CallNoArg(__pyx_t_5); if (unlikely(!__pyx_t_4)) __PYX_ERR(25, 151, __pyx_L1_error) + } + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __pyx_v_cols_mapping = __pyx_t_4; + __pyx_t_4 = 0; + + /* "asyncpg/protocol/prepared_stmt.pyx":152 + * + * cols_mapping = collections.OrderedDict() + * cols_names = [] # <<<<<<<<<<<<<< + * codecs = [] + * for i from 0 <= i < self.cols_num: + */ + __pyx_t_4 = PyList_New(0); if (unlikely(!__pyx_t_4)) __PYX_ERR(25, 152, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_v_cols_names = ((PyObject*)__pyx_t_4); + __pyx_t_4 = 0; + + /* "asyncpg/protocol/prepared_stmt.pyx":153 + * cols_mapping = collections.OrderedDict() + * cols_names = [] + * codecs = [] # <<<<<<<<<<<<<< + * for i from 0 <= i < self.cols_num: + * row = self.row_desc[i] + */ + __pyx_t_4 = PyList_New(0); if (unlikely(!__pyx_t_4)) __PYX_ERR(25, 153, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_v_codecs = ((PyObject*)__pyx_t_4); + __pyx_t_4 = 0; + + /* "asyncpg/protocol/prepared_stmt.pyx":154 + * cols_names = [] + * codecs = [] + * for i from 0 <= i < self.cols_num: # <<<<<<<<<<<<<< + * row = self.row_desc[i] + * col_name = row[0].decode(self.settings._encoding) + */ + __pyx_t_6 = __pyx_v_self->cols_num; + for (__pyx_v_i = 0; __pyx_v_i < __pyx_t_6; __pyx_v_i++) { + + /* "asyncpg/protocol/prepared_stmt.pyx":155 + * codecs = [] + * for i from 0 <= i < self.cols_num: + * row = self.row_desc[i] # <<<<<<<<<<<<<< + * col_name = row[0].decode(self.settings._encoding) + * cols_mapping[col_name] = i + */ + if (unlikely(__pyx_v_self->row_desc == Py_None)) { + PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable"); + __PYX_ERR(25, 155, __pyx_L1_error) + } + __pyx_t_4 = __Pyx_GetItemInt_List(__pyx_v_self->row_desc, __pyx_v_i, long, 1, __Pyx_PyInt_From_long, 1, 1, 1); if (unlikely(!__pyx_t_4)) __PYX_ERR(25, 155, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + if (!(likely(PyTuple_CheckExact(__pyx_t_4))||((__pyx_t_4) == Py_None)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "tuple", Py_TYPE(__pyx_t_4)->tp_name), 0))) __PYX_ERR(25, 155, __pyx_L1_error) + __Pyx_XDECREF_SET(__pyx_v_row, ((PyObject*)__pyx_t_4)); + __pyx_t_4 = 0; + + /* "asyncpg/protocol/prepared_stmt.pyx":156 + * for i from 0 <= i < self.cols_num: + * row = self.row_desc[i] + * col_name = row[0].decode(self.settings._encoding) # <<<<<<<<<<<<<< + * cols_mapping[col_name] = i + * cols_names.append(col_name) + */ + if (unlikely(__pyx_v_row == Py_None)) { + PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable"); + __PYX_ERR(25, 156, __pyx_L1_error) + } + __pyx_t_5 = __Pyx_GetItemInt_Tuple(__pyx_v_row, 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_5)) __PYX_ERR(25, 156, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_5, __pyx_n_s_decode); if (unlikely(!__pyx_t_3)) __PYX_ERR(25, 156, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __pyx_t_5 = NULL; + if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_3))) { + __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_3); + if (likely(__pyx_t_5)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); + __Pyx_INCREF(__pyx_t_5); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_3, function); + } + } + if (!__pyx_t_5) { + __pyx_t_4 = __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_v_self->settings->_encoding); if (unlikely(!__pyx_t_4)) __PYX_ERR(25, 156, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + } else { + #if CYTHON_FAST_PYCALL + if (PyFunction_Check(__pyx_t_3)) { + PyObject *__pyx_temp[2] = {__pyx_t_5, __pyx_v_self->settings->_encoding}; + __pyx_t_4 = __Pyx_PyFunction_FastCall(__pyx_t_3, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_4)) __PYX_ERR(25, 156, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_GOTREF(__pyx_t_4); + } else + #endif + #if CYTHON_FAST_PYCCALL + if (__Pyx_PyFastCFunction_Check(__pyx_t_3)) { + PyObject *__pyx_temp[2] = {__pyx_t_5, __pyx_v_self->settings->_encoding}; + __pyx_t_4 = __Pyx_PyCFunction_FastCall(__pyx_t_3, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_4)) __PYX_ERR(25, 156, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_GOTREF(__pyx_t_4); + } else + #endif + { + __pyx_t_7 = PyTuple_New(1+1); if (unlikely(!__pyx_t_7)) __PYX_ERR(25, 156, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __Pyx_GIVEREF(__pyx_t_5); PyTuple_SET_ITEM(__pyx_t_7, 0, __pyx_t_5); __pyx_t_5 = NULL; + __Pyx_INCREF(__pyx_v_self->settings->_encoding); + __Pyx_GIVEREF(__pyx_v_self->settings->_encoding); + PyTuple_SET_ITEM(__pyx_t_7, 0+1, __pyx_v_self->settings->_encoding); + __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_t_7, NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(25, 156, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + } + } + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_XDECREF_SET(__pyx_v_col_name, __pyx_t_4); + __pyx_t_4 = 0; + + /* "asyncpg/protocol/prepared_stmt.pyx":157 + * row = self.row_desc[i] + * col_name = row[0].decode(self.settings._encoding) + * cols_mapping[col_name] = i # <<<<<<<<<<<<<< + * cols_names.append(col_name) + * oid = row[3] + */ + __pyx_t_4 = __Pyx_PyInt_From_long(__pyx_v_i); if (unlikely(!__pyx_t_4)) __PYX_ERR(25, 157, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + if (unlikely(PyObject_SetItem(__pyx_v_cols_mapping, __pyx_v_col_name, __pyx_t_4) < 0)) __PYX_ERR(25, 157, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + + /* "asyncpg/protocol/prepared_stmt.pyx":158 + * col_name = row[0].decode(self.settings._encoding) + * cols_mapping[col_name] = i + * cols_names.append(col_name) # <<<<<<<<<<<<<< + * oid = row[3] + * codec = self.settings.get_data_codec(oid) + */ + __pyx_t_8 = __Pyx_PyList_Append(__pyx_v_cols_names, __pyx_v_col_name); if (unlikely(__pyx_t_8 == -1)) __PYX_ERR(25, 158, __pyx_L1_error) + + /* "asyncpg/protocol/prepared_stmt.pyx":159 + * cols_mapping[col_name] = i + * cols_names.append(col_name) + * oid = row[3] # <<<<<<<<<<<<<< + * codec = self.settings.get_data_codec(oid) + * if codec is None or not codec.has_decoder(): + */ + if (unlikely(__pyx_v_row == Py_None)) { + PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable"); + __PYX_ERR(25, 159, __pyx_L1_error) + } + __pyx_t_4 = __Pyx_GetItemInt_Tuple(__pyx_v_row, 3, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_4)) __PYX_ERR(25, 159, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_9 = __Pyx_PyInt_As_int(__pyx_t_4); if (unlikely((__pyx_t_9 == (int)-1) && PyErr_Occurred())) __PYX_ERR(25, 159, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_v_oid = __pyx_t_9; + + /* "asyncpg/protocol/prepared_stmt.pyx":160 + * cols_names.append(col_name) + * oid = row[3] + * codec = self.settings.get_data_codec(oid) # <<<<<<<<<<<<<< + * if codec is None or not codec.has_decoder(): + * raise RuntimeError('no decoder for OID {}'.format(oid)) + */ + __pyx_t_4 = ((PyObject *)__pyx_f_7asyncpg_8protocol_8protocol_18ConnectionSettings_get_data_codec(__pyx_v_self->settings, ((uint32_t)__pyx_v_oid), 0, NULL)); if (unlikely(!__pyx_t_4)) __PYX_ERR(25, 160, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_XDECREF_SET(__pyx_v_codec, ((struct __pyx_obj_7asyncpg_8protocol_8protocol_Codec *)__pyx_t_4)); + __pyx_t_4 = 0; + + /* "asyncpg/protocol/prepared_stmt.pyx":161 + * oid = row[3] + * codec = self.settings.get_data_codec(oid) + * if codec is None or not codec.has_decoder(): # <<<<<<<<<<<<<< + * raise RuntimeError('no decoder for OID {}'.format(oid)) + * if not codec.is_binary(): + */ + __pyx_t_1 = (((PyObject *)__pyx_v_codec) == Py_None); + __pyx_t_10 = (__pyx_t_1 != 0); + if (!__pyx_t_10) { + } else { + __pyx_t_2 = __pyx_t_10; + goto __pyx_L8_bool_binop_done; + } + __pyx_t_4 = __pyx_f_7asyncpg_8protocol_8protocol_5Codec_has_decoder(__pyx_v_codec); if (unlikely(!__pyx_t_4)) __PYX_ERR(25, 161, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_10 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_10 < 0)) __PYX_ERR(25, 161, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_1 = ((!__pyx_t_10) != 0); + __pyx_t_2 = __pyx_t_1; + __pyx_L8_bool_binop_done:; + if (__pyx_t_2) { + + /* "asyncpg/protocol/prepared_stmt.pyx":162 + * codec = self.settings.get_data_codec(oid) + * if codec is None or not codec.has_decoder(): + * raise RuntimeError('no decoder for OID {}'.format(oid)) # <<<<<<<<<<<<<< + * if not codec.is_binary(): + * self.have_text_cols = True + */ + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_kp_u_no_decoder_for_OID, __pyx_n_s_format); if (unlikely(!__pyx_t_3)) __PYX_ERR(25, 162, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_7 = __Pyx_PyInt_From_int(__pyx_v_oid); if (unlikely(!__pyx_t_7)) __PYX_ERR(25, 162, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __pyx_t_5 = NULL; + if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_3))) { + __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_3); + if (likely(__pyx_t_5)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); + __Pyx_INCREF(__pyx_t_5); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_3, function); + } + } + if (!__pyx_t_5) { + __pyx_t_4 = __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_7); if (unlikely(!__pyx_t_4)) __PYX_ERR(25, 162, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_GOTREF(__pyx_t_4); + } else { + #if CYTHON_FAST_PYCALL + if (PyFunction_Check(__pyx_t_3)) { + PyObject *__pyx_temp[2] = {__pyx_t_5, __pyx_t_7}; + __pyx_t_4 = __Pyx_PyFunction_FastCall(__pyx_t_3, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_4)) __PYX_ERR(25, 162, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + } else + #endif + #if CYTHON_FAST_PYCCALL + if (__Pyx_PyFastCFunction_Check(__pyx_t_3)) { + PyObject *__pyx_temp[2] = {__pyx_t_5, __pyx_t_7}; + __pyx_t_4 = __Pyx_PyCFunction_FastCall(__pyx_t_3, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_4)) __PYX_ERR(25, 162, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + } else + #endif + { + __pyx_t_11 = PyTuple_New(1+1); if (unlikely(!__pyx_t_11)) __PYX_ERR(25, 162, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_11); + __Pyx_GIVEREF(__pyx_t_5); PyTuple_SET_ITEM(__pyx_t_11, 0, __pyx_t_5); __pyx_t_5 = NULL; + __Pyx_GIVEREF(__pyx_t_7); + PyTuple_SET_ITEM(__pyx_t_11, 0+1, __pyx_t_7); + __pyx_t_7 = 0; + __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_t_11, NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(25, 162, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0; + } + } + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_3 = PyTuple_New(1); if (unlikely(!__pyx_t_3)) __PYX_ERR(25, 162, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_GIVEREF(__pyx_t_4); + PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_t_4); + __pyx_t_4 = 0; + __pyx_t_4 = __Pyx_PyObject_Call(__pyx_builtin_RuntimeError, __pyx_t_3, NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(25, 162, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_Raise(__pyx_t_4, 0, 0, 0); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __PYX_ERR(25, 162, __pyx_L1_error) + + /* "asyncpg/protocol/prepared_stmt.pyx":161 + * oid = row[3] + * codec = self.settings.get_data_codec(oid) + * if codec is None or not codec.has_decoder(): # <<<<<<<<<<<<<< + * raise RuntimeError('no decoder for OID {}'.format(oid)) + * if not codec.is_binary(): + */ + } + + /* "asyncpg/protocol/prepared_stmt.pyx":163 + * if codec is None or not codec.has_decoder(): + * raise RuntimeError('no decoder for OID {}'.format(oid)) + * if not codec.is_binary(): # <<<<<<<<<<<<<< + * self.have_text_cols = True + * + */ + __pyx_t_4 = __pyx_f_7asyncpg_8protocol_8protocol_5Codec_is_binary(__pyx_v_codec); if (unlikely(!__pyx_t_4)) __PYX_ERR(25, 163, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_2 < 0)) __PYX_ERR(25, 163, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_1 = ((!__pyx_t_2) != 0); + if (__pyx_t_1) { + + /* "asyncpg/protocol/prepared_stmt.pyx":164 + * raise RuntimeError('no decoder for OID {}'.format(oid)) + * if not codec.is_binary(): + * self.have_text_cols = True # <<<<<<<<<<<<<< + * + * codecs.append(codec) + */ + __pyx_v_self->have_text_cols = 1; + + /* "asyncpg/protocol/prepared_stmt.pyx":163 + * if codec is None or not codec.has_decoder(): + * raise RuntimeError('no decoder for OID {}'.format(oid)) + * if not codec.is_binary(): # <<<<<<<<<<<<<< + * self.have_text_cols = True + * + */ + } + + /* "asyncpg/protocol/prepared_stmt.pyx":166 + * self.have_text_cols = True + * + * codecs.append(codec) # <<<<<<<<<<<<<< + * + * self.cols_desc = record.ApgRecordDesc_New( + */ + __pyx_t_8 = __Pyx_PyList_Append(__pyx_v_codecs, ((PyObject *)__pyx_v_codec)); if (unlikely(__pyx_t_8 == -1)) __PYX_ERR(25, 166, __pyx_L1_error) + } + + /* "asyncpg/protocol/prepared_stmt.pyx":169 + * + * self.cols_desc = record.ApgRecordDesc_New( + * cols_mapping, tuple(cols_names)) # <<<<<<<<<<<<<< + * + * self.rows_codecs = tuple(codecs) + */ + __pyx_t_4 = PyList_AsTuple(__pyx_v_cols_names); if (unlikely(!__pyx_t_4)) __PYX_ERR(25, 169, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + + /* "asyncpg/protocol/prepared_stmt.pyx":168 + * codecs.append(codec) + * + * self.cols_desc = record.ApgRecordDesc_New( # <<<<<<<<<<<<<< + * cols_mapping, tuple(cols_names)) + * + */ + __pyx_t_3 = ApgRecordDesc_New(__pyx_v_cols_mapping, __pyx_t_4); if (unlikely(!__pyx_t_3)) __PYX_ERR(25, 168, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_GIVEREF(__pyx_t_3); + __Pyx_GOTREF(__pyx_v_self->cols_desc); + __Pyx_DECREF(__pyx_v_self->cols_desc); + __pyx_v_self->cols_desc = __pyx_t_3; + __pyx_t_3 = 0; + + /* "asyncpg/protocol/prepared_stmt.pyx":171 + * cols_mapping, tuple(cols_names)) + * + * self.rows_codecs = tuple(codecs) # <<<<<<<<<<<<<< + * + * cdef _ensure_args_encoder(self): + */ + __pyx_t_3 = PyList_AsTuple(__pyx_v_codecs); if (unlikely(!__pyx_t_3)) __PYX_ERR(25, 171, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_GIVEREF(__pyx_t_3); + __Pyx_GOTREF(__pyx_v_self->rows_codecs); + __Pyx_DECREF(__pyx_v_self->rows_codecs); + __pyx_v_self->rows_codecs = ((PyObject*)__pyx_t_3); + __pyx_t_3 = 0; + + /* "asyncpg/protocol/prepared_stmt.pyx":135 + * return writer + * + * cdef _ensure_rows_decoder(self): # <<<<<<<<<<<<<< + * cdef: + * list cols_names + */ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_XDECREF(__pyx_t_7); + __Pyx_XDECREF(__pyx_t_11); + __Pyx_AddTraceback("asyncpg.protocol.protocol.PreparedStatementState._ensure_rows_decoder", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XDECREF(__pyx_v_cols_names); + __Pyx_XDECREF(__pyx_v_cols_mapping); + __Pyx_XDECREF(__pyx_v_row); + __Pyx_XDECREF((PyObject *)__pyx_v_codec); + __Pyx_XDECREF(__pyx_v_codecs); + __Pyx_XDECREF(__pyx_v_col_name); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "asyncpg/protocol/prepared_stmt.pyx":173 + * self.rows_codecs = tuple(codecs) + * + * cdef _ensure_args_encoder(self): # <<<<<<<<<<<<<< + * cdef: + * int p_oid + */ + +static PyObject *__pyx_f_7asyncpg_8protocol_8protocol_22PreparedStatementState__ensure_args_encoder(struct __pyx_obj_7asyncpg_8protocol_8protocol_PreparedStatementState *__pyx_v_self) { + int __pyx_v_p_oid; + struct __pyx_obj_7asyncpg_8protocol_8protocol_Codec *__pyx_v_codec = 0; + PyObject *__pyx_v_codecs = 0; + long __pyx_v_i; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_t_2; + int __pyx_t_3; + int __pyx_t_4; + int16_t __pyx_t_5; + int __pyx_t_6; + PyObject *__pyx_t_7 = NULL; + PyObject *__pyx_t_8 = NULL; + PyObject *__pyx_t_9 = NULL; + PyObject *__pyx_t_10 = NULL; + int __pyx_t_11; + __Pyx_RefNannySetupContext("_ensure_args_encoder", 0); + + /* "asyncpg/protocol/prepared_stmt.pyx":177 + * int p_oid + * Codec codec + * list codecs = [] # <<<<<<<<<<<<<< + * + * if self.args_num == 0 or self.args_codecs is not None: + */ + __pyx_t_1 = PyList_New(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(25, 177, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_v_codecs = ((PyObject*)__pyx_t_1); + __pyx_t_1 = 0; + + /* "asyncpg/protocol/prepared_stmt.pyx":179 + * list codecs = [] + * + * if self.args_num == 0 or self.args_codecs is not None: # <<<<<<<<<<<<<< + * return + * + */ + __pyx_t_3 = ((__pyx_v_self->args_num == 0) != 0); + if (!__pyx_t_3) { + } else { + __pyx_t_2 = __pyx_t_3; + goto __pyx_L4_bool_binop_done; + } + __pyx_t_3 = (__pyx_v_self->args_codecs != ((PyObject*)Py_None)); + __pyx_t_4 = (__pyx_t_3 != 0); + __pyx_t_2 = __pyx_t_4; + __pyx_L4_bool_binop_done:; + if (__pyx_t_2) { + + /* "asyncpg/protocol/prepared_stmt.pyx":180 + * + * if self.args_num == 0 or self.args_codecs is not None: + * return # <<<<<<<<<<<<<< + * + * for i from 0 <= i < self.args_num: + */ + __Pyx_XDECREF(__pyx_r); + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + + /* "asyncpg/protocol/prepared_stmt.pyx":179 + * list codecs = [] + * + * if self.args_num == 0 or self.args_codecs is not None: # <<<<<<<<<<<<<< + * return + * + */ + } + + /* "asyncpg/protocol/prepared_stmt.pyx":182 + * return + * + * for i from 0 <= i < self.args_num: # <<<<<<<<<<<<<< + * p_oid = self.parameters_desc[i] + * codec = self.settings.get_data_codec(p_oid) + */ + __pyx_t_5 = __pyx_v_self->args_num; + for (__pyx_v_i = 0; __pyx_v_i < __pyx_t_5; __pyx_v_i++) { + + /* "asyncpg/protocol/prepared_stmt.pyx":183 + * + * for i from 0 <= i < self.args_num: + * p_oid = self.parameters_desc[i] # <<<<<<<<<<<<<< + * codec = self.settings.get_data_codec(p_oid) + * if codec is None or not codec.has_encoder(): + */ + if (unlikely(__pyx_v_self->parameters_desc == Py_None)) { + PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable"); + __PYX_ERR(25, 183, __pyx_L1_error) + } + __pyx_t_1 = __Pyx_GetItemInt_List(__pyx_v_self->parameters_desc, __pyx_v_i, long, 1, __Pyx_PyInt_From_long, 1, 1, 1); if (unlikely(!__pyx_t_1)) __PYX_ERR(25, 183, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_6 = __Pyx_PyInt_As_int(__pyx_t_1); if (unlikely((__pyx_t_6 == (int)-1) && PyErr_Occurred())) __PYX_ERR(25, 183, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_v_p_oid = __pyx_t_6; + + /* "asyncpg/protocol/prepared_stmt.pyx":184 + * for i from 0 <= i < self.args_num: + * p_oid = self.parameters_desc[i] + * codec = self.settings.get_data_codec(p_oid) # <<<<<<<<<<<<<< + * if codec is None or not codec.has_encoder(): + * raise RuntimeError('no encoder for OID {}'.format(p_oid)) + */ + __pyx_t_1 = ((PyObject *)__pyx_f_7asyncpg_8protocol_8protocol_18ConnectionSettings_get_data_codec(__pyx_v_self->settings, ((uint32_t)__pyx_v_p_oid), 0, NULL)); if (unlikely(!__pyx_t_1)) __PYX_ERR(25, 184, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_XDECREF_SET(__pyx_v_codec, ((struct __pyx_obj_7asyncpg_8protocol_8protocol_Codec *)__pyx_t_1)); + __pyx_t_1 = 0; + + /* "asyncpg/protocol/prepared_stmt.pyx":185 + * p_oid = self.parameters_desc[i] + * codec = self.settings.get_data_codec(p_oid) + * if codec is None or not codec.has_encoder(): # <<<<<<<<<<<<<< + * raise RuntimeError('no encoder for OID {}'.format(p_oid)) + * if codec.type not in {}: + */ + __pyx_t_4 = (((PyObject *)__pyx_v_codec) == Py_None); + __pyx_t_3 = (__pyx_t_4 != 0); + if (!__pyx_t_3) { + } else { + __pyx_t_2 = __pyx_t_3; + goto __pyx_L9_bool_binop_done; + } + __pyx_t_1 = __pyx_f_7asyncpg_8protocol_8protocol_5Codec_has_encoder(__pyx_v_codec); if (unlikely(!__pyx_t_1)) __PYX_ERR(25, 185, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_3 = __Pyx_PyObject_IsTrue(__pyx_t_1); if (unlikely(__pyx_t_3 < 0)) __PYX_ERR(25, 185, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_4 = ((!__pyx_t_3) != 0); + __pyx_t_2 = __pyx_t_4; + __pyx_L9_bool_binop_done:; + if (__pyx_t_2) { + + /* "asyncpg/protocol/prepared_stmt.pyx":186 + * codec = self.settings.get_data_codec(p_oid) + * if codec is None or not codec.has_encoder(): + * raise RuntimeError('no encoder for OID {}'.format(p_oid)) # <<<<<<<<<<<<<< + * if codec.type not in {}: + * self.have_text_args = True + */ + __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_kp_u_no_encoder_for_OID, __pyx_n_s_format); if (unlikely(!__pyx_t_7)) __PYX_ERR(25, 186, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __pyx_t_8 = __Pyx_PyInt_From_int(__pyx_v_p_oid); if (unlikely(!__pyx_t_8)) __PYX_ERR(25, 186, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __pyx_t_9 = NULL; + if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_7))) { + __pyx_t_9 = PyMethod_GET_SELF(__pyx_t_7); + if (likely(__pyx_t_9)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_7); + __Pyx_INCREF(__pyx_t_9); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_7, function); + } + } + if (!__pyx_t_9) { + __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_t_7, __pyx_t_8); if (unlikely(!__pyx_t_1)) __PYX_ERR(25, 186, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + __Pyx_GOTREF(__pyx_t_1); + } else { + #if CYTHON_FAST_PYCALL + if (PyFunction_Check(__pyx_t_7)) { + PyObject *__pyx_temp[2] = {__pyx_t_9, __pyx_t_8}; + __pyx_t_1 = __Pyx_PyFunction_FastCall(__pyx_t_7, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_1)) __PYX_ERR(25, 186, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0; + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + } else + #endif + #if CYTHON_FAST_PYCCALL + if (__Pyx_PyFastCFunction_Check(__pyx_t_7)) { + PyObject *__pyx_temp[2] = {__pyx_t_9, __pyx_t_8}; + __pyx_t_1 = __Pyx_PyCFunction_FastCall(__pyx_t_7, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_1)) __PYX_ERR(25, 186, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0; + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + } else + #endif + { + __pyx_t_10 = PyTuple_New(1+1); if (unlikely(!__pyx_t_10)) __PYX_ERR(25, 186, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_10); + __Pyx_GIVEREF(__pyx_t_9); PyTuple_SET_ITEM(__pyx_t_10, 0, __pyx_t_9); __pyx_t_9 = NULL; + __Pyx_GIVEREF(__pyx_t_8); + PyTuple_SET_ITEM(__pyx_t_10, 0+1, __pyx_t_8); + __pyx_t_8 = 0; + __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_7, __pyx_t_10, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(25, 186, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; + } + } + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __pyx_t_7 = PyTuple_New(1); if (unlikely(!__pyx_t_7)) __PYX_ERR(25, 186, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __Pyx_GIVEREF(__pyx_t_1); + PyTuple_SET_ITEM(__pyx_t_7, 0, __pyx_t_1); + __pyx_t_1 = 0; + __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_RuntimeError, __pyx_t_7, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(25, 186, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_Raise(__pyx_t_1, 0, 0, 0); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __PYX_ERR(25, 186, __pyx_L1_error) + + /* "asyncpg/protocol/prepared_stmt.pyx":185 + * p_oid = self.parameters_desc[i] + * codec = self.settings.get_data_codec(p_oid) + * if codec is None or not codec.has_encoder(): # <<<<<<<<<<<<<< + * raise RuntimeError('no encoder for OID {}'.format(p_oid)) + * if codec.type not in {}: + */ + } + + /* "asyncpg/protocol/prepared_stmt.pyx":187 + * if codec is None or not codec.has_encoder(): + * raise RuntimeError('no encoder for OID {}'.format(p_oid)) + * if codec.type not in {}: # <<<<<<<<<<<<<< + * self.have_text_args = True + * + */ + __pyx_t_1 = __Pyx_PyInt_From_enum____pyx_t_7asyncpg_8protocol_8protocol_CodecType(__pyx_v_codec->type); if (unlikely(!__pyx_t_1)) __PYX_ERR(25, 187, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_7 = PyDict_New(); if (unlikely(!__pyx_t_7)) __PYX_ERR(25, 187, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __pyx_t_2 = (__Pyx_PyDict_ContainsTF(__pyx_t_1, __pyx_t_7, Py_NE)); if (unlikely(__pyx_t_2 < 0)) __PYX_ERR(25, 187, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __pyx_t_4 = (__pyx_t_2 != 0); + if (__pyx_t_4) { + + /* "asyncpg/protocol/prepared_stmt.pyx":188 + * raise RuntimeError('no encoder for OID {}'.format(p_oid)) + * if codec.type not in {}: + * self.have_text_args = True # <<<<<<<<<<<<<< + * + * codecs.append(codec) + */ + __pyx_v_self->have_text_args = 1; + + /* "asyncpg/protocol/prepared_stmt.pyx":187 + * if codec is None or not codec.has_encoder(): + * raise RuntimeError('no encoder for OID {}'.format(p_oid)) + * if codec.type not in {}: # <<<<<<<<<<<<<< + * self.have_text_args = True + * + */ + } + + /* "asyncpg/protocol/prepared_stmt.pyx":190 + * self.have_text_args = True + * + * codecs.append(codec) # <<<<<<<<<<<<<< + * + * self.args_codecs = tuple(codecs) + */ + __pyx_t_11 = __Pyx_PyList_Append(__pyx_v_codecs, ((PyObject *)__pyx_v_codec)); if (unlikely(__pyx_t_11 == -1)) __PYX_ERR(25, 190, __pyx_L1_error) + } + + /* "asyncpg/protocol/prepared_stmt.pyx":192 + * codecs.append(codec) + * + * self.args_codecs = tuple(codecs) # <<<<<<<<<<<<<< + * + * cdef _set_row_desc(self, object desc): + */ + __pyx_t_7 = PyList_AsTuple(__pyx_v_codecs); if (unlikely(!__pyx_t_7)) __PYX_ERR(25, 192, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __Pyx_GIVEREF(__pyx_t_7); + __Pyx_GOTREF(__pyx_v_self->args_codecs); + __Pyx_DECREF(__pyx_v_self->args_codecs); + __pyx_v_self->args_codecs = ((PyObject*)__pyx_t_7); + __pyx_t_7 = 0; + + /* "asyncpg/protocol/prepared_stmt.pyx":173 + * self.rows_codecs = tuple(codecs) + * + * cdef _ensure_args_encoder(self): # <<<<<<<<<<<<<< + * cdef: + * int p_oid + */ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_7); + __Pyx_XDECREF(__pyx_t_8); + __Pyx_XDECREF(__pyx_t_9); + __Pyx_XDECREF(__pyx_t_10); + __Pyx_AddTraceback("asyncpg.protocol.protocol.PreparedStatementState._ensure_args_encoder", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XDECREF((PyObject *)__pyx_v_codec); + __Pyx_XDECREF(__pyx_v_codecs); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "asyncpg/protocol/prepared_stmt.pyx":194 + * self.args_codecs = tuple(codecs) + * + * cdef _set_row_desc(self, object desc): # <<<<<<<<<<<<<< + * self.row_desc = _decode_row_desc(desc) + * self.cols_num = (len(self.row_desc)) + */ + +static PyObject *__pyx_f_7asyncpg_8protocol_8protocol_22PreparedStatementState__set_row_desc(struct __pyx_obj_7asyncpg_8protocol_8protocol_PreparedStatementState *__pyx_v_self, PyObject *__pyx_v_desc) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + Py_ssize_t __pyx_t_2; + __Pyx_RefNannySetupContext("_set_row_desc", 0); + + /* "asyncpg/protocol/prepared_stmt.pyx":195 + * + * cdef _set_row_desc(self, object desc): + * self.row_desc = _decode_row_desc(desc) # <<<<<<<<<<<<<< + * self.cols_num = (len(self.row_desc)) + * + */ + __pyx_t_1 = __pyx_f_7asyncpg_8protocol_8protocol__decode_row_desc(__pyx_v_desc); if (unlikely(!__pyx_t_1)) __PYX_ERR(25, 195, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (!(likely(PyList_CheckExact(__pyx_t_1))||((__pyx_t_1) == Py_None)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "list", Py_TYPE(__pyx_t_1)->tp_name), 0))) __PYX_ERR(25, 195, __pyx_L1_error) + __Pyx_GIVEREF(__pyx_t_1); + __Pyx_GOTREF(__pyx_v_self->row_desc); + __Pyx_DECREF(__pyx_v_self->row_desc); + __pyx_v_self->row_desc = ((PyObject*)__pyx_t_1); + __pyx_t_1 = 0; + + /* "asyncpg/protocol/prepared_stmt.pyx":196 + * cdef _set_row_desc(self, object desc): + * self.row_desc = _decode_row_desc(desc) + * self.cols_num = (len(self.row_desc)) # <<<<<<<<<<<<<< + * + * cdef _set_args_desc(self, object desc): + */ + __pyx_t_1 = __pyx_v_self->row_desc; + __Pyx_INCREF(__pyx_t_1); + if (unlikely(__pyx_t_1 == Py_None)) { + PyErr_SetString(PyExc_TypeError, "object of type 'NoneType' has no len()"); + __PYX_ERR(25, 196, __pyx_L1_error) + } + __pyx_t_2 = PyList_GET_SIZE(__pyx_t_1); if (unlikely(__pyx_t_2 == -1)) __PYX_ERR(25, 196, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_v_self->cols_num = ((int16_t)__pyx_t_2); + + /* "asyncpg/protocol/prepared_stmt.pyx":194 + * self.args_codecs = tuple(codecs) + * + * cdef _set_row_desc(self, object desc): # <<<<<<<<<<<<<< + * self.row_desc = _decode_row_desc(desc) + * self.cols_num = (len(self.row_desc)) + */ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("asyncpg.protocol.protocol.PreparedStatementState._set_row_desc", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "asyncpg/protocol/prepared_stmt.pyx":198 + * self.cols_num = (len(self.row_desc)) + * + * cdef _set_args_desc(self, object desc): # <<<<<<<<<<<<<< + * self.parameters_desc = _decode_parameters_desc(desc) + * self.args_num = (len(self.parameters_desc)) + */ + +static PyObject *__pyx_f_7asyncpg_8protocol_8protocol_22PreparedStatementState__set_args_desc(struct __pyx_obj_7asyncpg_8protocol_8protocol_PreparedStatementState *__pyx_v_self, PyObject *__pyx_v_desc) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + Py_ssize_t __pyx_t_2; + __Pyx_RefNannySetupContext("_set_args_desc", 0); + + /* "asyncpg/protocol/prepared_stmt.pyx":199 + * + * cdef _set_args_desc(self, object desc): + * self.parameters_desc = _decode_parameters_desc(desc) # <<<<<<<<<<<<<< + * self.args_num = (len(self.parameters_desc)) + * + */ + __pyx_t_1 = __pyx_f_7asyncpg_8protocol_8protocol__decode_parameters_desc(__pyx_v_desc); if (unlikely(!__pyx_t_1)) __PYX_ERR(25, 199, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (!(likely(PyList_CheckExact(__pyx_t_1))||((__pyx_t_1) == Py_None)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "list", Py_TYPE(__pyx_t_1)->tp_name), 0))) __PYX_ERR(25, 199, __pyx_L1_error) + __Pyx_GIVEREF(__pyx_t_1); + __Pyx_GOTREF(__pyx_v_self->parameters_desc); + __Pyx_DECREF(__pyx_v_self->parameters_desc); + __pyx_v_self->parameters_desc = ((PyObject*)__pyx_t_1); + __pyx_t_1 = 0; + + /* "asyncpg/protocol/prepared_stmt.pyx":200 + * cdef _set_args_desc(self, object desc): + * self.parameters_desc = _decode_parameters_desc(desc) + * self.args_num = (len(self.parameters_desc)) # <<<<<<<<<<<<<< + * + * cdef _decode_row(self, const char* cbuf, ssize_t buf_len): + */ + __pyx_t_1 = __pyx_v_self->parameters_desc; + __Pyx_INCREF(__pyx_t_1); + if (unlikely(__pyx_t_1 == Py_None)) { + PyErr_SetString(PyExc_TypeError, "object of type 'NoneType' has no len()"); + __PYX_ERR(25, 200, __pyx_L1_error) + } + __pyx_t_2 = PyList_GET_SIZE(__pyx_t_1); if (unlikely(__pyx_t_2 == -1)) __PYX_ERR(25, 200, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_v_self->args_num = ((int16_t)__pyx_t_2); + + /* "asyncpg/protocol/prepared_stmt.pyx":198 + * self.cols_num = (len(self.row_desc)) + * + * cdef _set_args_desc(self, object desc): # <<<<<<<<<<<<<< + * self.parameters_desc = _decode_parameters_desc(desc) + * self.args_num = (len(self.parameters_desc)) + */ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("asyncpg.protocol.protocol.PreparedStatementState._set_args_desc", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "asyncpg/protocol/prepared_stmt.pyx":202 + * self.args_num = (len(self.parameters_desc)) + * + * cdef _decode_row(self, const char* cbuf, ssize_t buf_len): # <<<<<<<<<<<<<< + * cdef: + * Codec codec + */ + +static PyObject *__pyx_f_7asyncpg_8protocol_8protocol_22PreparedStatementState__decode_row(struct __pyx_obj_7asyncpg_8protocol_8protocol_PreparedStatementState *__pyx_v_self, char const *__pyx_v_cbuf, Py_ssize_t __pyx_v_buf_len) { + struct __pyx_obj_7asyncpg_8protocol_8protocol_Codec *__pyx_v_codec = 0; + int16_t __pyx_v_fnum; + int32_t __pyx_v_flen; + PyObject *__pyx_v_dec_row = 0; + PyObject *__pyx_v_rows_codecs = 0; + struct __pyx_obj_7asyncpg_8protocol_8protocol_ConnectionSettings *__pyx_v_settings = 0; + int32_t __pyx_v_i; + struct __pyx_obj_7asyncpg_8protocol_8protocol_FastReadBuffer *__pyx_v_rbuf = 0; + Py_ssize_t __pyx_v_bl; + PyObject *__pyx_v_val = NULL; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + char const *__pyx_t_2; + int __pyx_t_3; + PyObject *__pyx_t_4 = NULL; + PyObject *__pyx_t_5 = NULL; + PyObject *__pyx_t_6 = NULL; + PyObject *__pyx_t_7 = NULL; + int __pyx_t_8; + PyObject *__pyx_t_9 = NULL; + int __pyx_t_10; + int __pyx_t_11; + Py_ssize_t __pyx_t_12; + int16_t __pyx_t_13; + int32_t __pyx_t_14; + Py_ssize_t __pyx_t_15; + PyObject *__pyx_t_16; + PyObject *__pyx_t_17 = NULL; + __Pyx_RefNannySetupContext("_decode_row", 0); + + /* "asyncpg/protocol/prepared_stmt.pyx":208 + * int32_t flen + * object dec_row + * tuple rows_codecs = self.rows_codecs # <<<<<<<<<<<<<< + * ConnectionSettings settings = self.settings + * int32_t i + */ + __pyx_t_1 = __pyx_v_self->rows_codecs; + __Pyx_INCREF(__pyx_t_1); + __pyx_v_rows_codecs = ((PyObject*)__pyx_t_1); + __pyx_t_1 = 0; + + /* "asyncpg/protocol/prepared_stmt.pyx":209 + * object dec_row + * tuple rows_codecs = self.rows_codecs + * ConnectionSettings settings = self.settings # <<<<<<<<<<<<<< + * int32_t i + * FastReadBuffer rbuf = self.buffer + */ + __pyx_t_1 = ((PyObject *)__pyx_v_self->settings); + __Pyx_INCREF(__pyx_t_1); + __pyx_v_settings = ((struct __pyx_obj_7asyncpg_8protocol_8protocol_ConnectionSettings *)__pyx_t_1); + __pyx_t_1 = 0; + + /* "asyncpg/protocol/prepared_stmt.pyx":211 + * ConnectionSettings settings = self.settings + * int32_t i + * FastReadBuffer rbuf = self.buffer # <<<<<<<<<<<<<< + * ssize_t bl + * + */ + __pyx_t_1 = ((PyObject *)__pyx_v_self->buffer); + __Pyx_INCREF(__pyx_t_1); + __pyx_v_rbuf = ((struct __pyx_obj_7asyncpg_8protocol_8protocol_FastReadBuffer *)__pyx_t_1); + __pyx_t_1 = 0; + + /* "asyncpg/protocol/prepared_stmt.pyx":214 + * ssize_t bl + * + * rbuf.buf = cbuf # <<<<<<<<<<<<<< + * rbuf.len = buf_len + * + */ + __pyx_v_rbuf->buf = __pyx_v_cbuf; + + /* "asyncpg/protocol/prepared_stmt.pyx":215 + * + * rbuf.buf = cbuf + * rbuf.len = buf_len # <<<<<<<<<<<<<< + * + * fnum = hton.unpack_int16(rbuf.read(2)) + */ + __pyx_v_rbuf->len = __pyx_v_buf_len; + + /* "asyncpg/protocol/prepared_stmt.pyx":217 + * rbuf.len = buf_len + * + * fnum = hton.unpack_int16(rbuf.read(2)) # <<<<<<<<<<<<<< + * + * if fnum != self.cols_num: + */ + __pyx_t_2 = __pyx_f_7asyncpg_8protocol_8protocol_14FastReadBuffer_read(__pyx_v_rbuf, 2); if (unlikely(__pyx_t_2 == NULL)) __PYX_ERR(25, 217, __pyx_L1_error) + __pyx_v_fnum = __pyx_f_7asyncpg_8protocol_4hton_unpack_int16(__pyx_t_2); + + /* "asyncpg/protocol/prepared_stmt.pyx":219 + * fnum = hton.unpack_int16(rbuf.read(2)) + * + * if fnum != self.cols_num: # <<<<<<<<<<<<<< + * raise RuntimeError( + * 'number of columns in result ({}) is ' + */ + __pyx_t_3 = ((__pyx_v_fnum != __pyx_v_self->cols_num) != 0); + if (__pyx_t_3) { + + /* "asyncpg/protocol/prepared_stmt.pyx":222 + * raise RuntimeError( + * 'number of columns in result ({}) is ' + * 'different from what was described ({})'.format( # <<<<<<<<<<<<<< + * fnum, self.cols_num)) + * + */ + __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_kp_u_number_of_columns_in_result_is_d, __pyx_n_s_format); if (unlikely(!__pyx_t_4)) __PYX_ERR(25, 222, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + + /* "asyncpg/protocol/prepared_stmt.pyx":223 + * 'number of columns in result ({}) is ' + * 'different from what was described ({})'.format( + * fnum, self.cols_num)) # <<<<<<<<<<<<<< + * + * if rows_codecs is None or len(rows_codecs) < fnum: + */ + __pyx_t_5 = __Pyx_PyInt_From_int16_t(__pyx_v_fnum); if (unlikely(!__pyx_t_5)) __PYX_ERR(25, 223, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_6 = __Pyx_PyInt_From_int16_t(__pyx_v_self->cols_num); if (unlikely(!__pyx_t_6)) __PYX_ERR(25, 223, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_7 = NULL; + __pyx_t_8 = 0; + if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_4))) { + __pyx_t_7 = PyMethod_GET_SELF(__pyx_t_4); + if (likely(__pyx_t_7)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4); + __Pyx_INCREF(__pyx_t_7); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_4, function); + __pyx_t_8 = 1; + } + } + #if CYTHON_FAST_PYCALL + if (PyFunction_Check(__pyx_t_4)) { + PyObject *__pyx_temp[3] = {__pyx_t_7, __pyx_t_5, __pyx_t_6}; + __pyx_t_1 = __Pyx_PyFunction_FastCall(__pyx_t_4, __pyx_temp+1-__pyx_t_8, 2+__pyx_t_8); if (unlikely(!__pyx_t_1)) __PYX_ERR(25, 222, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + } else + #endif + #if CYTHON_FAST_PYCCALL + if (__Pyx_PyFastCFunction_Check(__pyx_t_4)) { + PyObject *__pyx_temp[3] = {__pyx_t_7, __pyx_t_5, __pyx_t_6}; + __pyx_t_1 = __Pyx_PyCFunction_FastCall(__pyx_t_4, __pyx_temp+1-__pyx_t_8, 2+__pyx_t_8); if (unlikely(!__pyx_t_1)) __PYX_ERR(25, 222, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + } else + #endif + { + __pyx_t_9 = PyTuple_New(2+__pyx_t_8); if (unlikely(!__pyx_t_9)) __PYX_ERR(25, 222, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_9); + if (__pyx_t_7) { + __Pyx_GIVEREF(__pyx_t_7); PyTuple_SET_ITEM(__pyx_t_9, 0, __pyx_t_7); __pyx_t_7 = NULL; + } + __Pyx_GIVEREF(__pyx_t_5); + PyTuple_SET_ITEM(__pyx_t_9, 0+__pyx_t_8, __pyx_t_5); + __Pyx_GIVEREF(__pyx_t_6); + PyTuple_SET_ITEM(__pyx_t_9, 1+__pyx_t_8, __pyx_t_6); + __pyx_t_5 = 0; + __pyx_t_6 = 0; + __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_4, __pyx_t_9, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(25, 222, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + } + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + + /* "asyncpg/protocol/prepared_stmt.pyx":220 + * + * if fnum != self.cols_num: + * raise RuntimeError( # <<<<<<<<<<<<<< + * 'number of columns in result ({}) is ' + * 'different from what was described ({})'.format( + */ + __pyx_t_4 = PyTuple_New(1); if (unlikely(!__pyx_t_4)) __PYX_ERR(25, 220, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_GIVEREF(__pyx_t_1); + PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_1); + __pyx_t_1 = 0; + __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_RuntimeError, __pyx_t_4, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(25, 220, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_Raise(__pyx_t_1, 0, 0, 0); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __PYX_ERR(25, 220, __pyx_L1_error) + + /* "asyncpg/protocol/prepared_stmt.pyx":219 + * fnum = hton.unpack_int16(rbuf.read(2)) + * + * if fnum != self.cols_num: # <<<<<<<<<<<<<< + * raise RuntimeError( + * 'number of columns in result ({}) is ' + */ + } + + /* "asyncpg/protocol/prepared_stmt.pyx":225 + * fnum, self.cols_num)) + * + * if rows_codecs is None or len(rows_codecs) < fnum: # <<<<<<<<<<<<<< + * if fnum > 0: + * # It's OK to have no rows_codecs for empty records + */ + __pyx_t_10 = (__pyx_v_rows_codecs == ((PyObject*)Py_None)); + __pyx_t_11 = (__pyx_t_10 != 0); + if (!__pyx_t_11) { + } else { + __pyx_t_3 = __pyx_t_11; + goto __pyx_L5_bool_binop_done; + } + if (unlikely(__pyx_v_rows_codecs == Py_None)) { + PyErr_SetString(PyExc_TypeError, "object of type 'NoneType' has no len()"); + __PYX_ERR(25, 225, __pyx_L1_error) + } + __pyx_t_12 = PyTuple_GET_SIZE(__pyx_v_rows_codecs); if (unlikely(__pyx_t_12 == -1)) __PYX_ERR(25, 225, __pyx_L1_error) + __pyx_t_11 = ((__pyx_t_12 < __pyx_v_fnum) != 0); + __pyx_t_3 = __pyx_t_11; + __pyx_L5_bool_binop_done:; + if (__pyx_t_3) { + + /* "asyncpg/protocol/prepared_stmt.pyx":226 + * + * if rows_codecs is None or len(rows_codecs) < fnum: + * if fnum > 0: # <<<<<<<<<<<<<< + * # It's OK to have no rows_codecs for empty records + * raise RuntimeError('invalid rows_codecs') + */ + __pyx_t_3 = ((__pyx_v_fnum > 0) != 0); + if (__pyx_t_3) { + + /* "asyncpg/protocol/prepared_stmt.pyx":228 + * if fnum > 0: + * # It's OK to have no rows_codecs for empty records + * raise RuntimeError('invalid rows_codecs') # <<<<<<<<<<<<<< + * + * dec_row = record.ApgRecord_New(self.cols_desc, fnum) + */ + __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_RuntimeError, __pyx_tuple__69, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(25, 228, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_Raise(__pyx_t_1, 0, 0, 0); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __PYX_ERR(25, 228, __pyx_L1_error) + + /* "asyncpg/protocol/prepared_stmt.pyx":226 + * + * if rows_codecs is None or len(rows_codecs) < fnum: + * if fnum > 0: # <<<<<<<<<<<<<< + * # It's OK to have no rows_codecs for empty records + * raise RuntimeError('invalid rows_codecs') + */ + } + + /* "asyncpg/protocol/prepared_stmt.pyx":225 + * fnum, self.cols_num)) + * + * if rows_codecs is None or len(rows_codecs) < fnum: # <<<<<<<<<<<<<< + * if fnum > 0: + * # It's OK to have no rows_codecs for empty records + */ + } + + /* "asyncpg/protocol/prepared_stmt.pyx":230 + * raise RuntimeError('invalid rows_codecs') + * + * dec_row = record.ApgRecord_New(self.cols_desc, fnum) # <<<<<<<<<<<<<< + * for i in range(fnum): + * flen = hton.unpack_int32(rbuf.read(4)) + */ + __pyx_t_1 = __pyx_v_self->cols_desc; + __Pyx_INCREF(__pyx_t_1); + __pyx_t_4 = ApgRecord_New(__pyx_t_1, __pyx_v_fnum); if (unlikely(!__pyx_t_4)) __PYX_ERR(25, 230, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_v_dec_row = __pyx_t_4; + __pyx_t_4 = 0; + + /* "asyncpg/protocol/prepared_stmt.pyx":231 + * + * dec_row = record.ApgRecord_New(self.cols_desc, fnum) + * for i in range(fnum): # <<<<<<<<<<<<<< + * flen = hton.unpack_int32(rbuf.read(4)) + * + */ + __pyx_t_13 = __pyx_v_fnum; + for (__pyx_t_14 = 0; __pyx_t_14 < __pyx_t_13; __pyx_t_14+=1) { + __pyx_v_i = __pyx_t_14; + + /* "asyncpg/protocol/prepared_stmt.pyx":232 + * dec_row = record.ApgRecord_New(self.cols_desc, fnum) + * for i in range(fnum): + * flen = hton.unpack_int32(rbuf.read(4)) # <<<<<<<<<<<<<< + * + * if flen == -1: + */ + __pyx_t_2 = __pyx_f_7asyncpg_8protocol_8protocol_14FastReadBuffer_read(__pyx_v_rbuf, 4); if (unlikely(__pyx_t_2 == NULL)) __PYX_ERR(25, 232, __pyx_L1_error) + __pyx_v_flen = __pyx_f_7asyncpg_8protocol_4hton_unpack_int32(__pyx_t_2); + + /* "asyncpg/protocol/prepared_stmt.pyx":234 + * flen = hton.unpack_int32(rbuf.read(4)) + * + * if flen == -1: # <<<<<<<<<<<<<< + * val = None + * else: + */ + __pyx_t_3 = ((__pyx_v_flen == -1L) != 0); + if (__pyx_t_3) { + + /* "asyncpg/protocol/prepared_stmt.pyx":235 + * + * if flen == -1: + * val = None # <<<<<<<<<<<<<< + * else: + * # Clamp buffer size to that of the reported field length + */ + __Pyx_INCREF(Py_None); + __Pyx_XDECREF_SET(__pyx_v_val, Py_None); + + /* "asyncpg/protocol/prepared_stmt.pyx":234 + * flen = hton.unpack_int32(rbuf.read(4)) + * + * if flen == -1: # <<<<<<<<<<<<<< + * val = None + * else: + */ + goto __pyx_L10; + } + + /* "asyncpg/protocol/prepared_stmt.pyx":240 + * # to make sure that codecs can rely on read_all() working + * # properly. + * bl = rbuf.len # <<<<<<<<<<<<<< + * if flen > bl: + * # Check for overflow + */ + /*else*/ { + __pyx_t_15 = __pyx_v_rbuf->len; + __pyx_v_bl = __pyx_t_15; + + /* "asyncpg/protocol/prepared_stmt.pyx":241 + * # properly. + * bl = rbuf.len + * if flen > bl: # <<<<<<<<<<<<<< + * # Check for overflow + * rbuf._raise_ins_err(flen, bl) + */ + __pyx_t_3 = ((__pyx_v_flen > __pyx_v_bl) != 0); + if (__pyx_t_3) { + + /* "asyncpg/protocol/prepared_stmt.pyx":243 + * if flen > bl: + * # Check for overflow + * rbuf._raise_ins_err(flen, bl) # <<<<<<<<<<<<<< + * rbuf.len = flen + * codec = cpython.PyTuple_GET_ITEM(rows_codecs, i) + */ + __pyx_t_4 = __pyx_f_7asyncpg_8protocol_8protocol_14FastReadBuffer__raise_ins_err(__pyx_v_rbuf, __pyx_v_flen, __pyx_v_bl); if (unlikely(!__pyx_t_4)) __PYX_ERR(25, 243, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + + /* "asyncpg/protocol/prepared_stmt.pyx":241 + * # properly. + * bl = rbuf.len + * if flen > bl: # <<<<<<<<<<<<<< + * # Check for overflow + * rbuf._raise_ins_err(flen, bl) + */ + } + + /* "asyncpg/protocol/prepared_stmt.pyx":244 + * # Check for overflow + * rbuf._raise_ins_err(flen, bl) + * rbuf.len = flen # <<<<<<<<<<<<<< + * codec = cpython.PyTuple_GET_ITEM(rows_codecs, i) + * val = codec.decode(settings, rbuf) + */ + __pyx_v_rbuf->len = __pyx_v_flen; + + /* "asyncpg/protocol/prepared_stmt.pyx":245 + * rbuf._raise_ins_err(flen, bl) + * rbuf.len = flen + * codec = cpython.PyTuple_GET_ITEM(rows_codecs, i) # <<<<<<<<<<<<<< + * val = codec.decode(settings, rbuf) + * if rbuf.len != 0: + */ + __pyx_t_16 = PyTuple_GET_ITEM(__pyx_v_rows_codecs, __pyx_v_i); + __pyx_t_4 = ((PyObject *)__pyx_t_16); + __Pyx_INCREF(__pyx_t_4); + __Pyx_XDECREF_SET(__pyx_v_codec, ((struct __pyx_obj_7asyncpg_8protocol_8protocol_Codec *)__pyx_t_4)); + __pyx_t_4 = 0; + + /* "asyncpg/protocol/prepared_stmt.pyx":246 + * rbuf.len = flen + * codec = cpython.PyTuple_GET_ITEM(rows_codecs, i) + * val = codec.decode(settings, rbuf) # <<<<<<<<<<<<<< + * if rbuf.len != 0: + * raise BufferError( + */ + __pyx_t_4 = __pyx_f_7asyncpg_8protocol_8protocol_5Codec_decode(__pyx_v_codec, __pyx_v_settings, __pyx_v_rbuf); if (unlikely(!__pyx_t_4)) __PYX_ERR(25, 246, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_XDECREF_SET(__pyx_v_val, __pyx_t_4); + __pyx_t_4 = 0; + + /* "asyncpg/protocol/prepared_stmt.pyx":247 + * codec = cpython.PyTuple_GET_ITEM(rows_codecs, i) + * val = codec.decode(settings, rbuf) + * if rbuf.len != 0: # <<<<<<<<<<<<<< + * raise BufferError( + * 'unexpected trailing {} bytes in buffer'.format( + */ + __pyx_t_3 = ((__pyx_v_rbuf->len != 0) != 0); + if (__pyx_t_3) { + + /* "asyncpg/protocol/prepared_stmt.pyx":248 + * val = codec.decode(settings, rbuf) + * if rbuf.len != 0: + * raise BufferError( # <<<<<<<<<<<<<< + * 'unexpected trailing {} bytes in buffer'.format( + * rbuf.len)) + */ + __pyx_t_1 = __Pyx_GetModuleGlobalName(__pyx_n_s_BufferError); if (unlikely(!__pyx_t_1)) __PYX_ERR(25, 248, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + + /* "asyncpg/protocol/prepared_stmt.pyx":249 + * if rbuf.len != 0: + * raise BufferError( + * 'unexpected trailing {} bytes in buffer'.format( # <<<<<<<<<<<<<< + * rbuf.len)) + * rbuf.len = bl - flen + */ + __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_kp_u_unexpected_trailing_bytes_in_buf, __pyx_n_s_format); if (unlikely(!__pyx_t_6)) __PYX_ERR(25, 249, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + + /* "asyncpg/protocol/prepared_stmt.pyx":250 + * raise BufferError( + * 'unexpected trailing {} bytes in buffer'.format( + * rbuf.len)) # <<<<<<<<<<<<<< + * rbuf.len = bl - flen + * + */ + __pyx_t_5 = PyInt_FromSsize_t(__pyx_v_rbuf->len); if (unlikely(!__pyx_t_5)) __PYX_ERR(25, 250, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_7 = NULL; + if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_6))) { + __pyx_t_7 = PyMethod_GET_SELF(__pyx_t_6); + if (likely(__pyx_t_7)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_6); + __Pyx_INCREF(__pyx_t_7); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_6, function); + } + } + if (!__pyx_t_7) { + __pyx_t_9 = __Pyx_PyObject_CallOneArg(__pyx_t_6, __pyx_t_5); if (unlikely(!__pyx_t_9)) __PYX_ERR(25, 249, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_GOTREF(__pyx_t_9); + } else { + #if CYTHON_FAST_PYCALL + if (PyFunction_Check(__pyx_t_6)) { + PyObject *__pyx_temp[2] = {__pyx_t_7, __pyx_t_5}; + __pyx_t_9 = __Pyx_PyFunction_FastCall(__pyx_t_6, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_9)) __PYX_ERR(25, 249, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_GOTREF(__pyx_t_9); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + } else + #endif + #if CYTHON_FAST_PYCCALL + if (__Pyx_PyFastCFunction_Check(__pyx_t_6)) { + PyObject *__pyx_temp[2] = {__pyx_t_7, __pyx_t_5}; + __pyx_t_9 = __Pyx_PyCFunction_FastCall(__pyx_t_6, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_9)) __PYX_ERR(25, 249, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_GOTREF(__pyx_t_9); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + } else + #endif + { + __pyx_t_17 = PyTuple_New(1+1); if (unlikely(!__pyx_t_17)) __PYX_ERR(25, 249, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_17); + __Pyx_GIVEREF(__pyx_t_7); PyTuple_SET_ITEM(__pyx_t_17, 0, __pyx_t_7); __pyx_t_7 = NULL; + __Pyx_GIVEREF(__pyx_t_5); + PyTuple_SET_ITEM(__pyx_t_17, 0+1, __pyx_t_5); + __pyx_t_5 = 0; + __pyx_t_9 = __Pyx_PyObject_Call(__pyx_t_6, __pyx_t_17, NULL); if (unlikely(!__pyx_t_9)) __PYX_ERR(25, 249, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_9); + __Pyx_DECREF(__pyx_t_17); __pyx_t_17 = 0; + } + } + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __pyx_t_6 = NULL; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_1))) { + __pyx_t_6 = PyMethod_GET_SELF(__pyx_t_1); + if (likely(__pyx_t_6)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_1); + __Pyx_INCREF(__pyx_t_6); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_1, function); + } + } + if (!__pyx_t_6) { + __pyx_t_4 = __Pyx_PyObject_CallOneArg(__pyx_t_1, __pyx_t_9); if (unlikely(!__pyx_t_4)) __PYX_ERR(25, 248, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + __Pyx_GOTREF(__pyx_t_4); + } else { + #if CYTHON_FAST_PYCALL + if (PyFunction_Check(__pyx_t_1)) { + PyObject *__pyx_temp[2] = {__pyx_t_6, __pyx_t_9}; + __pyx_t_4 = __Pyx_PyFunction_FastCall(__pyx_t_1, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_4)) __PYX_ERR(25, 248, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + } else + #endif + #if CYTHON_FAST_PYCCALL + if (__Pyx_PyFastCFunction_Check(__pyx_t_1)) { + PyObject *__pyx_temp[2] = {__pyx_t_6, __pyx_t_9}; + __pyx_t_4 = __Pyx_PyCFunction_FastCall(__pyx_t_1, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_4)) __PYX_ERR(25, 248, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + } else + #endif + { + __pyx_t_17 = PyTuple_New(1+1); if (unlikely(!__pyx_t_17)) __PYX_ERR(25, 248, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_17); + __Pyx_GIVEREF(__pyx_t_6); PyTuple_SET_ITEM(__pyx_t_17, 0, __pyx_t_6); __pyx_t_6 = NULL; + __Pyx_GIVEREF(__pyx_t_9); + PyTuple_SET_ITEM(__pyx_t_17, 0+1, __pyx_t_9); + __pyx_t_9 = 0; + __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_t_17, NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(25, 248, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_17); __pyx_t_17 = 0; + } + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_Raise(__pyx_t_4, 0, 0, 0); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __PYX_ERR(25, 248, __pyx_L1_error) + + /* "asyncpg/protocol/prepared_stmt.pyx":247 + * codec = cpython.PyTuple_GET_ITEM(rows_codecs, i) + * val = codec.decode(settings, rbuf) + * if rbuf.len != 0: # <<<<<<<<<<<<<< + * raise BufferError( + * 'unexpected trailing {} bytes in buffer'.format( + */ + } + + /* "asyncpg/protocol/prepared_stmt.pyx":251 + * 'unexpected trailing {} bytes in buffer'.format( + * rbuf.len)) + * rbuf.len = bl - flen # <<<<<<<<<<<<<< + * + * cpython.Py_INCREF(val) + */ + __pyx_v_rbuf->len = (__pyx_v_bl - __pyx_v_flen); + } + __pyx_L10:; + + /* "asyncpg/protocol/prepared_stmt.pyx":253 + * rbuf.len = bl - flen + * + * cpython.Py_INCREF(val) # <<<<<<<<<<<<<< + * record.ApgRecord_SET_ITEM(dec_row, i, val) + * + */ + Py_INCREF(__pyx_v_val); + + /* "asyncpg/protocol/prepared_stmt.pyx":254 + * + * cpython.Py_INCREF(val) + * record.ApgRecord_SET_ITEM(dec_row, i, val) # <<<<<<<<<<<<<< + * + * if rbuf.len != 0: + */ + ApgRecord_SET_ITEM(__pyx_v_dec_row, __pyx_v_i, __pyx_v_val); + } + + /* "asyncpg/protocol/prepared_stmt.pyx":256 + * record.ApgRecord_SET_ITEM(dec_row, i, val) + * + * if rbuf.len != 0: # <<<<<<<<<<<<<< + * raise BufferError('unexpected trailing {} bytes in buffer'.format( + * rbuf.len)) + */ + __pyx_t_3 = ((__pyx_v_rbuf->len != 0) != 0); + if (__pyx_t_3) { + + /* "asyncpg/protocol/prepared_stmt.pyx":257 + * + * if rbuf.len != 0: + * raise BufferError('unexpected trailing {} bytes in buffer'.format( # <<<<<<<<<<<<<< + * rbuf.len)) + * + */ + __pyx_t_1 = __Pyx_GetModuleGlobalName(__pyx_n_s_BufferError); if (unlikely(!__pyx_t_1)) __PYX_ERR(25, 257, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_9 = __Pyx_PyObject_GetAttrStr(__pyx_kp_u_unexpected_trailing_bytes_in_buf, __pyx_n_s_format); if (unlikely(!__pyx_t_9)) __PYX_ERR(25, 257, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_9); + + /* "asyncpg/protocol/prepared_stmt.pyx":258 + * if rbuf.len != 0: + * raise BufferError('unexpected trailing {} bytes in buffer'.format( + * rbuf.len)) # <<<<<<<<<<<<<< + * + * return dec_row + */ + __pyx_t_6 = PyInt_FromSsize_t(__pyx_v_rbuf->len); if (unlikely(!__pyx_t_6)) __PYX_ERR(25, 258, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_5 = NULL; + if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_9))) { + __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_9); + if (likely(__pyx_t_5)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_9); + __Pyx_INCREF(__pyx_t_5); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_9, function); + } + } + if (!__pyx_t_5) { + __pyx_t_17 = __Pyx_PyObject_CallOneArg(__pyx_t_9, __pyx_t_6); if (unlikely(!__pyx_t_17)) __PYX_ERR(25, 257, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_GOTREF(__pyx_t_17); + } else { + #if CYTHON_FAST_PYCALL + if (PyFunction_Check(__pyx_t_9)) { + PyObject *__pyx_temp[2] = {__pyx_t_5, __pyx_t_6}; + __pyx_t_17 = __Pyx_PyFunction_FastCall(__pyx_t_9, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_17)) __PYX_ERR(25, 257, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_GOTREF(__pyx_t_17); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + } else + #endif + #if CYTHON_FAST_PYCCALL + if (__Pyx_PyFastCFunction_Check(__pyx_t_9)) { + PyObject *__pyx_temp[2] = {__pyx_t_5, __pyx_t_6}; + __pyx_t_17 = __Pyx_PyCFunction_FastCall(__pyx_t_9, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_17)) __PYX_ERR(25, 257, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_GOTREF(__pyx_t_17); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + } else + #endif + { + __pyx_t_7 = PyTuple_New(1+1); if (unlikely(!__pyx_t_7)) __PYX_ERR(25, 257, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __Pyx_GIVEREF(__pyx_t_5); PyTuple_SET_ITEM(__pyx_t_7, 0, __pyx_t_5); __pyx_t_5 = NULL; + __Pyx_GIVEREF(__pyx_t_6); + PyTuple_SET_ITEM(__pyx_t_7, 0+1, __pyx_t_6); + __pyx_t_6 = 0; + __pyx_t_17 = __Pyx_PyObject_Call(__pyx_t_9, __pyx_t_7, NULL); if (unlikely(!__pyx_t_17)) __PYX_ERR(25, 257, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_17); + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + } + } + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + __pyx_t_9 = NULL; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_1))) { + __pyx_t_9 = PyMethod_GET_SELF(__pyx_t_1); + if (likely(__pyx_t_9)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_1); + __Pyx_INCREF(__pyx_t_9); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_1, function); + } + } + if (!__pyx_t_9) { + __pyx_t_4 = __Pyx_PyObject_CallOneArg(__pyx_t_1, __pyx_t_17); if (unlikely(!__pyx_t_4)) __PYX_ERR(25, 257, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_17); __pyx_t_17 = 0; + __Pyx_GOTREF(__pyx_t_4); + } else { + #if CYTHON_FAST_PYCALL + if (PyFunction_Check(__pyx_t_1)) { + PyObject *__pyx_temp[2] = {__pyx_t_9, __pyx_t_17}; + __pyx_t_4 = __Pyx_PyFunction_FastCall(__pyx_t_1, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_4)) __PYX_ERR(25, 257, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0; + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_17); __pyx_t_17 = 0; + } else + #endif + #if CYTHON_FAST_PYCCALL + if (__Pyx_PyFastCFunction_Check(__pyx_t_1)) { + PyObject *__pyx_temp[2] = {__pyx_t_9, __pyx_t_17}; + __pyx_t_4 = __Pyx_PyCFunction_FastCall(__pyx_t_1, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_4)) __PYX_ERR(25, 257, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0; + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_17); __pyx_t_17 = 0; + } else + #endif + { + __pyx_t_7 = PyTuple_New(1+1); if (unlikely(!__pyx_t_7)) __PYX_ERR(25, 257, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __Pyx_GIVEREF(__pyx_t_9); PyTuple_SET_ITEM(__pyx_t_7, 0, __pyx_t_9); __pyx_t_9 = NULL; + __Pyx_GIVEREF(__pyx_t_17); + PyTuple_SET_ITEM(__pyx_t_7, 0+1, __pyx_t_17); + __pyx_t_17 = 0; + __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_t_7, NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(25, 257, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + } + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_Raise(__pyx_t_4, 0, 0, 0); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __PYX_ERR(25, 257, __pyx_L1_error) + + /* "asyncpg/protocol/prepared_stmt.pyx":256 + * record.ApgRecord_SET_ITEM(dec_row, i, val) + * + * if rbuf.len != 0: # <<<<<<<<<<<<<< + * raise BufferError('unexpected trailing {} bytes in buffer'.format( + * rbuf.len)) + */ + } + + /* "asyncpg/protocol/prepared_stmt.pyx":260 + * rbuf.len)) + * + * return dec_row # <<<<<<<<<<<<<< + * + * + */ + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(__pyx_v_dec_row); + __pyx_r = __pyx_v_dec_row; + goto __pyx_L0; + + /* "asyncpg/protocol/prepared_stmt.pyx":202 + * self.args_num = (len(self.parameters_desc)) + * + * cdef _decode_row(self, const char* cbuf, ssize_t buf_len): # <<<<<<<<<<<<<< + * cdef: + * Codec codec + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_XDECREF(__pyx_t_6); + __Pyx_XDECREF(__pyx_t_7); + __Pyx_XDECREF(__pyx_t_9); + __Pyx_XDECREF(__pyx_t_17); + __Pyx_AddTraceback("asyncpg.protocol.protocol.PreparedStatementState._decode_row", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XDECREF((PyObject *)__pyx_v_codec); + __Pyx_XDECREF(__pyx_v_dec_row); + __Pyx_XDECREF(__pyx_v_rows_codecs); + __Pyx_XDECREF((PyObject *)__pyx_v_settings); + __Pyx_XDECREF((PyObject *)__pyx_v_rbuf); + __Pyx_XDECREF(__pyx_v_val); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "asyncpg/protocol/prepared_stmt.pxd":10 + * cdef class PreparedStatementState: + * cdef: + * readonly str name # <<<<<<<<<<<<<< + * readonly str query + * readonly bint closed + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_7asyncpg_8protocol_8protocol_22PreparedStatementState_4name_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_7asyncpg_8protocol_8protocol_22PreparedStatementState_4name_1__get__(PyObject *__pyx_v_self) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_r = __pyx_pf_7asyncpg_8protocol_8protocol_22PreparedStatementState_4name___get__(((struct __pyx_obj_7asyncpg_8protocol_8protocol_PreparedStatementState *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_7asyncpg_8protocol_8protocol_22PreparedStatementState_4name___get__(struct __pyx_obj_7asyncpg_8protocol_8protocol_PreparedStatementState *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__", 0); + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(__pyx_v_self->name); + __pyx_r = __pyx_v_self->name; + goto __pyx_L0; + + /* function exit code */ + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "asyncpg/protocol/prepared_stmt.pxd":11 + * cdef: + * readonly str name + * readonly str query # <<<<<<<<<<<<<< + * readonly bint closed + * readonly int refs + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_7asyncpg_8protocol_8protocol_22PreparedStatementState_5query_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_7asyncpg_8protocol_8protocol_22PreparedStatementState_5query_1__get__(PyObject *__pyx_v_self) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_r = __pyx_pf_7asyncpg_8protocol_8protocol_22PreparedStatementState_5query___get__(((struct __pyx_obj_7asyncpg_8protocol_8protocol_PreparedStatementState *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_7asyncpg_8protocol_8protocol_22PreparedStatementState_5query___get__(struct __pyx_obj_7asyncpg_8protocol_8protocol_PreparedStatementState *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__", 0); + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(__pyx_v_self->query); + __pyx_r = __pyx_v_self->query; + goto __pyx_L0; + + /* function exit code */ + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "asyncpg/protocol/prepared_stmt.pxd":12 + * readonly str name + * readonly str query + * readonly bint closed # <<<<<<<<<<<<<< + * readonly int refs + * + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_7asyncpg_8protocol_8protocol_22PreparedStatementState_6closed_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_7asyncpg_8protocol_8protocol_22PreparedStatementState_6closed_1__get__(PyObject *__pyx_v_self) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_r = __pyx_pf_7asyncpg_8protocol_8protocol_22PreparedStatementState_6closed___get__(((struct __pyx_obj_7asyncpg_8protocol_8protocol_PreparedStatementState *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_7asyncpg_8protocol_8protocol_22PreparedStatementState_6closed___get__(struct __pyx_obj_7asyncpg_8protocol_8protocol_PreparedStatementState *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + __Pyx_RefNannySetupContext("__get__", 0); + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyBool_FromLong(__pyx_v_self->closed); if (unlikely(!__pyx_t_1)) __PYX_ERR(26, 12, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("asyncpg.protocol.protocol.PreparedStatementState.closed.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "asyncpg/protocol/prepared_stmt.pxd":13 + * readonly str query + * readonly bint closed + * readonly int refs # <<<<<<<<<<<<<< + * + * FastReadBuffer buffer + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_7asyncpg_8protocol_8protocol_22PreparedStatementState_4refs_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_7asyncpg_8protocol_8protocol_22PreparedStatementState_4refs_1__get__(PyObject *__pyx_v_self) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_r = __pyx_pf_7asyncpg_8protocol_8protocol_22PreparedStatementState_4refs___get__(((struct __pyx_obj_7asyncpg_8protocol_8protocol_PreparedStatementState *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_7asyncpg_8protocol_8protocol_22PreparedStatementState_4refs___get__(struct __pyx_obj_7asyncpg_8protocol_8protocol_PreparedStatementState *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + __Pyx_RefNannySetupContext("__get__", 0); + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_v_self->refs); if (unlikely(!__pyx_t_1)) __PYX_ERR(26, 13, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("asyncpg.protocol.protocol.PreparedStatementState.refs.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "asyncpg/protocol/prepared_stmt.pyx":263 + * + * + * cdef _decode_parameters_desc(object desc): # <<<<<<<<<<<<<< + * cdef: + * ReadBuffer reader + */ + +static PyObject *__pyx_f_7asyncpg_8protocol_8protocol__decode_parameters_desc(PyObject *__pyx_v_desc) { + struct __pyx_obj_7asyncpg_8protocol_8protocol_ReadBuffer *__pyx_v_reader = 0; + int16_t __pyx_v_nparams; + int32_t __pyx_v_p_oid; + PyObject *__pyx_v_result = 0; + CYTHON_UNUSED long __pyx_v_i; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int16_t __pyx_t_2; + int32_t __pyx_t_3; + int __pyx_t_4; + __Pyx_RefNannySetupContext("_decode_parameters_desc", 0); + + /* "asyncpg/protocol/prepared_stmt.pyx":268 + * int16_t nparams + * int32_t p_oid + * list result = [] # <<<<<<<<<<<<<< + * + * reader = ReadBuffer.new_message_parser(desc) + */ + __pyx_t_1 = PyList_New(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(25, 268, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_v_result = ((PyObject*)__pyx_t_1); + __pyx_t_1 = 0; + + /* "asyncpg/protocol/prepared_stmt.pyx":270 + * list result = [] + * + * reader = ReadBuffer.new_message_parser(desc) # <<<<<<<<<<<<<< + * nparams = reader.read_int16() + * + */ + __pyx_t_1 = ((PyObject *)__pyx_f_7asyncpg_8protocol_8protocol_10ReadBuffer_new_message_parser(__pyx_v_desc)); if (unlikely(!__pyx_t_1)) __PYX_ERR(25, 270, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_v_reader = ((struct __pyx_obj_7asyncpg_8protocol_8protocol_ReadBuffer *)__pyx_t_1); + __pyx_t_1 = 0; + + /* "asyncpg/protocol/prepared_stmt.pyx":271 + * + * reader = ReadBuffer.new_message_parser(desc) + * nparams = reader.read_int16() # <<<<<<<<<<<<<< + * + * for i from 0 <= i < nparams: + */ + __pyx_t_1 = __pyx_f_7asyncpg_8protocol_8protocol_10ReadBuffer_read_int16(__pyx_v_reader); if (unlikely(!__pyx_t_1)) __PYX_ERR(25, 271, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = __Pyx_PyInt_As_int16_t(__pyx_t_1); if (unlikely((__pyx_t_2 == ((int16_t)-1)) && PyErr_Occurred())) __PYX_ERR(25, 271, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_v_nparams = __pyx_t_2; + + /* "asyncpg/protocol/prepared_stmt.pyx":273 + * nparams = reader.read_int16() + * + * for i from 0 <= i < nparams: # <<<<<<<<<<<<<< + * p_oid = reader.read_int32() + * result.append(p_oid) + */ + __pyx_t_2 = __pyx_v_nparams; + for (__pyx_v_i = 0; __pyx_v_i < __pyx_t_2; __pyx_v_i++) { + + /* "asyncpg/protocol/prepared_stmt.pyx":274 + * + * for i from 0 <= i < nparams: + * p_oid = reader.read_int32() # <<<<<<<<<<<<<< + * result.append(p_oid) + * + */ + __pyx_t_1 = __pyx_f_7asyncpg_8protocol_8protocol_10ReadBuffer_read_int32(__pyx_v_reader); if (unlikely(!__pyx_t_1)) __PYX_ERR(25, 274, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_3 = __Pyx_PyInt_As_int32_t(__pyx_t_1); if (unlikely((__pyx_t_3 == ((int32_t)-1)) && PyErr_Occurred())) __PYX_ERR(25, 274, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_v_p_oid = __pyx_t_3; + + /* "asyncpg/protocol/prepared_stmt.pyx":275 + * for i from 0 <= i < nparams: + * p_oid = reader.read_int32() + * result.append(p_oid) # <<<<<<<<<<<<<< + * + * return result + */ + __pyx_t_1 = __Pyx_PyInt_From_int32_t(__pyx_v_p_oid); if (unlikely(!__pyx_t_1)) __PYX_ERR(25, 275, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_4 = __Pyx_PyList_Append(__pyx_v_result, __pyx_t_1); if (unlikely(__pyx_t_4 == -1)) __PYX_ERR(25, 275, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + } + + /* "asyncpg/protocol/prepared_stmt.pyx":277 + * result.append(p_oid) + * + * return result # <<<<<<<<<<<<<< + * + * + */ + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(__pyx_v_result); + __pyx_r = __pyx_v_result; + goto __pyx_L0; + + /* "asyncpg/protocol/prepared_stmt.pyx":263 + * + * + * cdef _decode_parameters_desc(object desc): # <<<<<<<<<<<<<< + * cdef: + * ReadBuffer reader + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("asyncpg.protocol.protocol._decode_parameters_desc", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XDECREF((PyObject *)__pyx_v_reader); + __Pyx_XDECREF(__pyx_v_result); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "asyncpg/protocol/prepared_stmt.pyx":280 + * + * + * cdef _decode_row_desc(object desc): # <<<<<<<<<<<<<< + * cdef: + * ReadBuffer reader + */ + +static PyObject *__pyx_f_7asyncpg_8protocol_8protocol__decode_row_desc(PyObject *__pyx_v_desc) { + struct __pyx_obj_7asyncpg_8protocol_8protocol_ReadBuffer *__pyx_v_reader = 0; + int16_t __pyx_v_nfields; + PyObject *__pyx_v_f_name = 0; + int32_t __pyx_v_f_table_oid; + int16_t __pyx_v_f_column_num; + int32_t __pyx_v_f_dt_oid; + int16_t __pyx_v_f_dt_size; + int32_t __pyx_v_f_dt_mod; + int16_t __pyx_v_f_format; + PyObject *__pyx_v_result = 0; + CYTHON_UNUSED long __pyx_v_i; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int16_t __pyx_t_2; + int32_t __pyx_t_3; + int16_t __pyx_t_4; + PyObject *__pyx_t_5 = NULL; + PyObject *__pyx_t_6 = NULL; + PyObject *__pyx_t_7 = NULL; + PyObject *__pyx_t_8 = NULL; + PyObject *__pyx_t_9 = NULL; + PyObject *__pyx_t_10 = NULL; + int __pyx_t_11; + __Pyx_RefNannySetupContext("_decode_row_desc", 0); + + /* "asyncpg/protocol/prepared_stmt.pyx":296 + * list result + * + * reader = ReadBuffer.new_message_parser(desc) # <<<<<<<<<<<<<< + * nfields = reader.read_int16() + * result = [] + */ + __pyx_t_1 = ((PyObject *)__pyx_f_7asyncpg_8protocol_8protocol_10ReadBuffer_new_message_parser(__pyx_v_desc)); if (unlikely(!__pyx_t_1)) __PYX_ERR(25, 296, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_v_reader = ((struct __pyx_obj_7asyncpg_8protocol_8protocol_ReadBuffer *)__pyx_t_1); + __pyx_t_1 = 0; + + /* "asyncpg/protocol/prepared_stmt.pyx":297 + * + * reader = ReadBuffer.new_message_parser(desc) + * nfields = reader.read_int16() # <<<<<<<<<<<<<< + * result = [] + * + */ + __pyx_t_1 = __pyx_f_7asyncpg_8protocol_8protocol_10ReadBuffer_read_int16(__pyx_v_reader); if (unlikely(!__pyx_t_1)) __PYX_ERR(25, 297, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = __Pyx_PyInt_As_int16_t(__pyx_t_1); if (unlikely((__pyx_t_2 == ((int16_t)-1)) && PyErr_Occurred())) __PYX_ERR(25, 297, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_v_nfields = __pyx_t_2; + + /* "asyncpg/protocol/prepared_stmt.pyx":298 + * reader = ReadBuffer.new_message_parser(desc) + * nfields = reader.read_int16() + * result = [] # <<<<<<<<<<<<<< + * + * for i from 0 <= i < nfields: + */ + __pyx_t_1 = PyList_New(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(25, 298, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_v_result = ((PyObject*)__pyx_t_1); + __pyx_t_1 = 0; + + /* "asyncpg/protocol/prepared_stmt.pyx":300 + * result = [] + * + * for i from 0 <= i < nfields: # <<<<<<<<<<<<<< + * f_name = reader.read_cstr() + * f_table_oid = reader.read_int32() + */ + __pyx_t_2 = __pyx_v_nfields; + for (__pyx_v_i = 0; __pyx_v_i < __pyx_t_2; __pyx_v_i++) { + + /* "asyncpg/protocol/prepared_stmt.pyx":301 + * + * for i from 0 <= i < nfields: + * f_name = reader.read_cstr() # <<<<<<<<<<<<<< + * f_table_oid = reader.read_int32() + * f_column_num = reader.read_int16() + */ + __pyx_t_1 = __pyx_f_7asyncpg_8protocol_8protocol_10ReadBuffer_read_cstr(__pyx_v_reader); if (unlikely(!__pyx_t_1)) __PYX_ERR(25, 301, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (!(likely(PyBytes_CheckExact(__pyx_t_1))||((__pyx_t_1) == Py_None)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "bytes", Py_TYPE(__pyx_t_1)->tp_name), 0))) __PYX_ERR(25, 301, __pyx_L1_error) + __Pyx_XDECREF_SET(__pyx_v_f_name, ((PyObject*)__pyx_t_1)); + __pyx_t_1 = 0; + + /* "asyncpg/protocol/prepared_stmt.pyx":302 + * for i from 0 <= i < nfields: + * f_name = reader.read_cstr() + * f_table_oid = reader.read_int32() # <<<<<<<<<<<<<< + * f_column_num = reader.read_int16() + * f_dt_oid = reader.read_int32() + */ + __pyx_t_1 = __pyx_f_7asyncpg_8protocol_8protocol_10ReadBuffer_read_int32(__pyx_v_reader); if (unlikely(!__pyx_t_1)) __PYX_ERR(25, 302, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_3 = __Pyx_PyInt_As_int32_t(__pyx_t_1); if (unlikely((__pyx_t_3 == ((int32_t)-1)) && PyErr_Occurred())) __PYX_ERR(25, 302, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_v_f_table_oid = __pyx_t_3; + + /* "asyncpg/protocol/prepared_stmt.pyx":303 + * f_name = reader.read_cstr() + * f_table_oid = reader.read_int32() + * f_column_num = reader.read_int16() # <<<<<<<<<<<<<< + * f_dt_oid = reader.read_int32() + * f_dt_size = reader.read_int16() + */ + __pyx_t_1 = __pyx_f_7asyncpg_8protocol_8protocol_10ReadBuffer_read_int16(__pyx_v_reader); if (unlikely(!__pyx_t_1)) __PYX_ERR(25, 303, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_4 = __Pyx_PyInt_As_int16_t(__pyx_t_1); if (unlikely((__pyx_t_4 == ((int16_t)-1)) && PyErr_Occurred())) __PYX_ERR(25, 303, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_v_f_column_num = __pyx_t_4; + + /* "asyncpg/protocol/prepared_stmt.pyx":304 + * f_table_oid = reader.read_int32() + * f_column_num = reader.read_int16() + * f_dt_oid = reader.read_int32() # <<<<<<<<<<<<<< + * f_dt_size = reader.read_int16() + * f_dt_mod = reader.read_int32() + */ + __pyx_t_1 = __pyx_f_7asyncpg_8protocol_8protocol_10ReadBuffer_read_int32(__pyx_v_reader); if (unlikely(!__pyx_t_1)) __PYX_ERR(25, 304, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_3 = __Pyx_PyInt_As_int32_t(__pyx_t_1); if (unlikely((__pyx_t_3 == ((int32_t)-1)) && PyErr_Occurred())) __PYX_ERR(25, 304, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_v_f_dt_oid = __pyx_t_3; + + /* "asyncpg/protocol/prepared_stmt.pyx":305 + * f_column_num = reader.read_int16() + * f_dt_oid = reader.read_int32() + * f_dt_size = reader.read_int16() # <<<<<<<<<<<<<< + * f_dt_mod = reader.read_int32() + * f_format = reader.read_int16() + */ + __pyx_t_1 = __pyx_f_7asyncpg_8protocol_8protocol_10ReadBuffer_read_int16(__pyx_v_reader); if (unlikely(!__pyx_t_1)) __PYX_ERR(25, 305, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_4 = __Pyx_PyInt_As_int16_t(__pyx_t_1); if (unlikely((__pyx_t_4 == ((int16_t)-1)) && PyErr_Occurred())) __PYX_ERR(25, 305, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_v_f_dt_size = __pyx_t_4; + + /* "asyncpg/protocol/prepared_stmt.pyx":306 + * f_dt_oid = reader.read_int32() + * f_dt_size = reader.read_int16() + * f_dt_mod = reader.read_int32() # <<<<<<<<<<<<<< + * f_format = reader.read_int16() + * + */ + __pyx_t_1 = __pyx_f_7asyncpg_8protocol_8protocol_10ReadBuffer_read_int32(__pyx_v_reader); if (unlikely(!__pyx_t_1)) __PYX_ERR(25, 306, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_3 = __Pyx_PyInt_As_int32_t(__pyx_t_1); if (unlikely((__pyx_t_3 == ((int32_t)-1)) && PyErr_Occurred())) __PYX_ERR(25, 306, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_v_f_dt_mod = __pyx_t_3; + + /* "asyncpg/protocol/prepared_stmt.pyx":307 + * f_dt_size = reader.read_int16() + * f_dt_mod = reader.read_int32() + * f_format = reader.read_int16() # <<<<<<<<<<<<<< + * + * result.append( + */ + __pyx_t_1 = __pyx_f_7asyncpg_8protocol_8protocol_10ReadBuffer_read_int16(__pyx_v_reader); if (unlikely(!__pyx_t_1)) __PYX_ERR(25, 307, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_4 = __Pyx_PyInt_As_int16_t(__pyx_t_1); if (unlikely((__pyx_t_4 == ((int16_t)-1)) && PyErr_Occurred())) __PYX_ERR(25, 307, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_v_f_format = __pyx_t_4; + + /* "asyncpg/protocol/prepared_stmt.pyx":310 + * + * result.append( + * (f_name, f_table_oid, f_column_num, f_dt_oid, # <<<<<<<<<<<<<< + * f_dt_size, f_dt_mod, f_format)) + * + */ + __pyx_t_1 = __Pyx_PyInt_From_int32_t(__pyx_v_f_table_oid); if (unlikely(!__pyx_t_1)) __PYX_ERR(25, 310, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_5 = __Pyx_PyInt_From_int16_t(__pyx_v_f_column_num); if (unlikely(!__pyx_t_5)) __PYX_ERR(25, 310, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_6 = __Pyx_PyInt_From_int32_t(__pyx_v_f_dt_oid); if (unlikely(!__pyx_t_6)) __PYX_ERR(25, 310, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + + /* "asyncpg/protocol/prepared_stmt.pyx":311 + * result.append( + * (f_name, f_table_oid, f_column_num, f_dt_oid, + * f_dt_size, f_dt_mod, f_format)) # <<<<<<<<<<<<<< + * + * return result + */ + __pyx_t_7 = __Pyx_PyInt_From_int16_t(__pyx_v_f_dt_size); if (unlikely(!__pyx_t_7)) __PYX_ERR(25, 311, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __pyx_t_8 = __Pyx_PyInt_From_int32_t(__pyx_v_f_dt_mod); if (unlikely(!__pyx_t_8)) __PYX_ERR(25, 311, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __pyx_t_9 = __Pyx_PyInt_From_int16_t(__pyx_v_f_format); if (unlikely(!__pyx_t_9)) __PYX_ERR(25, 311, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_9); + + /* "asyncpg/protocol/prepared_stmt.pyx":310 + * + * result.append( + * (f_name, f_table_oid, f_column_num, f_dt_oid, # <<<<<<<<<<<<<< + * f_dt_size, f_dt_mod, f_format)) + * + */ + __pyx_t_10 = PyTuple_New(7); if (unlikely(!__pyx_t_10)) __PYX_ERR(25, 310, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_10); + __Pyx_INCREF(__pyx_v_f_name); + __Pyx_GIVEREF(__pyx_v_f_name); + PyTuple_SET_ITEM(__pyx_t_10, 0, __pyx_v_f_name); + __Pyx_GIVEREF(__pyx_t_1); + PyTuple_SET_ITEM(__pyx_t_10, 1, __pyx_t_1); + __Pyx_GIVEREF(__pyx_t_5); + PyTuple_SET_ITEM(__pyx_t_10, 2, __pyx_t_5); + __Pyx_GIVEREF(__pyx_t_6); + PyTuple_SET_ITEM(__pyx_t_10, 3, __pyx_t_6); + __Pyx_GIVEREF(__pyx_t_7); + PyTuple_SET_ITEM(__pyx_t_10, 4, __pyx_t_7); + __Pyx_GIVEREF(__pyx_t_8); + PyTuple_SET_ITEM(__pyx_t_10, 5, __pyx_t_8); + __Pyx_GIVEREF(__pyx_t_9); + PyTuple_SET_ITEM(__pyx_t_10, 6, __pyx_t_9); + __pyx_t_1 = 0; + __pyx_t_5 = 0; + __pyx_t_6 = 0; + __pyx_t_7 = 0; + __pyx_t_8 = 0; + __pyx_t_9 = 0; + + /* "asyncpg/protocol/prepared_stmt.pyx":309 + * f_format = reader.read_int16() + * + * result.append( # <<<<<<<<<<<<<< + * (f_name, f_table_oid, f_column_num, f_dt_oid, + * f_dt_size, f_dt_mod, f_format)) + */ + __pyx_t_11 = __Pyx_PyList_Append(__pyx_v_result, __pyx_t_10); if (unlikely(__pyx_t_11 == -1)) __PYX_ERR(25, 309, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; + } + + /* "asyncpg/protocol/prepared_stmt.pyx":313 + * f_dt_size, f_dt_mod, f_format)) + * + * return result # <<<<<<<<<<<<<< + */ + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(__pyx_v_result); + __pyx_r = __pyx_v_result; + goto __pyx_L0; + + /* "asyncpg/protocol/prepared_stmt.pyx":280 + * + * + * cdef _decode_row_desc(object desc): # <<<<<<<<<<<<<< + * cdef: + * ReadBuffer reader + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_XDECREF(__pyx_t_6); + __Pyx_XDECREF(__pyx_t_7); + __Pyx_XDECREF(__pyx_t_8); + __Pyx_XDECREF(__pyx_t_9); + __Pyx_XDECREF(__pyx_t_10); + __Pyx_AddTraceback("asyncpg.protocol.protocol._decode_row_desc", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XDECREF((PyObject *)__pyx_v_reader); + __Pyx_XDECREF(__pyx_v_f_name); + __Pyx_XDECREF(__pyx_v_result); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "asyncpg/protocol/protocol.pyx":83 + * + * cdef class BaseProtocol(CoreProtocol): + * def __init__(self, addr, connected_fut, con_args, loop): # <<<<<<<<<<<<<< + * CoreProtocol.__init__(self, con_args) + * + */ + +/* Python wrapper */ +static int __pyx_pw_7asyncpg_8protocol_8protocol_12BaseProtocol_1__init__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ +static int __pyx_pw_7asyncpg_8protocol_8protocol_12BaseProtocol_1__init__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { + PyObject *__pyx_v_addr = 0; + PyObject *__pyx_v_connected_fut = 0; + PyObject *__pyx_v_con_args = 0; + PyObject *__pyx_v_loop = 0; + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__init__ (wrapper)", 0); + { + static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_addr,&__pyx_n_s_connected_fut,&__pyx_n_s_con_args,&__pyx_n_s_loop,0}; + PyObject* values[4] = {0,0,0,0}; + if (unlikely(__pyx_kwds)) { + Py_ssize_t kw_args; + const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args); + switch (pos_args) { + case 4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3); + case 3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2); + case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); + case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = PyDict_Size(__pyx_kwds); + switch (pos_args) { + case 0: + if (likely((values[0] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_addr)) != 0)) kw_args--; + else goto __pyx_L5_argtuple_error; + case 1: + if (likely((values[1] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_connected_fut)) != 0)) kw_args--; + else { + __Pyx_RaiseArgtupleInvalid("__init__", 1, 4, 4, 1); __PYX_ERR(27, 83, __pyx_L3_error) + } + case 2: + if (likely((values[2] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_con_args)) != 0)) kw_args--; + else { + __Pyx_RaiseArgtupleInvalid("__init__", 1, 4, 4, 2); __PYX_ERR(27, 83, __pyx_L3_error) + } + case 3: + if (likely((values[3] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_loop)) != 0)) kw_args--; + else { + __Pyx_RaiseArgtupleInvalid("__init__", 1, 4, 4, 3); __PYX_ERR(27, 83, __pyx_L3_error) + } + } + if (unlikely(kw_args > 0)) { + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "__init__") < 0)) __PYX_ERR(27, 83, __pyx_L3_error) + } + } else if (PyTuple_GET_SIZE(__pyx_args) != 4) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + values[1] = PyTuple_GET_ITEM(__pyx_args, 1); + values[2] = PyTuple_GET_ITEM(__pyx_args, 2); + values[3] = PyTuple_GET_ITEM(__pyx_args, 3); + } + __pyx_v_addr = values[0]; + __pyx_v_connected_fut = values[1]; + __pyx_v_con_args = values[2]; + __pyx_v_loop = values[3]; + } + goto __pyx_L4_argument_unpacking_done; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("__init__", 1, 4, 4, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(27, 83, __pyx_L3_error) + __pyx_L3_error:; + __Pyx_AddTraceback("asyncpg.protocol.protocol.BaseProtocol.__init__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return -1; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_7asyncpg_8protocol_8protocol_12BaseProtocol___init__(((struct __pyx_obj_7asyncpg_8protocol_8protocol_BaseProtocol *)__pyx_v_self), __pyx_v_addr, __pyx_v_connected_fut, __pyx_v_con_args, __pyx_v_loop); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_7asyncpg_8protocol_8protocol_12BaseProtocol___init__(struct __pyx_obj_7asyncpg_8protocol_8protocol_BaseProtocol *__pyx_v_self, PyObject *__pyx_v_addr, PyObject *__pyx_v_connected_fut, PyObject *__pyx_v_con_args, PyObject *__pyx_v_loop) { + int __pyx_r; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + int __pyx_t_4; + PyObject *__pyx_t_5 = NULL; + PyObject *__pyx_t_6 = NULL; + PyObject *__pyx_t_7 = NULL; + PyObject *__pyx_t_8 = NULL; + __Pyx_RefNannySetupContext("__init__", 0); + + /* "asyncpg/protocol/protocol.pyx":84 + * cdef class BaseProtocol(CoreProtocol): + * def __init__(self, addr, connected_fut, con_args, loop): + * CoreProtocol.__init__(self, con_args) # <<<<<<<<<<<<<< + * + * self.loop = loop + */ + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_ptype_7asyncpg_8protocol_8protocol_CoreProtocol), __pyx_n_s_init); if (unlikely(!__pyx_t_2)) __PYX_ERR(27, 84, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = NULL; + __pyx_t_4 = 0; + if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_3)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_3); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + __pyx_t_4 = 1; + } + } + #if CYTHON_FAST_PYCALL + if (PyFunction_Check(__pyx_t_2)) { + PyObject *__pyx_temp[3] = {__pyx_t_3, ((PyObject *)__pyx_v_self), __pyx_v_con_args}; + __pyx_t_1 = __Pyx_PyFunction_FastCall(__pyx_t_2, __pyx_temp+1-__pyx_t_4, 2+__pyx_t_4); if (unlikely(!__pyx_t_1)) __PYX_ERR(27, 84, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_GOTREF(__pyx_t_1); + } else + #endif + #if CYTHON_FAST_PYCCALL + if (__Pyx_PyFastCFunction_Check(__pyx_t_2)) { + PyObject *__pyx_temp[3] = {__pyx_t_3, ((PyObject *)__pyx_v_self), __pyx_v_con_args}; + __pyx_t_1 = __Pyx_PyCFunction_FastCall(__pyx_t_2, __pyx_temp+1-__pyx_t_4, 2+__pyx_t_4); if (unlikely(!__pyx_t_1)) __PYX_ERR(27, 84, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_GOTREF(__pyx_t_1); + } else + #endif + { + __pyx_t_5 = PyTuple_New(2+__pyx_t_4); if (unlikely(!__pyx_t_5)) __PYX_ERR(27, 84, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + if (__pyx_t_3) { + __Pyx_GIVEREF(__pyx_t_3); PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_t_3); __pyx_t_3 = NULL; + } + __Pyx_INCREF(((PyObject *)__pyx_v_self)); + __Pyx_GIVEREF(((PyObject *)__pyx_v_self)); + PyTuple_SET_ITEM(__pyx_t_5, 0+__pyx_t_4, ((PyObject *)__pyx_v_self)); + __Pyx_INCREF(__pyx_v_con_args); + __Pyx_GIVEREF(__pyx_v_con_args); + PyTuple_SET_ITEM(__pyx_t_5, 1+__pyx_t_4, __pyx_v_con_args); + __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_t_5, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(27, 84, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + } + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "asyncpg/protocol/protocol.pyx":86 + * CoreProtocol.__init__(self, con_args) + * + * self.loop = loop # <<<<<<<<<<<<<< + * self.waiter = connected_fut + * self.cancel_waiter = None + */ + __Pyx_INCREF(__pyx_v_loop); + __Pyx_GIVEREF(__pyx_v_loop); + __Pyx_GOTREF(__pyx_v_self->loop); + __Pyx_DECREF(__pyx_v_self->loop); + __pyx_v_self->loop = __pyx_v_loop; + + /* "asyncpg/protocol/protocol.pyx":87 + * + * self.loop = loop + * self.waiter = connected_fut # <<<<<<<<<<<<<< + * self.cancel_waiter = None + * self.cancel_sent_waiter = None + */ + __Pyx_INCREF(__pyx_v_connected_fut); + __Pyx_GIVEREF(__pyx_v_connected_fut); + __Pyx_GOTREF(__pyx_v_self->waiter); + __Pyx_DECREF(__pyx_v_self->waiter); + __pyx_v_self->waiter = __pyx_v_connected_fut; + + /* "asyncpg/protocol/protocol.pyx":88 + * self.loop = loop + * self.waiter = connected_fut + * self.cancel_waiter = None # <<<<<<<<<<<<<< + * self.cancel_sent_waiter = None + * + */ + __Pyx_INCREF(Py_None); + __Pyx_GIVEREF(Py_None); + __Pyx_GOTREF(__pyx_v_self->cancel_waiter); + __Pyx_DECREF(__pyx_v_self->cancel_waiter); + __pyx_v_self->cancel_waiter = Py_None; + + /* "asyncpg/protocol/protocol.pyx":89 + * self.waiter = connected_fut + * self.cancel_waiter = None + * self.cancel_sent_waiter = None # <<<<<<<<<<<<<< + * + * self.address = addr + */ + __Pyx_INCREF(Py_None); + __Pyx_GIVEREF(Py_None); + __Pyx_GOTREF(__pyx_v_self->cancel_sent_waiter); + __Pyx_DECREF(__pyx_v_self->cancel_sent_waiter); + __pyx_v_self->cancel_sent_waiter = Py_None; + + /* "asyncpg/protocol/protocol.pyx":91 + * self.cancel_sent_waiter = None + * + * self.address = addr # <<<<<<<<<<<<<< + * self.settings = ConnectionSettings( + * (self.address, con_args.get('database'))) + */ + __Pyx_INCREF(__pyx_v_addr); + __Pyx_GIVEREF(__pyx_v_addr); + __Pyx_GOTREF(__pyx_v_self->address); + __Pyx_DECREF(__pyx_v_self->address); + __pyx_v_self->address = __pyx_v_addr; + + /* "asyncpg/protocol/protocol.pyx":93 + * self.address = addr + * self.settings = ConnectionSettings( + * (self.address, con_args.get('database'))) # <<<<<<<<<<<<<< + * + * self.uid_counter = 0 + */ + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_con_args, __pyx_n_s_get); if (unlikely(!__pyx_t_1)) __PYX_ERR(27, 93, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_tuple__70, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(27, 93, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_1 = PyTuple_New(2); if (unlikely(!__pyx_t_1)) __PYX_ERR(27, 93, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_INCREF(__pyx_v_self->address); + __Pyx_GIVEREF(__pyx_v_self->address); + PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_v_self->address); + __Pyx_GIVEREF(__pyx_t_2); + PyTuple_SET_ITEM(__pyx_t_1, 1, __pyx_t_2); + __pyx_t_2 = 0; + + /* "asyncpg/protocol/protocol.pyx":92 + * + * self.address = addr + * self.settings = ConnectionSettings( # <<<<<<<<<<<<<< + * (self.address, con_args.get('database'))) + * + */ + __pyx_t_2 = PyTuple_New(1); if (unlikely(!__pyx_t_2)) __PYX_ERR(27, 92, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_GIVEREF(__pyx_t_1); + PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_t_1); + __pyx_t_1 = 0; + __pyx_t_1 = __Pyx_PyObject_Call(((PyObject *)__pyx_ptype_7asyncpg_8protocol_8protocol_ConnectionSettings), __pyx_t_2, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(27, 92, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_GIVEREF(__pyx_t_1); + __Pyx_GOTREF(__pyx_v_self->settings); + __Pyx_DECREF(((PyObject *)__pyx_v_self->settings)); + __pyx_v_self->settings = ((struct __pyx_obj_7asyncpg_8protocol_8protocol_ConnectionSettings *)__pyx_t_1); + __pyx_t_1 = 0; + + /* "asyncpg/protocol/protocol.pyx":95 + * (self.address, con_args.get('database'))) + * + * self.uid_counter = 0 # <<<<<<<<<<<<<< + * self.statement = None + * self.return_extra = False + */ + __pyx_v_self->uid_counter = 0; + + /* "asyncpg/protocol/protocol.pyx":96 + * + * self.uid_counter = 0 + * self.statement = None # <<<<<<<<<<<<<< + * self.return_extra = False + * + */ + __Pyx_INCREF(Py_None); + __Pyx_GIVEREF(Py_None); + __Pyx_GOTREF(__pyx_v_self->statement); + __Pyx_DECREF(((PyObject *)__pyx_v_self->statement)); + __pyx_v_self->statement = ((struct __pyx_obj_7asyncpg_8protocol_8protocol_PreparedStatementState *)Py_None); + + /* "asyncpg/protocol/protocol.pyx":97 + * self.uid_counter = 0 + * self.statement = None + * self.return_extra = False # <<<<<<<<<<<<<< + * + * self.last_query = None + */ + __pyx_v_self->return_extra = 0; + + /* "asyncpg/protocol/protocol.pyx":99 + * self.return_extra = False + * + * self.last_query = None # <<<<<<<<<<<<<< + * + * self.closing = False + */ + __Pyx_INCREF(Py_None); + __Pyx_GIVEREF(Py_None); + __Pyx_GOTREF(__pyx_v_self->last_query); + __Pyx_DECREF(__pyx_v_self->last_query); + __pyx_v_self->last_query = ((PyObject*)Py_None); + + /* "asyncpg/protocol/protocol.pyx":101 + * self.last_query = None + * + * self.closing = False # <<<<<<<<<<<<<< + * + * self.timeout_handle = None + */ + __pyx_v_self->closing = 0; + + /* "asyncpg/protocol/protocol.pyx":103 + * self.closing = False + * + * self.timeout_handle = None # <<<<<<<<<<<<<< + * self.timeout_callback = self._on_timeout + * self.completed_callback = self._on_waiter_completed + */ + __Pyx_INCREF(Py_None); + __Pyx_GIVEREF(Py_None); + __Pyx_GOTREF(__pyx_v_self->timeout_handle); + __Pyx_DECREF(__pyx_v_self->timeout_handle); + __pyx_v_self->timeout_handle = Py_None; + + /* "asyncpg/protocol/protocol.pyx":104 + * + * self.timeout_handle = None + * self.timeout_callback = self._on_timeout # <<<<<<<<<<<<<< + * self.completed_callback = self._on_waiter_completed + * + */ + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_on_timeout); if (unlikely(!__pyx_t_1)) __PYX_ERR(27, 104, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_GIVEREF(__pyx_t_1); + __Pyx_GOTREF(__pyx_v_self->timeout_callback); + __Pyx_DECREF(__pyx_v_self->timeout_callback); + __pyx_v_self->timeout_callback = __pyx_t_1; + __pyx_t_1 = 0; + + /* "asyncpg/protocol/protocol.pyx":105 + * self.timeout_handle = None + * self.timeout_callback = self._on_timeout + * self.completed_callback = self._on_waiter_completed # <<<<<<<<<<<<<< + * + * self.queries_count = 0 + */ + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_on_waiter_completed); if (unlikely(!__pyx_t_1)) __PYX_ERR(27, 105, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_GIVEREF(__pyx_t_1); + __Pyx_GOTREF(__pyx_v_self->completed_callback); + __Pyx_DECREF(__pyx_v_self->completed_callback); + __pyx_v_self->completed_callback = __pyx_t_1; + __pyx_t_1 = 0; + + /* "asyncpg/protocol/protocol.pyx":107 + * self.completed_callback = self._on_waiter_completed + * + * self.queries_count = 0 # <<<<<<<<<<<<<< + * + * try: + */ + __pyx_v_self->queries_count = 0; + + /* "asyncpg/protocol/protocol.pyx":109 + * self.queries_count = 0 + * + * try: # <<<<<<<<<<<<<< + * self.create_future = loop.create_future + * except AttributeError: + */ + { + __Pyx_PyThreadState_declare + __Pyx_PyThreadState_assign + __Pyx_ExceptionSave(&__pyx_t_6, &__pyx_t_7, &__pyx_t_8); + __Pyx_XGOTREF(__pyx_t_6); + __Pyx_XGOTREF(__pyx_t_7); + __Pyx_XGOTREF(__pyx_t_8); + /*try:*/ { + + /* "asyncpg/protocol/protocol.pyx":110 + * + * try: + * self.create_future = loop.create_future # <<<<<<<<<<<<<< + * except AttributeError: + * self.create_future = self._create_future_fallback + */ + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_loop, __pyx_n_s_create_future); if (unlikely(!__pyx_t_1)) __PYX_ERR(27, 110, __pyx_L3_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_GIVEREF(__pyx_t_1); + __Pyx_GOTREF(__pyx_v_self->create_future); + __Pyx_DECREF(__pyx_v_self->create_future); + __pyx_v_self->create_future = __pyx_t_1; + __pyx_t_1 = 0; + + /* "asyncpg/protocol/protocol.pyx":109 + * self.queries_count = 0 + * + * try: # <<<<<<<<<<<<<< + * self.create_future = loop.create_future + * except AttributeError: + */ + } + __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; + goto __pyx_L10_try_end; + __pyx_L3_error:; + __Pyx_PyThreadState_assign + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "asyncpg/protocol/protocol.pyx":111 + * try: + * self.create_future = loop.create_future + * except AttributeError: # <<<<<<<<<<<<<< + * self.create_future = self._create_future_fallback + * + */ + __pyx_t_4 = __Pyx_PyErr_ExceptionMatches(__pyx_builtin_AttributeError); + if (__pyx_t_4) { + __Pyx_AddTraceback("asyncpg.protocol.protocol.BaseProtocol.__init__", __pyx_clineno, __pyx_lineno, __pyx_filename); + if (__Pyx_GetException(&__pyx_t_1, &__pyx_t_2, &__pyx_t_5) < 0) __PYX_ERR(27, 111, __pyx_L5_except_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_GOTREF(__pyx_t_2); + __Pyx_GOTREF(__pyx_t_5); + + /* "asyncpg/protocol/protocol.pyx":112 + * self.create_future = loop.create_future + * except AttributeError: + * self.create_future = self._create_future_fallback # <<<<<<<<<<<<<< + * + * def set_connection(self, connection): + */ + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_create_future_fallback); if (unlikely(!__pyx_t_3)) __PYX_ERR(27, 112, __pyx_L5_except_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_GIVEREF(__pyx_t_3); + __Pyx_GOTREF(__pyx_v_self->create_future); + __Pyx_DECREF(__pyx_v_self->create_future); + __pyx_v_self->create_future = __pyx_t_3; + __pyx_t_3 = 0; + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + goto __pyx_L4_exception_handled; + } + goto __pyx_L5_except_error; + __pyx_L5_except_error:; + + /* "asyncpg/protocol/protocol.pyx":109 + * self.queries_count = 0 + * + * try: # <<<<<<<<<<<<<< + * self.create_future = loop.create_future + * except AttributeError: + */ + __Pyx_PyThreadState_assign + __Pyx_XGIVEREF(__pyx_t_6); + __Pyx_XGIVEREF(__pyx_t_7); + __Pyx_XGIVEREF(__pyx_t_8); + __Pyx_ExceptionReset(__pyx_t_6, __pyx_t_7, __pyx_t_8); + goto __pyx_L1_error; + __pyx_L4_exception_handled:; + __Pyx_PyThreadState_assign + __Pyx_XGIVEREF(__pyx_t_6); + __Pyx_XGIVEREF(__pyx_t_7); + __Pyx_XGIVEREF(__pyx_t_8); + __Pyx_ExceptionReset(__pyx_t_6, __pyx_t_7, __pyx_t_8); + __pyx_L10_try_end:; + } + + /* "asyncpg/protocol/protocol.pyx":83 + * + * cdef class BaseProtocol(CoreProtocol): + * def __init__(self, addr, connected_fut, con_args, loop): # <<<<<<<<<<<<<< + * CoreProtocol.__init__(self, con_args) + * + */ + + /* function exit code */ + __pyx_r = 0; + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_AddTraceback("asyncpg.protocol.protocol.BaseProtocol.__init__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = -1; + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "asyncpg/protocol/protocol.pyx":114 + * self.create_future = self._create_future_fallback + * + * def set_connection(self, connection): # <<<<<<<<<<<<<< + * self.connection = connection + * + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_7asyncpg_8protocol_8protocol_12BaseProtocol_3set_connection(PyObject *__pyx_v_self, PyObject *__pyx_v_connection); /*proto*/ +static PyObject *__pyx_pw_7asyncpg_8protocol_8protocol_12BaseProtocol_3set_connection(PyObject *__pyx_v_self, PyObject *__pyx_v_connection) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("set_connection (wrapper)", 0); + __pyx_r = __pyx_pf_7asyncpg_8protocol_8protocol_12BaseProtocol_2set_connection(((struct __pyx_obj_7asyncpg_8protocol_8protocol_BaseProtocol *)__pyx_v_self), ((PyObject *)__pyx_v_connection)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_7asyncpg_8protocol_8protocol_12BaseProtocol_2set_connection(struct __pyx_obj_7asyncpg_8protocol_8protocol_BaseProtocol *__pyx_v_self, PyObject *__pyx_v_connection) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("set_connection", 0); + + /* "asyncpg/protocol/protocol.pyx":115 + * + * def set_connection(self, connection): + * self.connection = connection # <<<<<<<<<<<<<< + * + * def get_server_pid(self): + */ + __Pyx_INCREF(__pyx_v_connection); + __Pyx_GIVEREF(__pyx_v_connection); + __Pyx_GOTREF(__pyx_v_self->connection); + __Pyx_DECREF(__pyx_v_self->connection); + __pyx_v_self->connection = __pyx_v_connection; + + /* "asyncpg/protocol/protocol.pyx":114 + * self.create_future = self._create_future_fallback + * + * def set_connection(self, connection): # <<<<<<<<<<<<<< + * self.connection = connection + * + */ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "asyncpg/protocol/protocol.pyx":117 + * self.connection = connection + * + * def get_server_pid(self): # <<<<<<<<<<<<<< + * return self.backend_pid + * + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_7asyncpg_8protocol_8protocol_12BaseProtocol_5get_server_pid(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/ +static PyObject *__pyx_pw_7asyncpg_8protocol_8protocol_12BaseProtocol_5get_server_pid(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("get_server_pid (wrapper)", 0); + __pyx_r = __pyx_pf_7asyncpg_8protocol_8protocol_12BaseProtocol_4get_server_pid(((struct __pyx_obj_7asyncpg_8protocol_8protocol_BaseProtocol *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_7asyncpg_8protocol_8protocol_12BaseProtocol_4get_server_pid(struct __pyx_obj_7asyncpg_8protocol_8protocol_BaseProtocol *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + __Pyx_RefNannySetupContext("get_server_pid", 0); + + /* "asyncpg/protocol/protocol.pyx":118 + * + * def get_server_pid(self): + * return self.backend_pid # <<<<<<<<<<<<<< + * + * def get_settings(self): + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyInt_From_int32_t(__pyx_v_self->__pyx_base.backend_pid); if (unlikely(!__pyx_t_1)) __PYX_ERR(27, 118, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "asyncpg/protocol/protocol.pyx":117 + * self.connection = connection + * + * def get_server_pid(self): # <<<<<<<<<<<<<< + * return self.backend_pid + * + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("asyncpg.protocol.protocol.BaseProtocol.get_server_pid", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "asyncpg/protocol/protocol.pyx":120 + * return self.backend_pid + * + * def get_settings(self): # <<<<<<<<<<<<<< + * return self.settings + * + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_7asyncpg_8protocol_8protocol_12BaseProtocol_7get_settings(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/ +static PyObject *__pyx_pw_7asyncpg_8protocol_8protocol_12BaseProtocol_7get_settings(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("get_settings (wrapper)", 0); + __pyx_r = __pyx_pf_7asyncpg_8protocol_8protocol_12BaseProtocol_6get_settings(((struct __pyx_obj_7asyncpg_8protocol_8protocol_BaseProtocol *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_7asyncpg_8protocol_8protocol_12BaseProtocol_6get_settings(struct __pyx_obj_7asyncpg_8protocol_8protocol_BaseProtocol *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("get_settings", 0); + + /* "asyncpg/protocol/protocol.pyx":121 + * + * def get_settings(self): + * return self.settings # <<<<<<<<<<<<<< + * + * async def prepare(self, stmt_name, query, timeout): + */ + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(((PyObject *)__pyx_v_self->settings)); + __pyx_r = ((PyObject *)__pyx_v_self->settings); + goto __pyx_L0; + + /* "asyncpg/protocol/protocol.pyx":120 + * return self.backend_pid + * + * def get_settings(self): # <<<<<<<<<<<<<< + * return self.settings + * + */ + + /* function exit code */ + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} +static PyObject *__pyx_gb_7asyncpg_8protocol_8protocol_12BaseProtocol_10generator(__pyx_CoroutineObject *__pyx_generator, PyObject *__pyx_sent_value); /* proto */ + +/* "asyncpg/protocol/protocol.pyx":123 + * return self.settings + * + * async def prepare(self, stmt_name, query, timeout): # <<<<<<<<<<<<<< + * if self.cancel_waiter is not None: + * await self.cancel_waiter + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_7asyncpg_8protocol_8protocol_12BaseProtocol_9prepare(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ +static PyObject *__pyx_pw_7asyncpg_8protocol_8protocol_12BaseProtocol_9prepare(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { + PyObject *__pyx_v_stmt_name = 0; + PyObject *__pyx_v_query = 0; + PyObject *__pyx_v_timeout = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("prepare (wrapper)", 0); + { + static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_stmt_name,&__pyx_n_s_query,&__pyx_n_s_timeout,0}; + PyObject* values[3] = {0,0,0}; + if (unlikely(__pyx_kwds)) { + Py_ssize_t kw_args; + const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args); + switch (pos_args) { + case 3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2); + case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); + case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = PyDict_Size(__pyx_kwds); + switch (pos_args) { + case 0: + if (likely((values[0] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_stmt_name)) != 0)) kw_args--; + else goto __pyx_L5_argtuple_error; + case 1: + if (likely((values[1] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_query)) != 0)) kw_args--; + else { + __Pyx_RaiseArgtupleInvalid("prepare", 1, 3, 3, 1); __PYX_ERR(27, 123, __pyx_L3_error) + } + case 2: + if (likely((values[2] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_timeout)) != 0)) kw_args--; + else { + __Pyx_RaiseArgtupleInvalid("prepare", 1, 3, 3, 2); __PYX_ERR(27, 123, __pyx_L3_error) + } + } + if (unlikely(kw_args > 0)) { + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "prepare") < 0)) __PYX_ERR(27, 123, __pyx_L3_error) + } + } else if (PyTuple_GET_SIZE(__pyx_args) != 3) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + values[1] = PyTuple_GET_ITEM(__pyx_args, 1); + values[2] = PyTuple_GET_ITEM(__pyx_args, 2); + } + __pyx_v_stmt_name = values[0]; + __pyx_v_query = values[1]; + __pyx_v_timeout = values[2]; + } + goto __pyx_L4_argument_unpacking_done; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("prepare", 1, 3, 3, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(27, 123, __pyx_L3_error) + __pyx_L3_error:; + __Pyx_AddTraceback("asyncpg.protocol.protocol.BaseProtocol.prepare", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_7asyncpg_8protocol_8protocol_12BaseProtocol_8prepare(((struct __pyx_obj_7asyncpg_8protocol_8protocol_BaseProtocol *)__pyx_v_self), __pyx_v_stmt_name, __pyx_v_query, __pyx_v_timeout); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_7asyncpg_8protocol_8protocol_12BaseProtocol_8prepare(struct __pyx_obj_7asyncpg_8protocol_8protocol_BaseProtocol *__pyx_v_self, PyObject *__pyx_v_stmt_name, PyObject *__pyx_v_query, PyObject *__pyx_v_timeout) { + struct __pyx_obj_7asyncpg_8protocol_8protocol___pyx_scope_struct__prepare *__pyx_cur_scope; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("prepare", 0); + __pyx_cur_scope = (struct __pyx_obj_7asyncpg_8protocol_8protocol___pyx_scope_struct__prepare *)__pyx_tp_new_7asyncpg_8protocol_8protocol___pyx_scope_struct__prepare(__pyx_ptype_7asyncpg_8protocol_8protocol___pyx_scope_struct__prepare, __pyx_empty_tuple, NULL); + if (unlikely(!__pyx_cur_scope)) { + __pyx_cur_scope = ((struct __pyx_obj_7asyncpg_8protocol_8protocol___pyx_scope_struct__prepare *)Py_None); + __Pyx_INCREF(Py_None); + __PYX_ERR(27, 123, __pyx_L1_error) + } else { + __Pyx_GOTREF(__pyx_cur_scope); + } + __pyx_cur_scope->__pyx_v_self = __pyx_v_self; + __Pyx_INCREF((PyObject *)__pyx_cur_scope->__pyx_v_self); + __Pyx_GIVEREF((PyObject *)__pyx_cur_scope->__pyx_v_self); + __pyx_cur_scope->__pyx_v_stmt_name = __pyx_v_stmt_name; + __Pyx_INCREF(__pyx_cur_scope->__pyx_v_stmt_name); + __Pyx_GIVEREF(__pyx_cur_scope->__pyx_v_stmt_name); + __pyx_cur_scope->__pyx_v_query = __pyx_v_query; + __Pyx_INCREF(__pyx_cur_scope->__pyx_v_query); + __Pyx_GIVEREF(__pyx_cur_scope->__pyx_v_query); + __pyx_cur_scope->__pyx_v_timeout = __pyx_v_timeout; + __Pyx_INCREF(__pyx_cur_scope->__pyx_v_timeout); + __Pyx_GIVEREF(__pyx_cur_scope->__pyx_v_timeout); + { + __pyx_CoroutineObject *gen = __Pyx_Coroutine_New((__pyx_coroutine_body_t) __pyx_gb_7asyncpg_8protocol_8protocol_12BaseProtocol_10generator, (PyObject *) __pyx_cur_scope, __pyx_n_s_prepare, __pyx_n_s_BaseProtocol_prepare, __pyx_n_s_asyncpg_protocol_protocol); if (unlikely(!gen)) __PYX_ERR(27, 123, __pyx_L1_error) + __Pyx_DECREF(__pyx_cur_scope); + __Pyx_RefNannyFinishContext(); + return (PyObject *) gen; + } + + /* function exit code */ + __pyx_L1_error:; + __Pyx_AddTraceback("asyncpg.protocol.protocol.BaseProtocol.prepare", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __Pyx_DECREF(((PyObject *)__pyx_cur_scope)); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_gb_7asyncpg_8protocol_8protocol_12BaseProtocol_10generator(__pyx_CoroutineObject *__pyx_generator, PyObject *__pyx_sent_value) /* generator body */ +{ + struct __pyx_obj_7asyncpg_8protocol_8protocol___pyx_scope_struct__prepare *__pyx_cur_scope = ((struct __pyx_obj_7asyncpg_8protocol_8protocol___pyx_scope_struct__prepare *)__pyx_generator->closure); + PyObject *__pyx_r = NULL; + int __pyx_t_1; + int __pyx_t_2; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + PyObject *__pyx_t_5 = NULL; + PyObject *__pyx_t_6 = NULL; + PyObject *__pyx_t_7 = NULL; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("None", 0); + switch (__pyx_generator->resume_label) { + case 0: goto __pyx_L3_first_run; + case 1: goto __pyx_L5_resume_from_yield; + case 2: goto __pyx_L7_resume_from_yield; + case 3: goto __pyx_L9_resume_from_yield; + default: /* CPython raises the right error here */ + __Pyx_RefNannyFinishContext(); + return NULL; + } + __pyx_L3_first_run:; + if (unlikely(!__pyx_sent_value)) __PYX_ERR(27, 123, __pyx_L1_error) + + /* "asyncpg/protocol/protocol.pyx":124 + * + * async def prepare(self, stmt_name, query, timeout): + * if self.cancel_waiter is not None: # <<<<<<<<<<<<<< + * await self.cancel_waiter + * if self.cancel_sent_waiter is not None: + */ + __pyx_t_1 = (__pyx_cur_scope->__pyx_v_self->cancel_waiter != Py_None); + __pyx_t_2 = (__pyx_t_1 != 0); + if (__pyx_t_2) { + + /* "asyncpg/protocol/protocol.pyx":125 + * async def prepare(self, stmt_name, query, timeout): + * if self.cancel_waiter is not None: + * await self.cancel_waiter # <<<<<<<<<<<<<< + * if self.cancel_sent_waiter is not None: + * await self.cancel_sent_waiter + */ + __pyx_r = __Pyx_Coroutine_Yield_From(__pyx_generator, __pyx_cur_scope->__pyx_v_self->cancel_waiter); + __Pyx_XGOTREF(__pyx_r); + if (likely(__pyx_r)) { + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + /* return from generator, yielding value */ + __pyx_generator->resume_label = 1; + return __pyx_r; + __pyx_L5_resume_from_yield:; + if (unlikely(!__pyx_sent_value)) __PYX_ERR(27, 125, __pyx_L1_error) + } else { + PyObject* exc_type = PyErr_Occurred(); + if (exc_type) { + if (likely(exc_type == PyExc_StopIteration || PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) PyErr_Clear(); + else __PYX_ERR(27, 125, __pyx_L1_error) + } + } + + /* "asyncpg/protocol/protocol.pyx":124 + * + * async def prepare(self, stmt_name, query, timeout): + * if self.cancel_waiter is not None: # <<<<<<<<<<<<<< + * await self.cancel_waiter + * if self.cancel_sent_waiter is not None: + */ + } + + /* "asyncpg/protocol/protocol.pyx":126 + * if self.cancel_waiter is not None: + * await self.cancel_waiter + * if self.cancel_sent_waiter is not None: # <<<<<<<<<<<<<< + * await self.cancel_sent_waiter + * self.cancel_sent_waiter = None + */ + __pyx_t_2 = (__pyx_cur_scope->__pyx_v_self->cancel_sent_waiter != Py_None); + __pyx_t_1 = (__pyx_t_2 != 0); + if (__pyx_t_1) { + + /* "asyncpg/protocol/protocol.pyx":127 + * await self.cancel_waiter + * if self.cancel_sent_waiter is not None: + * await self.cancel_sent_waiter # <<<<<<<<<<<<<< + * self.cancel_sent_waiter = None + * + */ + __pyx_r = __Pyx_Coroutine_Yield_From(__pyx_generator, __pyx_cur_scope->__pyx_v_self->cancel_sent_waiter); + __Pyx_XGOTREF(__pyx_r); + if (likely(__pyx_r)) { + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + /* return from generator, yielding value */ + __pyx_generator->resume_label = 2; + return __pyx_r; + __pyx_L7_resume_from_yield:; + if (unlikely(!__pyx_sent_value)) __PYX_ERR(27, 127, __pyx_L1_error) + } else { + PyObject* exc_type = PyErr_Occurred(); + if (exc_type) { + if (likely(exc_type == PyExc_StopIteration || PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) PyErr_Clear(); + else __PYX_ERR(27, 127, __pyx_L1_error) + } + } + + /* "asyncpg/protocol/protocol.pyx":128 + * if self.cancel_sent_waiter is not None: + * await self.cancel_sent_waiter + * self.cancel_sent_waiter = None # <<<<<<<<<<<<<< + * + * self._ensure_clear_state() + */ + __Pyx_INCREF(Py_None); + __Pyx_GIVEREF(Py_None); + __Pyx_GOTREF(__pyx_cur_scope->__pyx_v_self->cancel_sent_waiter); + __Pyx_DECREF(__pyx_cur_scope->__pyx_v_self->cancel_sent_waiter); + __pyx_cur_scope->__pyx_v_self->cancel_sent_waiter = Py_None; + + /* "asyncpg/protocol/protocol.pyx":126 + * if self.cancel_waiter is not None: + * await self.cancel_waiter + * if self.cancel_sent_waiter is not None: # <<<<<<<<<<<<<< + * await self.cancel_sent_waiter + * self.cancel_sent_waiter = None + */ + } + + /* "asyncpg/protocol/protocol.pyx":130 + * self.cancel_sent_waiter = None + * + * self._ensure_clear_state() # <<<<<<<<<<<<<< + * + * if stmt_name is None: + */ + __pyx_t_3 = ((struct __pyx_vtabstruct_7asyncpg_8protocol_8protocol_BaseProtocol *)__pyx_cur_scope->__pyx_v_self->__pyx_base.__pyx_vtab)->_ensure_clear_state(__pyx_cur_scope->__pyx_v_self); if (unlikely(!__pyx_t_3)) __PYX_ERR(27, 130, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + + /* "asyncpg/protocol/protocol.pyx":132 + * self._ensure_clear_state() + * + * if stmt_name is None: # <<<<<<<<<<<<<< + * self.uid_counter += 1 + * stmt_name = 'stmt_{}'.format(self.uid_counter) + */ + __pyx_t_1 = (__pyx_cur_scope->__pyx_v_stmt_name == Py_None); + __pyx_t_2 = (__pyx_t_1 != 0); + if (__pyx_t_2) { + + /* "asyncpg/protocol/protocol.pyx":133 + * + * if stmt_name is None: + * self.uid_counter += 1 # <<<<<<<<<<<<<< + * stmt_name = 'stmt_{}'.format(self.uid_counter) + * + */ + __pyx_cur_scope->__pyx_v_self->uid_counter = (__pyx_cur_scope->__pyx_v_self->uid_counter + 1); + + /* "asyncpg/protocol/protocol.pyx":134 + * if stmt_name is None: + * self.uid_counter += 1 + * stmt_name = 'stmt_{}'.format(self.uid_counter) # <<<<<<<<<<<<<< + * + * self._prepare(stmt_name, query) + */ + __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_kp_u_stmt, __pyx_n_s_format); if (unlikely(!__pyx_t_4)) __PYX_ERR(27, 134, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_5 = __Pyx_PyInt_From_int(__pyx_cur_scope->__pyx_v_self->uid_counter); if (unlikely(!__pyx_t_5)) __PYX_ERR(27, 134, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_6 = NULL; + if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_4))) { + __pyx_t_6 = PyMethod_GET_SELF(__pyx_t_4); + if (likely(__pyx_t_6)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4); + __Pyx_INCREF(__pyx_t_6); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_4, function); + } + } + if (!__pyx_t_6) { + __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_t_5); if (unlikely(!__pyx_t_3)) __PYX_ERR(27, 134, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_GOTREF(__pyx_t_3); + } else { + #if CYTHON_FAST_PYCALL + if (PyFunction_Check(__pyx_t_4)) { + PyObject *__pyx_temp[2] = {__pyx_t_6, __pyx_t_5}; + __pyx_t_3 = __Pyx_PyFunction_FastCall(__pyx_t_4, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_3)) __PYX_ERR(27, 134, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + } else + #endif + #if CYTHON_FAST_PYCCALL + if (__Pyx_PyFastCFunction_Check(__pyx_t_4)) { + PyObject *__pyx_temp[2] = {__pyx_t_6, __pyx_t_5}; + __pyx_t_3 = __Pyx_PyCFunction_FastCall(__pyx_t_4, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_3)) __PYX_ERR(27, 134, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + } else + #endif + { + __pyx_t_7 = PyTuple_New(1+1); if (unlikely(!__pyx_t_7)) __PYX_ERR(27, 134, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __Pyx_GIVEREF(__pyx_t_6); PyTuple_SET_ITEM(__pyx_t_7, 0, __pyx_t_6); __pyx_t_6 = NULL; + __Pyx_GIVEREF(__pyx_t_5); + PyTuple_SET_ITEM(__pyx_t_7, 0+1, __pyx_t_5); + __pyx_t_5 = 0; + __pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_4, __pyx_t_7, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(27, 134, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + } + } + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_GOTREF(__pyx_cur_scope->__pyx_v_stmt_name); + __Pyx_DECREF_SET(__pyx_cur_scope->__pyx_v_stmt_name, __pyx_t_3); + __Pyx_GIVEREF(__pyx_t_3); + __pyx_t_3 = 0; + + /* "asyncpg/protocol/protocol.pyx":132 + * self._ensure_clear_state() + * + * if stmt_name is None: # <<<<<<<<<<<<<< + * self.uid_counter += 1 + * stmt_name = 'stmt_{}'.format(self.uid_counter) + */ + } + + /* "asyncpg/protocol/protocol.pyx":136 + * stmt_name = 'stmt_{}'.format(self.uid_counter) + * + * self._prepare(stmt_name, query) # <<<<<<<<<<<<<< + * self.last_query = query + * self.statement = PreparedStatementState(stmt_name, query, self) + */ + if (!(likely(PyUnicode_CheckExact(__pyx_cur_scope->__pyx_v_stmt_name))||((__pyx_cur_scope->__pyx_v_stmt_name) == Py_None)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "unicode", Py_TYPE(__pyx_cur_scope->__pyx_v_stmt_name)->tp_name), 0))) __PYX_ERR(27, 136, __pyx_L1_error) + if (!(likely(PyUnicode_CheckExact(__pyx_cur_scope->__pyx_v_query))||((__pyx_cur_scope->__pyx_v_query) == Py_None)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "unicode", Py_TYPE(__pyx_cur_scope->__pyx_v_query)->tp_name), 0))) __PYX_ERR(27, 136, __pyx_L1_error) + __pyx_t_3 = ((struct __pyx_vtabstruct_7asyncpg_8protocol_8protocol_BaseProtocol *)__pyx_cur_scope->__pyx_v_self->__pyx_base.__pyx_vtab)->__pyx_base._prepare(((struct __pyx_obj_7asyncpg_8protocol_8protocol_CoreProtocol *)__pyx_cur_scope->__pyx_v_self), ((PyObject*)__pyx_cur_scope->__pyx_v_stmt_name), ((PyObject*)__pyx_cur_scope->__pyx_v_query)); if (unlikely(!__pyx_t_3)) __PYX_ERR(27, 136, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + + /* "asyncpg/protocol/protocol.pyx":137 + * + * self._prepare(stmt_name, query) + * self.last_query = query # <<<<<<<<<<<<<< + * self.statement = PreparedStatementState(stmt_name, query, self) + * + */ + if (!(likely(PyUnicode_CheckExact(__pyx_cur_scope->__pyx_v_query))||((__pyx_cur_scope->__pyx_v_query) == Py_None)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "unicode", Py_TYPE(__pyx_cur_scope->__pyx_v_query)->tp_name), 0))) __PYX_ERR(27, 137, __pyx_L1_error) + __pyx_t_3 = __pyx_cur_scope->__pyx_v_query; + __Pyx_INCREF(__pyx_t_3); + __Pyx_GIVEREF(__pyx_t_3); + __Pyx_GOTREF(__pyx_cur_scope->__pyx_v_self->last_query); + __Pyx_DECREF(__pyx_cur_scope->__pyx_v_self->last_query); + __pyx_cur_scope->__pyx_v_self->last_query = ((PyObject*)__pyx_t_3); + __pyx_t_3 = 0; + + /* "asyncpg/protocol/protocol.pyx":138 + * self._prepare(stmt_name, query) + * self.last_query = query + * self.statement = PreparedStatementState(stmt_name, query, self) # <<<<<<<<<<<<<< + * + * return await self._new_waiter(timeout) + */ + __pyx_t_3 = PyTuple_New(3); if (unlikely(!__pyx_t_3)) __PYX_ERR(27, 138, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_INCREF(__pyx_cur_scope->__pyx_v_stmt_name); + __Pyx_GIVEREF(__pyx_cur_scope->__pyx_v_stmt_name); + PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_cur_scope->__pyx_v_stmt_name); + __Pyx_INCREF(__pyx_cur_scope->__pyx_v_query); + __Pyx_GIVEREF(__pyx_cur_scope->__pyx_v_query); + PyTuple_SET_ITEM(__pyx_t_3, 1, __pyx_cur_scope->__pyx_v_query); + __Pyx_INCREF(((PyObject *)__pyx_cur_scope->__pyx_v_self)); + __Pyx_GIVEREF(((PyObject *)__pyx_cur_scope->__pyx_v_self)); + PyTuple_SET_ITEM(__pyx_t_3, 2, ((PyObject *)__pyx_cur_scope->__pyx_v_self)); + __pyx_t_4 = __Pyx_PyObject_Call(((PyObject *)__pyx_ptype_7asyncpg_8protocol_8protocol_PreparedStatementState), __pyx_t_3, NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(27, 138, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_GIVEREF(__pyx_t_4); + __Pyx_GOTREF(__pyx_cur_scope->__pyx_v_self->statement); + __Pyx_DECREF(((PyObject *)__pyx_cur_scope->__pyx_v_self->statement)); + __pyx_cur_scope->__pyx_v_self->statement = ((struct __pyx_obj_7asyncpg_8protocol_8protocol_PreparedStatementState *)__pyx_t_4); + __pyx_t_4 = 0; + + /* "asyncpg/protocol/protocol.pyx":140 + * self.statement = PreparedStatementState(stmt_name, query, self) + * + * return await self._new_waiter(timeout) # <<<<<<<<<<<<<< + * + * async def bind_execute(self, PreparedStatementState state, args, + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_4 = ((struct __pyx_vtabstruct_7asyncpg_8protocol_8protocol_BaseProtocol *)__pyx_cur_scope->__pyx_v_self->__pyx_base.__pyx_vtab)->_new_waiter(__pyx_cur_scope->__pyx_v_self, __pyx_cur_scope->__pyx_v_timeout); if (unlikely(!__pyx_t_4)) __PYX_ERR(27, 140, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_r = __Pyx_Coroutine_Yield_From(__pyx_generator, __pyx_t_4); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_XGOTREF(__pyx_r); + if (likely(__pyx_r)) { + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + /* return from generator, yielding value */ + __pyx_generator->resume_label = 3; + return __pyx_r; + __pyx_L9_resume_from_yield:; + if (unlikely(!__pyx_sent_value)) __PYX_ERR(27, 140, __pyx_L1_error) + __pyx_t_4 = __pyx_sent_value; __Pyx_INCREF(__pyx_t_4); + } else { + __pyx_t_4 = NULL; + if (__Pyx_PyGen_FetchStopIterationValue(&__pyx_t_4) < 0) __PYX_ERR(27, 140, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + } + __pyx_r = NULL; __Pyx_ReturnWithStopIteration(__pyx_t_4); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_4 = 0; + goto __pyx_L0; + CYTHON_MAYBE_UNUSED_VAR(__pyx_cur_scope); + + /* "asyncpg/protocol/protocol.pyx":123 + * return self.settings + * + * async def prepare(self, stmt_name, query, timeout): # <<<<<<<<<<<<<< + * if self.cancel_waiter is not None: + * await self.cancel_waiter + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_XDECREF(__pyx_t_6); + __Pyx_XDECREF(__pyx_t_7); + __Pyx_AddTraceback("prepare", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_L0:; + __Pyx_XDECREF(__pyx_r); __pyx_r = 0; + __pyx_generator->resume_label = -1; + __Pyx_Coroutine_clear((PyObject*)__pyx_generator); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} +static PyObject *__pyx_gb_7asyncpg_8protocol_8protocol_12BaseProtocol_13generator1(__pyx_CoroutineObject *__pyx_generator, PyObject *__pyx_sent_value); /* proto */ + +/* "asyncpg/protocol/protocol.pyx":142 + * return await self._new_waiter(timeout) + * + * async def bind_execute(self, PreparedStatementState state, args, # <<<<<<<<<<<<<< + * str portal_name, int limit, return_extra, + * timeout): + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_7asyncpg_8protocol_8protocol_12BaseProtocol_12bind_execute(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ +static PyObject *__pyx_pw_7asyncpg_8protocol_8protocol_12BaseProtocol_12bind_execute(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { + struct __pyx_obj_7asyncpg_8protocol_8protocol_PreparedStatementState *__pyx_v_state = 0; + PyObject *__pyx_v_args = 0; + PyObject *__pyx_v_portal_name = 0; + int __pyx_v_limit; + PyObject *__pyx_v_return_extra = 0; + PyObject *__pyx_v_timeout = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("bind_execute (wrapper)", 0); + { + static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_state,&__pyx_n_s_args,&__pyx_n_s_portal_name,&__pyx_n_s_limit,&__pyx_n_s_return_extra,&__pyx_n_s_timeout,0}; + PyObject* values[6] = {0,0,0,0,0,0}; + if (unlikely(__pyx_kwds)) { + Py_ssize_t kw_args; + const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args); + switch (pos_args) { + case 6: values[5] = PyTuple_GET_ITEM(__pyx_args, 5); + case 5: values[4] = PyTuple_GET_ITEM(__pyx_args, 4); + case 4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3); + case 3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2); + case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); + case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = PyDict_Size(__pyx_kwds); + switch (pos_args) { + case 0: + if (likely((values[0] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_state)) != 0)) kw_args--; + else goto __pyx_L5_argtuple_error; + case 1: + if (likely((values[1] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_args)) != 0)) kw_args--; + else { + __Pyx_RaiseArgtupleInvalid("bind_execute", 1, 6, 6, 1); __PYX_ERR(27, 142, __pyx_L3_error) + } + case 2: + if (likely((values[2] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_portal_name)) != 0)) kw_args--; + else { + __Pyx_RaiseArgtupleInvalid("bind_execute", 1, 6, 6, 2); __PYX_ERR(27, 142, __pyx_L3_error) + } + case 3: + if (likely((values[3] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_limit)) != 0)) kw_args--; + else { + __Pyx_RaiseArgtupleInvalid("bind_execute", 1, 6, 6, 3); __PYX_ERR(27, 142, __pyx_L3_error) + } + case 4: + if (likely((values[4] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_return_extra)) != 0)) kw_args--; + else { + __Pyx_RaiseArgtupleInvalid("bind_execute", 1, 6, 6, 4); __PYX_ERR(27, 142, __pyx_L3_error) + } + case 5: + if (likely((values[5] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_timeout)) != 0)) kw_args--; + else { + __Pyx_RaiseArgtupleInvalid("bind_execute", 1, 6, 6, 5); __PYX_ERR(27, 142, __pyx_L3_error) + } + } + if (unlikely(kw_args > 0)) { + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "bind_execute") < 0)) __PYX_ERR(27, 142, __pyx_L3_error) + } + } else if (PyTuple_GET_SIZE(__pyx_args) != 6) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + values[1] = PyTuple_GET_ITEM(__pyx_args, 1); + values[2] = PyTuple_GET_ITEM(__pyx_args, 2); + values[3] = PyTuple_GET_ITEM(__pyx_args, 3); + values[4] = PyTuple_GET_ITEM(__pyx_args, 4); + values[5] = PyTuple_GET_ITEM(__pyx_args, 5); + } + __pyx_v_state = ((struct __pyx_obj_7asyncpg_8protocol_8protocol_PreparedStatementState *)values[0]); + __pyx_v_args = values[1]; + __pyx_v_portal_name = ((PyObject*)values[2]); + __pyx_v_limit = __Pyx_PyInt_As_int(values[3]); if (unlikely((__pyx_v_limit == (int)-1) && PyErr_Occurred())) __PYX_ERR(27, 143, __pyx_L3_error) + __pyx_v_return_extra = values[4]; + __pyx_v_timeout = values[5]; + } + goto __pyx_L4_argument_unpacking_done; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("bind_execute", 1, 6, 6, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(27, 142, __pyx_L3_error) + __pyx_L3_error:; + __Pyx_AddTraceback("asyncpg.protocol.protocol.BaseProtocol.bind_execute", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_state), __pyx_ptype_7asyncpg_8protocol_8protocol_PreparedStatementState, 1, "state", 0))) __PYX_ERR(27, 142, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_portal_name), (&PyUnicode_Type), 1, "portal_name", 1))) __PYX_ERR(27, 143, __pyx_L1_error) + __pyx_r = __pyx_pf_7asyncpg_8protocol_8protocol_12BaseProtocol_11bind_execute(((struct __pyx_obj_7asyncpg_8protocol_8protocol_BaseProtocol *)__pyx_v_self), __pyx_v_state, __pyx_v_args, __pyx_v_portal_name, __pyx_v_limit, __pyx_v_return_extra, __pyx_v_timeout); + + /* function exit code */ + goto __pyx_L0; + __pyx_L1_error:; + __pyx_r = NULL; + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_7asyncpg_8protocol_8protocol_12BaseProtocol_11bind_execute(struct __pyx_obj_7asyncpg_8protocol_8protocol_BaseProtocol *__pyx_v_self, struct __pyx_obj_7asyncpg_8protocol_8protocol_PreparedStatementState *__pyx_v_state, PyObject *__pyx_v_args, PyObject *__pyx_v_portal_name, int __pyx_v_limit, PyObject *__pyx_v_return_extra, PyObject *__pyx_v_timeout) { + struct __pyx_obj_7asyncpg_8protocol_8protocol___pyx_scope_struct_1_bind_execute *__pyx_cur_scope; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("bind_execute", 0); + __pyx_cur_scope = (struct __pyx_obj_7asyncpg_8protocol_8protocol___pyx_scope_struct_1_bind_execute *)__pyx_tp_new_7asyncpg_8protocol_8protocol___pyx_scope_struct_1_bind_execute(__pyx_ptype_7asyncpg_8protocol_8protocol___pyx_scope_struct_1_bind_execute, __pyx_empty_tuple, NULL); + if (unlikely(!__pyx_cur_scope)) { + __pyx_cur_scope = ((struct __pyx_obj_7asyncpg_8protocol_8protocol___pyx_scope_struct_1_bind_execute *)Py_None); + __Pyx_INCREF(Py_None); + __PYX_ERR(27, 142, __pyx_L1_error) + } else { + __Pyx_GOTREF(__pyx_cur_scope); + } + __pyx_cur_scope->__pyx_v_self = __pyx_v_self; + __Pyx_INCREF((PyObject *)__pyx_cur_scope->__pyx_v_self); + __Pyx_GIVEREF((PyObject *)__pyx_cur_scope->__pyx_v_self); + __pyx_cur_scope->__pyx_v_state = __pyx_v_state; + __Pyx_INCREF((PyObject *)__pyx_cur_scope->__pyx_v_state); + __Pyx_GIVEREF((PyObject *)__pyx_cur_scope->__pyx_v_state); + __pyx_cur_scope->__pyx_v_args = __pyx_v_args; + __Pyx_INCREF(__pyx_cur_scope->__pyx_v_args); + __Pyx_GIVEREF(__pyx_cur_scope->__pyx_v_args); + __pyx_cur_scope->__pyx_v_portal_name = __pyx_v_portal_name; + __Pyx_INCREF(__pyx_cur_scope->__pyx_v_portal_name); + __Pyx_GIVEREF(__pyx_cur_scope->__pyx_v_portal_name); + __pyx_cur_scope->__pyx_v_limit = __pyx_v_limit; + __pyx_cur_scope->__pyx_v_return_extra = __pyx_v_return_extra; + __Pyx_INCREF(__pyx_cur_scope->__pyx_v_return_extra); + __Pyx_GIVEREF(__pyx_cur_scope->__pyx_v_return_extra); + __pyx_cur_scope->__pyx_v_timeout = __pyx_v_timeout; + __Pyx_INCREF(__pyx_cur_scope->__pyx_v_timeout); + __Pyx_GIVEREF(__pyx_cur_scope->__pyx_v_timeout); + { + __pyx_CoroutineObject *gen = __Pyx_Coroutine_New((__pyx_coroutine_body_t) __pyx_gb_7asyncpg_8protocol_8protocol_12BaseProtocol_13generator1, (PyObject *) __pyx_cur_scope, __pyx_n_s_bind_execute, __pyx_n_s_BaseProtocol_bind_execute, __pyx_n_s_asyncpg_protocol_protocol); if (unlikely(!gen)) __PYX_ERR(27, 142, __pyx_L1_error) + __Pyx_DECREF(__pyx_cur_scope); + __Pyx_RefNannyFinishContext(); + return (PyObject *) gen; + } + + /* function exit code */ + __pyx_L1_error:; + __Pyx_AddTraceback("asyncpg.protocol.protocol.BaseProtocol.bind_execute", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __Pyx_DECREF(((PyObject *)__pyx_cur_scope)); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_gb_7asyncpg_8protocol_8protocol_12BaseProtocol_13generator1(__pyx_CoroutineObject *__pyx_generator, PyObject *__pyx_sent_value) /* generator body */ +{ + struct __pyx_obj_7asyncpg_8protocol_8protocol___pyx_scope_struct_1_bind_execute *__pyx_cur_scope = ((struct __pyx_obj_7asyncpg_8protocol_8protocol___pyx_scope_struct_1_bind_execute *)__pyx_generator->closure); + PyObject *__pyx_r = NULL; + int __pyx_t_1; + int __pyx_t_2; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + PyObject *__pyx_t_5 = NULL; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("None", 0); + switch (__pyx_generator->resume_label) { + case 0: goto __pyx_L3_first_run; + case 1: goto __pyx_L5_resume_from_yield; + case 2: goto __pyx_L7_resume_from_yield; + case 3: goto __pyx_L8_resume_from_yield; + default: /* CPython raises the right error here */ + __Pyx_RefNannyFinishContext(); + return NULL; + } + __pyx_L3_first_run:; + if (unlikely(!__pyx_sent_value)) __PYX_ERR(27, 142, __pyx_L1_error) + + /* "asyncpg/protocol/protocol.pyx":146 + * timeout): + * + * if self.cancel_waiter is not None: # <<<<<<<<<<<<<< + * await self.cancel_waiter + * if self.cancel_sent_waiter is not None: + */ + __pyx_t_1 = (__pyx_cur_scope->__pyx_v_self->cancel_waiter != Py_None); + __pyx_t_2 = (__pyx_t_1 != 0); + if (__pyx_t_2) { + + /* "asyncpg/protocol/protocol.pyx":147 + * + * if self.cancel_waiter is not None: + * await self.cancel_waiter # <<<<<<<<<<<<<< + * if self.cancel_sent_waiter is not None: + * await self.cancel_sent_waiter + */ + __pyx_r = __Pyx_Coroutine_Yield_From(__pyx_generator, __pyx_cur_scope->__pyx_v_self->cancel_waiter); + __Pyx_XGOTREF(__pyx_r); + if (likely(__pyx_r)) { + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + /* return from generator, yielding value */ + __pyx_generator->resume_label = 1; + return __pyx_r; + __pyx_L5_resume_from_yield:; + if (unlikely(!__pyx_sent_value)) __PYX_ERR(27, 147, __pyx_L1_error) + } else { + PyObject* exc_type = PyErr_Occurred(); + if (exc_type) { + if (likely(exc_type == PyExc_StopIteration || PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) PyErr_Clear(); + else __PYX_ERR(27, 147, __pyx_L1_error) + } + } + + /* "asyncpg/protocol/protocol.pyx":146 + * timeout): + * + * if self.cancel_waiter is not None: # <<<<<<<<<<<<<< + * await self.cancel_waiter + * if self.cancel_sent_waiter is not None: + */ + } + + /* "asyncpg/protocol/protocol.pyx":148 + * if self.cancel_waiter is not None: + * await self.cancel_waiter + * if self.cancel_sent_waiter is not None: # <<<<<<<<<<<<<< + * await self.cancel_sent_waiter + * self.cancel_sent_waiter = None + */ + __pyx_t_2 = (__pyx_cur_scope->__pyx_v_self->cancel_sent_waiter != Py_None); + __pyx_t_1 = (__pyx_t_2 != 0); + if (__pyx_t_1) { + + /* "asyncpg/protocol/protocol.pyx":149 + * await self.cancel_waiter + * if self.cancel_sent_waiter is not None: + * await self.cancel_sent_waiter # <<<<<<<<<<<<<< + * self.cancel_sent_waiter = None + * + */ + __pyx_r = __Pyx_Coroutine_Yield_From(__pyx_generator, __pyx_cur_scope->__pyx_v_self->cancel_sent_waiter); + __Pyx_XGOTREF(__pyx_r); + if (likely(__pyx_r)) { + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + /* return from generator, yielding value */ + __pyx_generator->resume_label = 2; + return __pyx_r; + __pyx_L7_resume_from_yield:; + if (unlikely(!__pyx_sent_value)) __PYX_ERR(27, 149, __pyx_L1_error) + } else { + PyObject* exc_type = PyErr_Occurred(); + if (exc_type) { + if (likely(exc_type == PyExc_StopIteration || PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) PyErr_Clear(); + else __PYX_ERR(27, 149, __pyx_L1_error) + } + } + + /* "asyncpg/protocol/protocol.pyx":150 + * if self.cancel_sent_waiter is not None: + * await self.cancel_sent_waiter + * self.cancel_sent_waiter = None # <<<<<<<<<<<<<< + * + * self._ensure_clear_state() + */ + __Pyx_INCREF(Py_None); + __Pyx_GIVEREF(Py_None); + __Pyx_GOTREF(__pyx_cur_scope->__pyx_v_self->cancel_sent_waiter); + __Pyx_DECREF(__pyx_cur_scope->__pyx_v_self->cancel_sent_waiter); + __pyx_cur_scope->__pyx_v_self->cancel_sent_waiter = Py_None; + + /* "asyncpg/protocol/protocol.pyx":148 + * if self.cancel_waiter is not None: + * await self.cancel_waiter + * if self.cancel_sent_waiter is not None: # <<<<<<<<<<<<<< + * await self.cancel_sent_waiter + * self.cancel_sent_waiter = None + */ + } + + /* "asyncpg/protocol/protocol.pyx":152 + * self.cancel_sent_waiter = None + * + * self._ensure_clear_state() # <<<<<<<<<<<<<< + * + * self._bind_execute( + */ + __pyx_t_3 = ((struct __pyx_vtabstruct_7asyncpg_8protocol_8protocol_BaseProtocol *)__pyx_cur_scope->__pyx_v_self->__pyx_base.__pyx_vtab)->_ensure_clear_state(__pyx_cur_scope->__pyx_v_self); if (unlikely(!__pyx_t_3)) __PYX_ERR(27, 152, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + + /* "asyncpg/protocol/protocol.pyx":156 + * self._bind_execute( + * portal_name, + * state.name, # <<<<<<<<<<<<<< + * state._encode_bind_msg(args), + * limit) + */ + __pyx_t_3 = __pyx_cur_scope->__pyx_v_state->name; + __Pyx_INCREF(__pyx_t_3); + + /* "asyncpg/protocol/protocol.pyx":157 + * portal_name, + * state.name, + * state._encode_bind_msg(args), # <<<<<<<<<<<<<< + * limit) + * + */ + __pyx_t_4 = __pyx_f_7asyncpg_8protocol_8protocol_22PreparedStatementState__encode_bind_msg(__pyx_cur_scope->__pyx_v_state, __pyx_cur_scope->__pyx_v_args); if (unlikely(!__pyx_t_4)) __PYX_ERR(27, 157, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + if (!(likely(((__pyx_t_4) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_4, __pyx_ptype_7asyncpg_8protocol_8protocol_WriteBuffer))))) __PYX_ERR(27, 157, __pyx_L1_error) + + /* "asyncpg/protocol/protocol.pyx":154 + * self._ensure_clear_state() + * + * self._bind_execute( # <<<<<<<<<<<<<< + * portal_name, + * state.name, + */ + __pyx_t_5 = ((struct __pyx_vtabstruct_7asyncpg_8protocol_8protocol_BaseProtocol *)__pyx_cur_scope->__pyx_v_self->__pyx_base.__pyx_vtab)->__pyx_base._bind_execute(((struct __pyx_obj_7asyncpg_8protocol_8protocol_CoreProtocol *)__pyx_cur_scope->__pyx_v_self), __pyx_cur_scope->__pyx_v_portal_name, ((PyObject*)__pyx_t_3), ((struct __pyx_obj_7asyncpg_8protocol_8protocol_WriteBuffer *)__pyx_t_4), __pyx_cur_scope->__pyx_v_limit); if (unlikely(!__pyx_t_5)) __PYX_ERR(27, 154, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + + /* "asyncpg/protocol/protocol.pyx":160 + * limit) + * + * self.last_query = state.query # <<<<<<<<<<<<<< + * self.statement = state + * self.return_extra = return_extra + */ + __pyx_t_5 = __pyx_cur_scope->__pyx_v_state->query; + __Pyx_INCREF(__pyx_t_5); + __Pyx_GIVEREF(__pyx_t_5); + __Pyx_GOTREF(__pyx_cur_scope->__pyx_v_self->last_query); + __Pyx_DECREF(__pyx_cur_scope->__pyx_v_self->last_query); + __pyx_cur_scope->__pyx_v_self->last_query = ((PyObject*)__pyx_t_5); + __pyx_t_5 = 0; + + /* "asyncpg/protocol/protocol.pyx":161 + * + * self.last_query = state.query + * self.statement = state # <<<<<<<<<<<<<< + * self.return_extra = return_extra + * self.queries_count += 1 + */ + __Pyx_INCREF(((PyObject *)__pyx_cur_scope->__pyx_v_state)); + __Pyx_GIVEREF(((PyObject *)__pyx_cur_scope->__pyx_v_state)); + __Pyx_GOTREF(__pyx_cur_scope->__pyx_v_self->statement); + __Pyx_DECREF(((PyObject *)__pyx_cur_scope->__pyx_v_self->statement)); + __pyx_cur_scope->__pyx_v_self->statement = __pyx_cur_scope->__pyx_v_state; + + /* "asyncpg/protocol/protocol.pyx":162 + * self.last_query = state.query + * self.statement = state + * self.return_extra = return_extra # <<<<<<<<<<<<<< + * self.queries_count += 1 + * + */ + __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_cur_scope->__pyx_v_return_extra); if (unlikely((__pyx_t_1 == (int)-1) && PyErr_Occurred())) __PYX_ERR(27, 162, __pyx_L1_error) + __pyx_cur_scope->__pyx_v_self->return_extra = __pyx_t_1; + + /* "asyncpg/protocol/protocol.pyx":163 + * self.statement = state + * self.return_extra = return_extra + * self.queries_count += 1 # <<<<<<<<<<<<<< + * + * return await self._new_waiter(timeout) + */ + __pyx_cur_scope->__pyx_v_self->queries_count = (__pyx_cur_scope->__pyx_v_self->queries_count + 1); + + /* "asyncpg/protocol/protocol.pyx":165 + * self.queries_count += 1 + * + * return await self._new_waiter(timeout) # <<<<<<<<<<<<<< + * + * async def bind_execute_many(self, PreparedStatementState state, args, + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_5 = ((struct __pyx_vtabstruct_7asyncpg_8protocol_8protocol_BaseProtocol *)__pyx_cur_scope->__pyx_v_self->__pyx_base.__pyx_vtab)->_new_waiter(__pyx_cur_scope->__pyx_v_self, __pyx_cur_scope->__pyx_v_timeout); if (unlikely(!__pyx_t_5)) __PYX_ERR(27, 165, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_r = __Pyx_Coroutine_Yield_From(__pyx_generator, __pyx_t_5); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_XGOTREF(__pyx_r); + if (likely(__pyx_r)) { + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + /* return from generator, yielding value */ + __pyx_generator->resume_label = 3; + return __pyx_r; + __pyx_L8_resume_from_yield:; + if (unlikely(!__pyx_sent_value)) __PYX_ERR(27, 165, __pyx_L1_error) + __pyx_t_5 = __pyx_sent_value; __Pyx_INCREF(__pyx_t_5); + } else { + __pyx_t_5 = NULL; + if (__Pyx_PyGen_FetchStopIterationValue(&__pyx_t_5) < 0) __PYX_ERR(27, 165, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + } + __pyx_r = NULL; __Pyx_ReturnWithStopIteration(__pyx_t_5); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __pyx_t_5 = 0; + goto __pyx_L0; + CYTHON_MAYBE_UNUSED_VAR(__pyx_cur_scope); + + /* "asyncpg/protocol/protocol.pyx":142 + * return await self._new_waiter(timeout) + * + * async def bind_execute(self, PreparedStatementState state, args, # <<<<<<<<<<<<<< + * str portal_name, int limit, return_extra, + * timeout): + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_AddTraceback("bind_execute", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_L0:; + __Pyx_XDECREF(__pyx_r); __pyx_r = 0; + __pyx_generator->resume_label = -1; + __Pyx_Coroutine_clear((PyObject*)__pyx_generator); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} +static PyObject *__pyx_gb_7asyncpg_8protocol_8protocol_12BaseProtocol_16generator2(__pyx_CoroutineObject *__pyx_generator, PyObject *__pyx_sent_value); /* proto */ + +/* "asyncpg/protocol/protocol.pyx":167 + * return await self._new_waiter(timeout) + * + * async def bind_execute_many(self, PreparedStatementState state, args, # <<<<<<<<<<<<<< + * str portal_name, timeout): + * + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_7asyncpg_8protocol_8protocol_12BaseProtocol_15bind_execute_many(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ +static PyObject *__pyx_pw_7asyncpg_8protocol_8protocol_12BaseProtocol_15bind_execute_many(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { + struct __pyx_obj_7asyncpg_8protocol_8protocol_PreparedStatementState *__pyx_v_state = 0; + PyObject *__pyx_v_args = 0; + PyObject *__pyx_v_portal_name = 0; + PyObject *__pyx_v_timeout = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("bind_execute_many (wrapper)", 0); + { + static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_state,&__pyx_n_s_args,&__pyx_n_s_portal_name,&__pyx_n_s_timeout,0}; + PyObject* values[4] = {0,0,0,0}; + if (unlikely(__pyx_kwds)) { + Py_ssize_t kw_args; + const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args); + switch (pos_args) { + case 4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3); + case 3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2); + case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); + case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = PyDict_Size(__pyx_kwds); + switch (pos_args) { + case 0: + if (likely((values[0] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_state)) != 0)) kw_args--; + else goto __pyx_L5_argtuple_error; + case 1: + if (likely((values[1] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_args)) != 0)) kw_args--; + else { + __Pyx_RaiseArgtupleInvalid("bind_execute_many", 1, 4, 4, 1); __PYX_ERR(27, 167, __pyx_L3_error) + } + case 2: + if (likely((values[2] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_portal_name)) != 0)) kw_args--; + else { + __Pyx_RaiseArgtupleInvalid("bind_execute_many", 1, 4, 4, 2); __PYX_ERR(27, 167, __pyx_L3_error) + } + case 3: + if (likely((values[3] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_timeout)) != 0)) kw_args--; + else { + __Pyx_RaiseArgtupleInvalid("bind_execute_many", 1, 4, 4, 3); __PYX_ERR(27, 167, __pyx_L3_error) + } + } + if (unlikely(kw_args > 0)) { + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "bind_execute_many") < 0)) __PYX_ERR(27, 167, __pyx_L3_error) + } + } else if (PyTuple_GET_SIZE(__pyx_args) != 4) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + values[1] = PyTuple_GET_ITEM(__pyx_args, 1); + values[2] = PyTuple_GET_ITEM(__pyx_args, 2); + values[3] = PyTuple_GET_ITEM(__pyx_args, 3); + } + __pyx_v_state = ((struct __pyx_obj_7asyncpg_8protocol_8protocol_PreparedStatementState *)values[0]); + __pyx_v_args = values[1]; + __pyx_v_portal_name = ((PyObject*)values[2]); + __pyx_v_timeout = values[3]; + } + goto __pyx_L4_argument_unpacking_done; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("bind_execute_many", 1, 4, 4, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(27, 167, __pyx_L3_error) + __pyx_L3_error:; + __Pyx_AddTraceback("asyncpg.protocol.protocol.BaseProtocol.bind_execute_many", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_state), __pyx_ptype_7asyncpg_8protocol_8protocol_PreparedStatementState, 1, "state", 0))) __PYX_ERR(27, 167, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_portal_name), (&PyUnicode_Type), 1, "portal_name", 1))) __PYX_ERR(27, 168, __pyx_L1_error) + __pyx_r = __pyx_pf_7asyncpg_8protocol_8protocol_12BaseProtocol_14bind_execute_many(((struct __pyx_obj_7asyncpg_8protocol_8protocol_BaseProtocol *)__pyx_v_self), __pyx_v_state, __pyx_v_args, __pyx_v_portal_name, __pyx_v_timeout); + + /* function exit code */ + goto __pyx_L0; + __pyx_L1_error:; + __pyx_r = NULL; + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} +static PyObject *__pyx_gb_7asyncpg_8protocol_8protocol_12BaseProtocol_17bind_execute_many_2generator8(__pyx_CoroutineObject *__pyx_generator, PyObject *__pyx_sent_value); /* proto */ + +/* "asyncpg/protocol/protocol.pyx":181 + * # this generator expression to keep the memory pressure under + * # control. + * data_gen = (state._encode_bind_msg(b) for b in args) # <<<<<<<<<<<<<< + * arg_bufs = iter(data_gen) + * + */ + +static PyObject *__pyx_pf_7asyncpg_8protocol_8protocol_12BaseProtocol_17bind_execute_many_genexpr(PyObject *__pyx_self) { + struct __pyx_obj_7asyncpg_8protocol_8protocol___pyx_scope_struct_3_genexpr *__pyx_cur_scope; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("genexpr", 0); + __pyx_cur_scope = (struct __pyx_obj_7asyncpg_8protocol_8protocol___pyx_scope_struct_3_genexpr *)__pyx_tp_new_7asyncpg_8protocol_8protocol___pyx_scope_struct_3_genexpr(__pyx_ptype_7asyncpg_8protocol_8protocol___pyx_scope_struct_3_genexpr, __pyx_empty_tuple, NULL); + if (unlikely(!__pyx_cur_scope)) { + __pyx_cur_scope = ((struct __pyx_obj_7asyncpg_8protocol_8protocol___pyx_scope_struct_3_genexpr *)Py_None); + __Pyx_INCREF(Py_None); + __PYX_ERR(27, 181, __pyx_L1_error) + } else { + __Pyx_GOTREF(__pyx_cur_scope); + } + __pyx_cur_scope->__pyx_outer_scope = (struct __pyx_obj_7asyncpg_8protocol_8protocol___pyx_scope_struct_2_bind_execute_many *) __pyx_self; + __Pyx_INCREF(((PyObject *)__pyx_cur_scope->__pyx_outer_scope)); + __Pyx_GIVEREF(__pyx_cur_scope->__pyx_outer_scope); + { + __pyx_CoroutineObject *gen = __Pyx_Generator_New((__pyx_coroutine_body_t) __pyx_gb_7asyncpg_8protocol_8protocol_12BaseProtocol_17bind_execute_many_2generator8, (PyObject *) __pyx_cur_scope, __pyx_n_s_genexpr, __pyx_n_s_bind_execute_many_locals_genexpr, __pyx_n_s_asyncpg_protocol_protocol); if (unlikely(!gen)) __PYX_ERR(27, 181, __pyx_L1_error) + __Pyx_DECREF(__pyx_cur_scope); + __Pyx_RefNannyFinishContext(); + return (PyObject *) gen; + } + + /* function exit code */ + __pyx_L1_error:; + __Pyx_AddTraceback("asyncpg.protocol.protocol.BaseProtocol.bind_execute_many.genexpr", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __Pyx_DECREF(((PyObject *)__pyx_cur_scope)); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_gb_7asyncpg_8protocol_8protocol_12BaseProtocol_17bind_execute_many_2generator8(__pyx_CoroutineObject *__pyx_generator, PyObject *__pyx_sent_value) /* generator body */ +{ + struct __pyx_obj_7asyncpg_8protocol_8protocol___pyx_scope_struct_3_genexpr *__pyx_cur_scope = ((struct __pyx_obj_7asyncpg_8protocol_8protocol___pyx_scope_struct_3_genexpr *)__pyx_generator->closure); + PyObject *__pyx_r = NULL; + PyObject *__pyx_t_1 = NULL; + Py_ssize_t __pyx_t_2; + PyObject *(*__pyx_t_3)(PyObject *); + PyObject *__pyx_t_4 = NULL; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("None", 0); + switch (__pyx_generator->resume_label) { + case 0: goto __pyx_L3_first_run; + case 1: goto __pyx_L6_resume_from_yield; + default: /* CPython raises the right error here */ + __Pyx_RefNannyFinishContext(); + return NULL; + } + __pyx_L3_first_run:; + if (unlikely(!__pyx_sent_value)) __PYX_ERR(27, 181, __pyx_L1_error) + if (unlikely(!__pyx_cur_scope->__pyx_outer_scope->__pyx_v_args)) { __Pyx_RaiseClosureNameError("args"); __PYX_ERR(27, 181, __pyx_L1_error) } + if (likely(PyList_CheckExact(__pyx_cur_scope->__pyx_outer_scope->__pyx_v_args)) || PyTuple_CheckExact(__pyx_cur_scope->__pyx_outer_scope->__pyx_v_args)) { + __pyx_t_1 = __pyx_cur_scope->__pyx_outer_scope->__pyx_v_args; __Pyx_INCREF(__pyx_t_1); __pyx_t_2 = 0; + __pyx_t_3 = NULL; + } else { + __pyx_t_2 = -1; __pyx_t_1 = PyObject_GetIter(__pyx_cur_scope->__pyx_outer_scope->__pyx_v_args); if (unlikely(!__pyx_t_1)) __PYX_ERR(27, 181, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_3 = Py_TYPE(__pyx_t_1)->tp_iternext; if (unlikely(!__pyx_t_3)) __PYX_ERR(27, 181, __pyx_L1_error) + } + for (;;) { + if (likely(!__pyx_t_3)) { + if (likely(PyList_CheckExact(__pyx_t_1))) { + if (__pyx_t_2 >= PyList_GET_SIZE(__pyx_t_1)) break; + #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + __pyx_t_4 = PyList_GET_ITEM(__pyx_t_1, __pyx_t_2); __Pyx_INCREF(__pyx_t_4); __pyx_t_2++; if (unlikely(0 < 0)) __PYX_ERR(27, 181, __pyx_L1_error) + #else + __pyx_t_4 = PySequence_ITEM(__pyx_t_1, __pyx_t_2); __pyx_t_2++; if (unlikely(!__pyx_t_4)) __PYX_ERR(27, 181, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + #endif + } else { + if (__pyx_t_2 >= PyTuple_GET_SIZE(__pyx_t_1)) break; + #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + __pyx_t_4 = PyTuple_GET_ITEM(__pyx_t_1, __pyx_t_2); __Pyx_INCREF(__pyx_t_4); __pyx_t_2++; if (unlikely(0 < 0)) __PYX_ERR(27, 181, __pyx_L1_error) + #else + __pyx_t_4 = PySequence_ITEM(__pyx_t_1, __pyx_t_2); __pyx_t_2++; if (unlikely(!__pyx_t_4)) __PYX_ERR(27, 181, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + #endif + } + } else { + __pyx_t_4 = __pyx_t_3(__pyx_t_1); + if (unlikely(!__pyx_t_4)) { + PyObject* exc_type = PyErr_Occurred(); + if (exc_type) { + if (likely(exc_type == PyExc_StopIteration || PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) PyErr_Clear(); + else __PYX_ERR(27, 181, __pyx_L1_error) + } + break; + } + __Pyx_GOTREF(__pyx_t_4); + } + __Pyx_XGOTREF(__pyx_cur_scope->__pyx_v_b); + __Pyx_XDECREF_SET(__pyx_cur_scope->__pyx_v_b, __pyx_t_4); + __Pyx_GIVEREF(__pyx_t_4); + __pyx_t_4 = 0; + if (unlikely(!__pyx_cur_scope->__pyx_outer_scope->__pyx_v_state)) { __Pyx_RaiseClosureNameError("state"); __PYX_ERR(27, 181, __pyx_L1_error) } + __pyx_t_4 = __pyx_f_7asyncpg_8protocol_8protocol_22PreparedStatementState__encode_bind_msg(__pyx_cur_scope->__pyx_outer_scope->__pyx_v_state, __pyx_cur_scope->__pyx_v_b); if (unlikely(!__pyx_t_4)) __PYX_ERR(27, 181, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_r = __pyx_t_4; + __pyx_t_4 = 0; + __Pyx_XGIVEREF(__pyx_t_1); + __pyx_cur_scope->__pyx_t_0 = __pyx_t_1; + __pyx_cur_scope->__pyx_t_1 = __pyx_t_2; + __pyx_cur_scope->__pyx_t_2 = __pyx_t_3; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + /* return from generator, yielding value */ + __pyx_generator->resume_label = 1; + return __pyx_r; + __pyx_L6_resume_from_yield:; + __pyx_t_1 = __pyx_cur_scope->__pyx_t_0; + __pyx_cur_scope->__pyx_t_0 = 0; + __Pyx_XGOTREF(__pyx_t_1); + __pyx_t_2 = __pyx_cur_scope->__pyx_t_1; + __pyx_t_3 = __pyx_cur_scope->__pyx_t_2; + if (unlikely(!__pyx_sent_value)) __PYX_ERR(27, 181, __pyx_L1_error) + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + CYTHON_MAYBE_UNUSED_VAR(__pyx_cur_scope); + + /* function exit code */ + PyErr_SetNone(PyExc_StopIteration); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_AddTraceback("genexpr", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_L0:; + __Pyx_XDECREF(__pyx_r); __pyx_r = 0; + __pyx_generator->resume_label = -1; + __Pyx_Coroutine_clear((PyObject*)__pyx_generator); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "asyncpg/protocol/protocol.pyx":167 + * return await self._new_waiter(timeout) + * + * async def bind_execute_many(self, PreparedStatementState state, args, # <<<<<<<<<<<<<< + * str portal_name, timeout): + * + */ + +static PyObject *__pyx_pf_7asyncpg_8protocol_8protocol_12BaseProtocol_14bind_execute_many(struct __pyx_obj_7asyncpg_8protocol_8protocol_BaseProtocol *__pyx_v_self, struct __pyx_obj_7asyncpg_8protocol_8protocol_PreparedStatementState *__pyx_v_state, PyObject *__pyx_v_args, PyObject *__pyx_v_portal_name, PyObject *__pyx_v_timeout) { + struct __pyx_obj_7asyncpg_8protocol_8protocol___pyx_scope_struct_2_bind_execute_many *__pyx_cur_scope; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("bind_execute_many", 0); + __pyx_cur_scope = (struct __pyx_obj_7asyncpg_8protocol_8protocol___pyx_scope_struct_2_bind_execute_many *)__pyx_tp_new_7asyncpg_8protocol_8protocol___pyx_scope_struct_2_bind_execute_many(__pyx_ptype_7asyncpg_8protocol_8protocol___pyx_scope_struct_2_bind_execute_many, __pyx_empty_tuple, NULL); + if (unlikely(!__pyx_cur_scope)) { + __pyx_cur_scope = ((struct __pyx_obj_7asyncpg_8protocol_8protocol___pyx_scope_struct_2_bind_execute_many *)Py_None); + __Pyx_INCREF(Py_None); + __PYX_ERR(27, 167, __pyx_L1_error) + } else { + __Pyx_GOTREF(__pyx_cur_scope); + } + __pyx_cur_scope->__pyx_v_self = __pyx_v_self; + __Pyx_INCREF((PyObject *)__pyx_cur_scope->__pyx_v_self); + __Pyx_GIVEREF((PyObject *)__pyx_cur_scope->__pyx_v_self); + __pyx_cur_scope->__pyx_v_state = __pyx_v_state; + __Pyx_INCREF((PyObject *)__pyx_cur_scope->__pyx_v_state); + __Pyx_GIVEREF((PyObject *)__pyx_cur_scope->__pyx_v_state); + __pyx_cur_scope->__pyx_v_args = __pyx_v_args; + __Pyx_INCREF(__pyx_cur_scope->__pyx_v_args); + __Pyx_GIVEREF(__pyx_cur_scope->__pyx_v_args); + __pyx_cur_scope->__pyx_v_portal_name = __pyx_v_portal_name; + __Pyx_INCREF(__pyx_cur_scope->__pyx_v_portal_name); + __Pyx_GIVEREF(__pyx_cur_scope->__pyx_v_portal_name); + __pyx_cur_scope->__pyx_v_timeout = __pyx_v_timeout; + __Pyx_INCREF(__pyx_cur_scope->__pyx_v_timeout); + __Pyx_GIVEREF(__pyx_cur_scope->__pyx_v_timeout); + { + __pyx_CoroutineObject *gen = __Pyx_Coroutine_New((__pyx_coroutine_body_t) __pyx_gb_7asyncpg_8protocol_8protocol_12BaseProtocol_16generator2, (PyObject *) __pyx_cur_scope, __pyx_n_s_bind_execute_many, __pyx_n_s_BaseProtocol_bind_execute_many, __pyx_n_s_asyncpg_protocol_protocol); if (unlikely(!gen)) __PYX_ERR(27, 167, __pyx_L1_error) + __Pyx_DECREF(__pyx_cur_scope); + __Pyx_RefNannyFinishContext(); + return (PyObject *) gen; + } + + /* function exit code */ + __pyx_L1_error:; + __Pyx_AddTraceback("asyncpg.protocol.protocol.BaseProtocol.bind_execute_many", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __Pyx_DECREF(((PyObject *)__pyx_cur_scope)); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_gb_7asyncpg_8protocol_8protocol_12BaseProtocol_16generator2(__pyx_CoroutineObject *__pyx_generator, PyObject *__pyx_sent_value) /* generator body */ +{ + struct __pyx_obj_7asyncpg_8protocol_8protocol___pyx_scope_struct_2_bind_execute_many *__pyx_cur_scope = ((struct __pyx_obj_7asyncpg_8protocol_8protocol___pyx_scope_struct_2_bind_execute_many *)__pyx_generator->closure); + PyObject *__pyx_r = NULL; + int __pyx_t_1; + int __pyx_t_2; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("None", 0); + switch (__pyx_generator->resume_label) { + case 0: goto __pyx_L3_first_run; + case 1: goto __pyx_L5_resume_from_yield; + case 2: goto __pyx_L7_resume_from_yield; + case 3: goto __pyx_L8_resume_from_yield; + default: /* CPython raises the right error here */ + __Pyx_RefNannyFinishContext(); + return NULL; + } + __pyx_L3_first_run:; + if (unlikely(!__pyx_sent_value)) __PYX_ERR(27, 167, __pyx_L1_error) + + /* "asyncpg/protocol/protocol.pyx":170 + * str portal_name, timeout): + * + * if self.cancel_waiter is not None: # <<<<<<<<<<<<<< + * await self.cancel_waiter + * if self.cancel_sent_waiter is not None: + */ + __pyx_t_1 = (__pyx_cur_scope->__pyx_v_self->cancel_waiter != Py_None); + __pyx_t_2 = (__pyx_t_1 != 0); + if (__pyx_t_2) { + + /* "asyncpg/protocol/protocol.pyx":171 + * + * if self.cancel_waiter is not None: + * await self.cancel_waiter # <<<<<<<<<<<<<< + * if self.cancel_sent_waiter is not None: + * await self.cancel_sent_waiter + */ + __pyx_r = __Pyx_Coroutine_Yield_From(__pyx_generator, __pyx_cur_scope->__pyx_v_self->cancel_waiter); + __Pyx_XGOTREF(__pyx_r); + if (likely(__pyx_r)) { + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + /* return from generator, yielding value */ + __pyx_generator->resume_label = 1; + return __pyx_r; + __pyx_L5_resume_from_yield:; + if (unlikely(!__pyx_sent_value)) __PYX_ERR(27, 171, __pyx_L1_error) + } else { + PyObject* exc_type = PyErr_Occurred(); + if (exc_type) { + if (likely(exc_type == PyExc_StopIteration || PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) PyErr_Clear(); + else __PYX_ERR(27, 171, __pyx_L1_error) + } + } + + /* "asyncpg/protocol/protocol.pyx":170 + * str portal_name, timeout): + * + * if self.cancel_waiter is not None: # <<<<<<<<<<<<<< + * await self.cancel_waiter + * if self.cancel_sent_waiter is not None: + */ + } + + /* "asyncpg/protocol/protocol.pyx":172 + * if self.cancel_waiter is not None: + * await self.cancel_waiter + * if self.cancel_sent_waiter is not None: # <<<<<<<<<<<<<< + * await self.cancel_sent_waiter + * self.cancel_sent_waiter = None + */ + __pyx_t_2 = (__pyx_cur_scope->__pyx_v_self->cancel_sent_waiter != Py_None); + __pyx_t_1 = (__pyx_t_2 != 0); + if (__pyx_t_1) { + + /* "asyncpg/protocol/protocol.pyx":173 + * await self.cancel_waiter + * if self.cancel_sent_waiter is not None: + * await self.cancel_sent_waiter # <<<<<<<<<<<<<< + * self.cancel_sent_waiter = None + * + */ + __pyx_r = __Pyx_Coroutine_Yield_From(__pyx_generator, __pyx_cur_scope->__pyx_v_self->cancel_sent_waiter); + __Pyx_XGOTREF(__pyx_r); + if (likely(__pyx_r)) { + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + /* return from generator, yielding value */ + __pyx_generator->resume_label = 2; + return __pyx_r; + __pyx_L7_resume_from_yield:; + if (unlikely(!__pyx_sent_value)) __PYX_ERR(27, 173, __pyx_L1_error) + } else { + PyObject* exc_type = PyErr_Occurred(); + if (exc_type) { + if (likely(exc_type == PyExc_StopIteration || PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) PyErr_Clear(); + else __PYX_ERR(27, 173, __pyx_L1_error) + } + } + + /* "asyncpg/protocol/protocol.pyx":174 + * if self.cancel_sent_waiter is not None: + * await self.cancel_sent_waiter + * self.cancel_sent_waiter = None # <<<<<<<<<<<<<< + * + * self._ensure_clear_state() + */ + __Pyx_INCREF(Py_None); + __Pyx_GIVEREF(Py_None); + __Pyx_GOTREF(__pyx_cur_scope->__pyx_v_self->cancel_sent_waiter); + __Pyx_DECREF(__pyx_cur_scope->__pyx_v_self->cancel_sent_waiter); + __pyx_cur_scope->__pyx_v_self->cancel_sent_waiter = Py_None; + + /* "asyncpg/protocol/protocol.pyx":172 + * if self.cancel_waiter is not None: + * await self.cancel_waiter + * if self.cancel_sent_waiter is not None: # <<<<<<<<<<<<<< + * await self.cancel_sent_waiter + * self.cancel_sent_waiter = None + */ + } + + /* "asyncpg/protocol/protocol.pyx":176 + * self.cancel_sent_waiter = None + * + * self._ensure_clear_state() # <<<<<<<<<<<<<< + * + * # Make sure the argument sequence is encoded lazily with + */ + __pyx_t_3 = ((struct __pyx_vtabstruct_7asyncpg_8protocol_8protocol_BaseProtocol *)__pyx_cur_scope->__pyx_v_self->__pyx_base.__pyx_vtab)->_ensure_clear_state(__pyx_cur_scope->__pyx_v_self); if (unlikely(!__pyx_t_3)) __PYX_ERR(27, 176, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + + /* "asyncpg/protocol/protocol.pyx":181 + * # this generator expression to keep the memory pressure under + * # control. + * data_gen = (state._encode_bind_msg(b) for b in args) # <<<<<<<<<<<<<< + * arg_bufs = iter(data_gen) + * + */ + __pyx_t_3 = __pyx_pf_7asyncpg_8protocol_8protocol_12BaseProtocol_17bind_execute_many_genexpr(((PyObject*)__pyx_cur_scope)); if (unlikely(!__pyx_t_3)) __PYX_ERR(27, 181, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_GIVEREF(__pyx_t_3); + __pyx_cur_scope->__pyx_v_data_gen = __pyx_t_3; + __pyx_t_3 = 0; + + /* "asyncpg/protocol/protocol.pyx":182 + * # control. + * data_gen = (state._encode_bind_msg(b) for b in args) + * arg_bufs = iter(data_gen) # <<<<<<<<<<<<<< + * + * waiter = self._new_waiter(timeout) + */ + __pyx_t_3 = PyObject_GetIter(__pyx_cur_scope->__pyx_v_data_gen); if (unlikely(!__pyx_t_3)) __PYX_ERR(27, 182, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_GIVEREF(__pyx_t_3); + __pyx_cur_scope->__pyx_v_arg_bufs = __pyx_t_3; + __pyx_t_3 = 0; + + /* "asyncpg/protocol/protocol.pyx":184 + * arg_bufs = iter(data_gen) + * + * waiter = self._new_waiter(timeout) # <<<<<<<<<<<<<< + * + * self._bind_execute_many( + */ + __pyx_t_3 = ((struct __pyx_vtabstruct_7asyncpg_8protocol_8protocol_BaseProtocol *)__pyx_cur_scope->__pyx_v_self->__pyx_base.__pyx_vtab)->_new_waiter(__pyx_cur_scope->__pyx_v_self, __pyx_cur_scope->__pyx_v_timeout); if (unlikely(!__pyx_t_3)) __PYX_ERR(27, 184, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_GIVEREF(__pyx_t_3); + __pyx_cur_scope->__pyx_v_waiter = __pyx_t_3; + __pyx_t_3 = 0; + + /* "asyncpg/protocol/protocol.pyx":188 + * self._bind_execute_many( + * portal_name, + * state.name, # <<<<<<<<<<<<<< + * arg_bufs) + * + */ + __pyx_t_3 = __pyx_cur_scope->__pyx_v_state->name; + __Pyx_INCREF(__pyx_t_3); + + /* "asyncpg/protocol/protocol.pyx":186 + * waiter = self._new_waiter(timeout) + * + * self._bind_execute_many( # <<<<<<<<<<<<<< + * portal_name, + * state.name, + */ + __pyx_t_4 = ((struct __pyx_vtabstruct_7asyncpg_8protocol_8protocol_BaseProtocol *)__pyx_cur_scope->__pyx_v_self->__pyx_base.__pyx_vtab)->__pyx_base._bind_execute_many(((struct __pyx_obj_7asyncpg_8protocol_8protocol_CoreProtocol *)__pyx_cur_scope->__pyx_v_self), __pyx_cur_scope->__pyx_v_portal_name, ((PyObject*)__pyx_t_3), __pyx_cur_scope->__pyx_v_arg_bufs); if (unlikely(!__pyx_t_4)) __PYX_ERR(27, 186, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + + /* "asyncpg/protocol/protocol.pyx":191 + * arg_bufs) + * + * self.last_query = state.query # <<<<<<<<<<<<<< + * self.statement = state + * self.return_extra = False + */ + __pyx_t_4 = __pyx_cur_scope->__pyx_v_state->query; + __Pyx_INCREF(__pyx_t_4); + __Pyx_GIVEREF(__pyx_t_4); + __Pyx_GOTREF(__pyx_cur_scope->__pyx_v_self->last_query); + __Pyx_DECREF(__pyx_cur_scope->__pyx_v_self->last_query); + __pyx_cur_scope->__pyx_v_self->last_query = ((PyObject*)__pyx_t_4); + __pyx_t_4 = 0; + + /* "asyncpg/protocol/protocol.pyx":192 + * + * self.last_query = state.query + * self.statement = state # <<<<<<<<<<<<<< + * self.return_extra = False + * self.queries_count += 1 + */ + __Pyx_INCREF(((PyObject *)__pyx_cur_scope->__pyx_v_state)); + __Pyx_GIVEREF(((PyObject *)__pyx_cur_scope->__pyx_v_state)); + __Pyx_GOTREF(__pyx_cur_scope->__pyx_v_self->statement); + __Pyx_DECREF(((PyObject *)__pyx_cur_scope->__pyx_v_self->statement)); + __pyx_cur_scope->__pyx_v_self->statement = __pyx_cur_scope->__pyx_v_state; + + /* "asyncpg/protocol/protocol.pyx":193 + * self.last_query = state.query + * self.statement = state + * self.return_extra = False # <<<<<<<<<<<<<< + * self.queries_count += 1 + * + */ + __pyx_cur_scope->__pyx_v_self->return_extra = 0; + + /* "asyncpg/protocol/protocol.pyx":194 + * self.statement = state + * self.return_extra = False + * self.queries_count += 1 # <<<<<<<<<<<<<< + * + * return await waiter + */ + __pyx_cur_scope->__pyx_v_self->queries_count = (__pyx_cur_scope->__pyx_v_self->queries_count + 1); + + /* "asyncpg/protocol/protocol.pyx":196 + * self.queries_count += 1 + * + * return await waiter # <<<<<<<<<<<<<< + * + * async def bind(self, PreparedStatementState state, args, + */ + __Pyx_XDECREF(__pyx_r); + __pyx_r = __Pyx_Coroutine_Yield_From(__pyx_generator, __pyx_cur_scope->__pyx_v_waiter); + __Pyx_XGOTREF(__pyx_r); + if (likely(__pyx_r)) { + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + /* return from generator, yielding value */ + __pyx_generator->resume_label = 3; + return __pyx_r; + __pyx_L8_resume_from_yield:; + if (unlikely(!__pyx_sent_value)) __PYX_ERR(27, 196, __pyx_L1_error) + __pyx_t_4 = __pyx_sent_value; __Pyx_INCREF(__pyx_t_4); + } else { + __pyx_t_4 = NULL; + if (__Pyx_PyGen_FetchStopIterationValue(&__pyx_t_4) < 0) __PYX_ERR(27, 196, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + } + __pyx_r = NULL; __Pyx_ReturnWithStopIteration(__pyx_t_4); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_4 = 0; + goto __pyx_L0; + CYTHON_MAYBE_UNUSED_VAR(__pyx_cur_scope); + + /* "asyncpg/protocol/protocol.pyx":167 + * return await self._new_waiter(timeout) + * + * async def bind_execute_many(self, PreparedStatementState state, args, # <<<<<<<<<<<<<< + * str portal_name, timeout): + * + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_AddTraceback("bind_execute_many", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_L0:; + __Pyx_XDECREF(__pyx_r); __pyx_r = 0; + __pyx_generator->resume_label = -1; + __Pyx_Coroutine_clear((PyObject*)__pyx_generator); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} +static PyObject *__pyx_gb_7asyncpg_8protocol_8protocol_12BaseProtocol_19generator3(__pyx_CoroutineObject *__pyx_generator, PyObject *__pyx_sent_value); /* proto */ + +/* "asyncpg/protocol/protocol.pyx":198 + * return await waiter + * + * async def bind(self, PreparedStatementState state, args, # <<<<<<<<<<<<<< + * str portal_name, timeout): + * + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_7asyncpg_8protocol_8protocol_12BaseProtocol_18bind(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ +static PyObject *__pyx_pw_7asyncpg_8protocol_8protocol_12BaseProtocol_18bind(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { + struct __pyx_obj_7asyncpg_8protocol_8protocol_PreparedStatementState *__pyx_v_state = 0; + PyObject *__pyx_v_args = 0; + PyObject *__pyx_v_portal_name = 0; + PyObject *__pyx_v_timeout = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("bind (wrapper)", 0); + { + static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_state,&__pyx_n_s_args,&__pyx_n_s_portal_name,&__pyx_n_s_timeout,0}; + PyObject* values[4] = {0,0,0,0}; + if (unlikely(__pyx_kwds)) { + Py_ssize_t kw_args; + const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args); + switch (pos_args) { + case 4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3); + case 3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2); + case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); + case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = PyDict_Size(__pyx_kwds); + switch (pos_args) { + case 0: + if (likely((values[0] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_state)) != 0)) kw_args--; + else goto __pyx_L5_argtuple_error; + case 1: + if (likely((values[1] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_args)) != 0)) kw_args--; + else { + __Pyx_RaiseArgtupleInvalid("bind", 1, 4, 4, 1); __PYX_ERR(27, 198, __pyx_L3_error) + } + case 2: + if (likely((values[2] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_portal_name)) != 0)) kw_args--; + else { + __Pyx_RaiseArgtupleInvalid("bind", 1, 4, 4, 2); __PYX_ERR(27, 198, __pyx_L3_error) + } + case 3: + if (likely((values[3] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_timeout)) != 0)) kw_args--; + else { + __Pyx_RaiseArgtupleInvalid("bind", 1, 4, 4, 3); __PYX_ERR(27, 198, __pyx_L3_error) + } + } + if (unlikely(kw_args > 0)) { + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "bind") < 0)) __PYX_ERR(27, 198, __pyx_L3_error) + } + } else if (PyTuple_GET_SIZE(__pyx_args) != 4) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + values[1] = PyTuple_GET_ITEM(__pyx_args, 1); + values[2] = PyTuple_GET_ITEM(__pyx_args, 2); + values[3] = PyTuple_GET_ITEM(__pyx_args, 3); + } + __pyx_v_state = ((struct __pyx_obj_7asyncpg_8protocol_8protocol_PreparedStatementState *)values[0]); + __pyx_v_args = values[1]; + __pyx_v_portal_name = ((PyObject*)values[2]); + __pyx_v_timeout = values[3]; + } + goto __pyx_L4_argument_unpacking_done; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("bind", 1, 4, 4, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(27, 198, __pyx_L3_error) + __pyx_L3_error:; + __Pyx_AddTraceback("asyncpg.protocol.protocol.BaseProtocol.bind", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_state), __pyx_ptype_7asyncpg_8protocol_8protocol_PreparedStatementState, 1, "state", 0))) __PYX_ERR(27, 198, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_portal_name), (&PyUnicode_Type), 1, "portal_name", 1))) __PYX_ERR(27, 199, __pyx_L1_error) + __pyx_r = __pyx_pf_7asyncpg_8protocol_8protocol_12BaseProtocol_17bind(((struct __pyx_obj_7asyncpg_8protocol_8protocol_BaseProtocol *)__pyx_v_self), __pyx_v_state, __pyx_v_args, __pyx_v_portal_name, __pyx_v_timeout); + + /* function exit code */ + goto __pyx_L0; + __pyx_L1_error:; + __pyx_r = NULL; + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_7asyncpg_8protocol_8protocol_12BaseProtocol_17bind(struct __pyx_obj_7asyncpg_8protocol_8protocol_BaseProtocol *__pyx_v_self, struct __pyx_obj_7asyncpg_8protocol_8protocol_PreparedStatementState *__pyx_v_state, PyObject *__pyx_v_args, PyObject *__pyx_v_portal_name, PyObject *__pyx_v_timeout) { + struct __pyx_obj_7asyncpg_8protocol_8protocol___pyx_scope_struct_4_bind *__pyx_cur_scope; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("bind", 0); + __pyx_cur_scope = (struct __pyx_obj_7asyncpg_8protocol_8protocol___pyx_scope_struct_4_bind *)__pyx_tp_new_7asyncpg_8protocol_8protocol___pyx_scope_struct_4_bind(__pyx_ptype_7asyncpg_8protocol_8protocol___pyx_scope_struct_4_bind, __pyx_empty_tuple, NULL); + if (unlikely(!__pyx_cur_scope)) { + __pyx_cur_scope = ((struct __pyx_obj_7asyncpg_8protocol_8protocol___pyx_scope_struct_4_bind *)Py_None); + __Pyx_INCREF(Py_None); + __PYX_ERR(27, 198, __pyx_L1_error) + } else { + __Pyx_GOTREF(__pyx_cur_scope); + } + __pyx_cur_scope->__pyx_v_self = __pyx_v_self; + __Pyx_INCREF((PyObject *)__pyx_cur_scope->__pyx_v_self); + __Pyx_GIVEREF((PyObject *)__pyx_cur_scope->__pyx_v_self); + __pyx_cur_scope->__pyx_v_state = __pyx_v_state; + __Pyx_INCREF((PyObject *)__pyx_cur_scope->__pyx_v_state); + __Pyx_GIVEREF((PyObject *)__pyx_cur_scope->__pyx_v_state); + __pyx_cur_scope->__pyx_v_args = __pyx_v_args; + __Pyx_INCREF(__pyx_cur_scope->__pyx_v_args); + __Pyx_GIVEREF(__pyx_cur_scope->__pyx_v_args); + __pyx_cur_scope->__pyx_v_portal_name = __pyx_v_portal_name; + __Pyx_INCREF(__pyx_cur_scope->__pyx_v_portal_name); + __Pyx_GIVEREF(__pyx_cur_scope->__pyx_v_portal_name); + __pyx_cur_scope->__pyx_v_timeout = __pyx_v_timeout; + __Pyx_INCREF(__pyx_cur_scope->__pyx_v_timeout); + __Pyx_GIVEREF(__pyx_cur_scope->__pyx_v_timeout); + { + __pyx_CoroutineObject *gen = __Pyx_Coroutine_New((__pyx_coroutine_body_t) __pyx_gb_7asyncpg_8protocol_8protocol_12BaseProtocol_19generator3, (PyObject *) __pyx_cur_scope, __pyx_n_s_bind, __pyx_n_s_BaseProtocol_bind, __pyx_n_s_asyncpg_protocol_protocol); if (unlikely(!gen)) __PYX_ERR(27, 198, __pyx_L1_error) + __Pyx_DECREF(__pyx_cur_scope); + __Pyx_RefNannyFinishContext(); + return (PyObject *) gen; + } + + /* function exit code */ + __pyx_L1_error:; + __Pyx_AddTraceback("asyncpg.protocol.protocol.BaseProtocol.bind", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __Pyx_DECREF(((PyObject *)__pyx_cur_scope)); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_gb_7asyncpg_8protocol_8protocol_12BaseProtocol_19generator3(__pyx_CoroutineObject *__pyx_generator, PyObject *__pyx_sent_value) /* generator body */ +{ + struct __pyx_obj_7asyncpg_8protocol_8protocol___pyx_scope_struct_4_bind *__pyx_cur_scope = ((struct __pyx_obj_7asyncpg_8protocol_8protocol___pyx_scope_struct_4_bind *)__pyx_generator->closure); + PyObject *__pyx_r = NULL; + int __pyx_t_1; + int __pyx_t_2; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + PyObject *__pyx_t_5 = NULL; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("None", 0); + switch (__pyx_generator->resume_label) { + case 0: goto __pyx_L3_first_run; + case 1: goto __pyx_L5_resume_from_yield; + case 2: goto __pyx_L7_resume_from_yield; + case 3: goto __pyx_L8_resume_from_yield; + default: /* CPython raises the right error here */ + __Pyx_RefNannyFinishContext(); + return NULL; + } + __pyx_L3_first_run:; + if (unlikely(!__pyx_sent_value)) __PYX_ERR(27, 198, __pyx_L1_error) + + /* "asyncpg/protocol/protocol.pyx":201 + * str portal_name, timeout): + * + * if self.cancel_waiter is not None: # <<<<<<<<<<<<<< + * await self.cancel_waiter + * if self.cancel_sent_waiter is not None: + */ + __pyx_t_1 = (__pyx_cur_scope->__pyx_v_self->cancel_waiter != Py_None); + __pyx_t_2 = (__pyx_t_1 != 0); + if (__pyx_t_2) { + + /* "asyncpg/protocol/protocol.pyx":202 + * + * if self.cancel_waiter is not None: + * await self.cancel_waiter # <<<<<<<<<<<<<< + * if self.cancel_sent_waiter is not None: + * await self.cancel_sent_waiter + */ + __pyx_r = __Pyx_Coroutine_Yield_From(__pyx_generator, __pyx_cur_scope->__pyx_v_self->cancel_waiter); + __Pyx_XGOTREF(__pyx_r); + if (likely(__pyx_r)) { + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + /* return from generator, yielding value */ + __pyx_generator->resume_label = 1; + return __pyx_r; + __pyx_L5_resume_from_yield:; + if (unlikely(!__pyx_sent_value)) __PYX_ERR(27, 202, __pyx_L1_error) + } else { + PyObject* exc_type = PyErr_Occurred(); + if (exc_type) { + if (likely(exc_type == PyExc_StopIteration || PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) PyErr_Clear(); + else __PYX_ERR(27, 202, __pyx_L1_error) + } + } + + /* "asyncpg/protocol/protocol.pyx":201 + * str portal_name, timeout): + * + * if self.cancel_waiter is not None: # <<<<<<<<<<<<<< + * await self.cancel_waiter + * if self.cancel_sent_waiter is not None: + */ + } + + /* "asyncpg/protocol/protocol.pyx":203 + * if self.cancel_waiter is not None: + * await self.cancel_waiter + * if self.cancel_sent_waiter is not None: # <<<<<<<<<<<<<< + * await self.cancel_sent_waiter + * self.cancel_sent_waiter = None + */ + __pyx_t_2 = (__pyx_cur_scope->__pyx_v_self->cancel_sent_waiter != Py_None); + __pyx_t_1 = (__pyx_t_2 != 0); + if (__pyx_t_1) { + + /* "asyncpg/protocol/protocol.pyx":204 + * await self.cancel_waiter + * if self.cancel_sent_waiter is not None: + * await self.cancel_sent_waiter # <<<<<<<<<<<<<< + * self.cancel_sent_waiter = None + * + */ + __pyx_r = __Pyx_Coroutine_Yield_From(__pyx_generator, __pyx_cur_scope->__pyx_v_self->cancel_sent_waiter); + __Pyx_XGOTREF(__pyx_r); + if (likely(__pyx_r)) { + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + /* return from generator, yielding value */ + __pyx_generator->resume_label = 2; + return __pyx_r; + __pyx_L7_resume_from_yield:; + if (unlikely(!__pyx_sent_value)) __PYX_ERR(27, 204, __pyx_L1_error) + } else { + PyObject* exc_type = PyErr_Occurred(); + if (exc_type) { + if (likely(exc_type == PyExc_StopIteration || PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) PyErr_Clear(); + else __PYX_ERR(27, 204, __pyx_L1_error) + } + } + + /* "asyncpg/protocol/protocol.pyx":205 + * if self.cancel_sent_waiter is not None: + * await self.cancel_sent_waiter + * self.cancel_sent_waiter = None # <<<<<<<<<<<<<< + * + * self._ensure_clear_state() + */ + __Pyx_INCREF(Py_None); + __Pyx_GIVEREF(Py_None); + __Pyx_GOTREF(__pyx_cur_scope->__pyx_v_self->cancel_sent_waiter); + __Pyx_DECREF(__pyx_cur_scope->__pyx_v_self->cancel_sent_waiter); + __pyx_cur_scope->__pyx_v_self->cancel_sent_waiter = Py_None; + + /* "asyncpg/protocol/protocol.pyx":203 + * if self.cancel_waiter is not None: + * await self.cancel_waiter + * if self.cancel_sent_waiter is not None: # <<<<<<<<<<<<<< + * await self.cancel_sent_waiter + * self.cancel_sent_waiter = None + */ + } + + /* "asyncpg/protocol/protocol.pyx":207 + * self.cancel_sent_waiter = None + * + * self._ensure_clear_state() # <<<<<<<<<<<<<< + * + * self._bind( + */ + __pyx_t_3 = ((struct __pyx_vtabstruct_7asyncpg_8protocol_8protocol_BaseProtocol *)__pyx_cur_scope->__pyx_v_self->__pyx_base.__pyx_vtab)->_ensure_clear_state(__pyx_cur_scope->__pyx_v_self); if (unlikely(!__pyx_t_3)) __PYX_ERR(27, 207, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + + /* "asyncpg/protocol/protocol.pyx":211 + * self._bind( + * portal_name, + * state.name, # <<<<<<<<<<<<<< + * state._encode_bind_msg(args)) + * + */ + __pyx_t_3 = __pyx_cur_scope->__pyx_v_state->name; + __Pyx_INCREF(__pyx_t_3); + + /* "asyncpg/protocol/protocol.pyx":212 + * portal_name, + * state.name, + * state._encode_bind_msg(args)) # <<<<<<<<<<<<<< + * + * self.last_query = state.query + */ + __pyx_t_4 = __pyx_f_7asyncpg_8protocol_8protocol_22PreparedStatementState__encode_bind_msg(__pyx_cur_scope->__pyx_v_state, __pyx_cur_scope->__pyx_v_args); if (unlikely(!__pyx_t_4)) __PYX_ERR(27, 212, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + if (!(likely(((__pyx_t_4) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_4, __pyx_ptype_7asyncpg_8protocol_8protocol_WriteBuffer))))) __PYX_ERR(27, 212, __pyx_L1_error) + + /* "asyncpg/protocol/protocol.pyx":209 + * self._ensure_clear_state() + * + * self._bind( # <<<<<<<<<<<<<< + * portal_name, + * state.name, + */ + __pyx_t_5 = ((struct __pyx_vtabstruct_7asyncpg_8protocol_8protocol_BaseProtocol *)__pyx_cur_scope->__pyx_v_self->__pyx_base.__pyx_vtab)->__pyx_base._bind(((struct __pyx_obj_7asyncpg_8protocol_8protocol_CoreProtocol *)__pyx_cur_scope->__pyx_v_self), __pyx_cur_scope->__pyx_v_portal_name, ((PyObject*)__pyx_t_3), ((struct __pyx_obj_7asyncpg_8protocol_8protocol_WriteBuffer *)__pyx_t_4)); if (unlikely(!__pyx_t_5)) __PYX_ERR(27, 209, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + + /* "asyncpg/protocol/protocol.pyx":214 + * state._encode_bind_msg(args)) + * + * self.last_query = state.query # <<<<<<<<<<<<<< + * self.statement = state + * + */ + __pyx_t_5 = __pyx_cur_scope->__pyx_v_state->query; + __Pyx_INCREF(__pyx_t_5); + __Pyx_GIVEREF(__pyx_t_5); + __Pyx_GOTREF(__pyx_cur_scope->__pyx_v_self->last_query); + __Pyx_DECREF(__pyx_cur_scope->__pyx_v_self->last_query); + __pyx_cur_scope->__pyx_v_self->last_query = ((PyObject*)__pyx_t_5); + __pyx_t_5 = 0; + + /* "asyncpg/protocol/protocol.pyx":215 + * + * self.last_query = state.query + * self.statement = state # <<<<<<<<<<<<<< + * + * return await self._new_waiter(timeout) + */ + __Pyx_INCREF(((PyObject *)__pyx_cur_scope->__pyx_v_state)); + __Pyx_GIVEREF(((PyObject *)__pyx_cur_scope->__pyx_v_state)); + __Pyx_GOTREF(__pyx_cur_scope->__pyx_v_self->statement); + __Pyx_DECREF(((PyObject *)__pyx_cur_scope->__pyx_v_self->statement)); + __pyx_cur_scope->__pyx_v_self->statement = __pyx_cur_scope->__pyx_v_state; + + /* "asyncpg/protocol/protocol.pyx":217 + * self.statement = state + * + * return await self._new_waiter(timeout) # <<<<<<<<<<<<<< + * + * async def execute(self, PreparedStatementState state, + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_5 = ((struct __pyx_vtabstruct_7asyncpg_8protocol_8protocol_BaseProtocol *)__pyx_cur_scope->__pyx_v_self->__pyx_base.__pyx_vtab)->_new_waiter(__pyx_cur_scope->__pyx_v_self, __pyx_cur_scope->__pyx_v_timeout); if (unlikely(!__pyx_t_5)) __PYX_ERR(27, 217, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_r = __Pyx_Coroutine_Yield_From(__pyx_generator, __pyx_t_5); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_XGOTREF(__pyx_r); + if (likely(__pyx_r)) { + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + /* return from generator, yielding value */ + __pyx_generator->resume_label = 3; + return __pyx_r; + __pyx_L8_resume_from_yield:; + if (unlikely(!__pyx_sent_value)) __PYX_ERR(27, 217, __pyx_L1_error) + __pyx_t_5 = __pyx_sent_value; __Pyx_INCREF(__pyx_t_5); + } else { + __pyx_t_5 = NULL; + if (__Pyx_PyGen_FetchStopIterationValue(&__pyx_t_5) < 0) __PYX_ERR(27, 217, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + } + __pyx_r = NULL; __Pyx_ReturnWithStopIteration(__pyx_t_5); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __pyx_t_5 = 0; + goto __pyx_L0; + CYTHON_MAYBE_UNUSED_VAR(__pyx_cur_scope); + + /* "asyncpg/protocol/protocol.pyx":198 + * return await waiter + * + * async def bind(self, PreparedStatementState state, args, # <<<<<<<<<<<<<< + * str portal_name, timeout): + * + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_AddTraceback("bind", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_L0:; + __Pyx_XDECREF(__pyx_r); __pyx_r = 0; + __pyx_generator->resume_label = -1; + __Pyx_Coroutine_clear((PyObject*)__pyx_generator); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} +static PyObject *__pyx_gb_7asyncpg_8protocol_8protocol_12BaseProtocol_22generator4(__pyx_CoroutineObject *__pyx_generator, PyObject *__pyx_sent_value); /* proto */ + +/* "asyncpg/protocol/protocol.pyx":219 + * return await self._new_waiter(timeout) + * + * async def execute(self, PreparedStatementState state, # <<<<<<<<<<<<<< + * str portal_name, int limit, return_extra, + * timeout): + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_7asyncpg_8protocol_8protocol_12BaseProtocol_21execute(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ +static PyObject *__pyx_pw_7asyncpg_8protocol_8protocol_12BaseProtocol_21execute(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { + struct __pyx_obj_7asyncpg_8protocol_8protocol_PreparedStatementState *__pyx_v_state = 0; + PyObject *__pyx_v_portal_name = 0; + int __pyx_v_limit; + PyObject *__pyx_v_return_extra = 0; + PyObject *__pyx_v_timeout = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("execute (wrapper)", 0); + { + static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_state,&__pyx_n_s_portal_name,&__pyx_n_s_limit,&__pyx_n_s_return_extra,&__pyx_n_s_timeout,0}; + PyObject* values[5] = {0,0,0,0,0}; + if (unlikely(__pyx_kwds)) { + Py_ssize_t kw_args; + const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args); + switch (pos_args) { + case 5: values[4] = PyTuple_GET_ITEM(__pyx_args, 4); + case 4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3); + case 3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2); + case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); + case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = PyDict_Size(__pyx_kwds); + switch (pos_args) { + case 0: + if (likely((values[0] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_state)) != 0)) kw_args--; + else goto __pyx_L5_argtuple_error; + case 1: + if (likely((values[1] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_portal_name)) != 0)) kw_args--; + else { + __Pyx_RaiseArgtupleInvalid("execute", 1, 5, 5, 1); __PYX_ERR(27, 219, __pyx_L3_error) + } + case 2: + if (likely((values[2] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_limit)) != 0)) kw_args--; + else { + __Pyx_RaiseArgtupleInvalid("execute", 1, 5, 5, 2); __PYX_ERR(27, 219, __pyx_L3_error) + } + case 3: + if (likely((values[3] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_return_extra)) != 0)) kw_args--; + else { + __Pyx_RaiseArgtupleInvalid("execute", 1, 5, 5, 3); __PYX_ERR(27, 219, __pyx_L3_error) + } + case 4: + if (likely((values[4] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_timeout)) != 0)) kw_args--; + else { + __Pyx_RaiseArgtupleInvalid("execute", 1, 5, 5, 4); __PYX_ERR(27, 219, __pyx_L3_error) + } + } + if (unlikely(kw_args > 0)) { + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "execute") < 0)) __PYX_ERR(27, 219, __pyx_L3_error) + } + } else if (PyTuple_GET_SIZE(__pyx_args) != 5) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + values[1] = PyTuple_GET_ITEM(__pyx_args, 1); + values[2] = PyTuple_GET_ITEM(__pyx_args, 2); + values[3] = PyTuple_GET_ITEM(__pyx_args, 3); + values[4] = PyTuple_GET_ITEM(__pyx_args, 4); + } + __pyx_v_state = ((struct __pyx_obj_7asyncpg_8protocol_8protocol_PreparedStatementState *)values[0]); + __pyx_v_portal_name = ((PyObject*)values[1]); + __pyx_v_limit = __Pyx_PyInt_As_int(values[2]); if (unlikely((__pyx_v_limit == (int)-1) && PyErr_Occurred())) __PYX_ERR(27, 220, __pyx_L3_error) + __pyx_v_return_extra = values[3]; + __pyx_v_timeout = values[4]; + } + goto __pyx_L4_argument_unpacking_done; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("execute", 1, 5, 5, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(27, 219, __pyx_L3_error) + __pyx_L3_error:; + __Pyx_AddTraceback("asyncpg.protocol.protocol.BaseProtocol.execute", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_state), __pyx_ptype_7asyncpg_8protocol_8protocol_PreparedStatementState, 1, "state", 0))) __PYX_ERR(27, 219, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_portal_name), (&PyUnicode_Type), 1, "portal_name", 1))) __PYX_ERR(27, 220, __pyx_L1_error) + __pyx_r = __pyx_pf_7asyncpg_8protocol_8protocol_12BaseProtocol_20execute(((struct __pyx_obj_7asyncpg_8protocol_8protocol_BaseProtocol *)__pyx_v_self), __pyx_v_state, __pyx_v_portal_name, __pyx_v_limit, __pyx_v_return_extra, __pyx_v_timeout); + + /* function exit code */ + goto __pyx_L0; + __pyx_L1_error:; + __pyx_r = NULL; + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_7asyncpg_8protocol_8protocol_12BaseProtocol_20execute(struct __pyx_obj_7asyncpg_8protocol_8protocol_BaseProtocol *__pyx_v_self, struct __pyx_obj_7asyncpg_8protocol_8protocol_PreparedStatementState *__pyx_v_state, PyObject *__pyx_v_portal_name, int __pyx_v_limit, PyObject *__pyx_v_return_extra, PyObject *__pyx_v_timeout) { + struct __pyx_obj_7asyncpg_8protocol_8protocol___pyx_scope_struct_5_execute *__pyx_cur_scope; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("execute", 0); + __pyx_cur_scope = (struct __pyx_obj_7asyncpg_8protocol_8protocol___pyx_scope_struct_5_execute *)__pyx_tp_new_7asyncpg_8protocol_8protocol___pyx_scope_struct_5_execute(__pyx_ptype_7asyncpg_8protocol_8protocol___pyx_scope_struct_5_execute, __pyx_empty_tuple, NULL); + if (unlikely(!__pyx_cur_scope)) { + __pyx_cur_scope = ((struct __pyx_obj_7asyncpg_8protocol_8protocol___pyx_scope_struct_5_execute *)Py_None); + __Pyx_INCREF(Py_None); + __PYX_ERR(27, 219, __pyx_L1_error) + } else { + __Pyx_GOTREF(__pyx_cur_scope); + } + __pyx_cur_scope->__pyx_v_self = __pyx_v_self; + __Pyx_INCREF((PyObject *)__pyx_cur_scope->__pyx_v_self); + __Pyx_GIVEREF((PyObject *)__pyx_cur_scope->__pyx_v_self); + __pyx_cur_scope->__pyx_v_state = __pyx_v_state; + __Pyx_INCREF((PyObject *)__pyx_cur_scope->__pyx_v_state); + __Pyx_GIVEREF((PyObject *)__pyx_cur_scope->__pyx_v_state); + __pyx_cur_scope->__pyx_v_portal_name = __pyx_v_portal_name; + __Pyx_INCREF(__pyx_cur_scope->__pyx_v_portal_name); + __Pyx_GIVEREF(__pyx_cur_scope->__pyx_v_portal_name); + __pyx_cur_scope->__pyx_v_limit = __pyx_v_limit; + __pyx_cur_scope->__pyx_v_return_extra = __pyx_v_return_extra; + __Pyx_INCREF(__pyx_cur_scope->__pyx_v_return_extra); + __Pyx_GIVEREF(__pyx_cur_scope->__pyx_v_return_extra); + __pyx_cur_scope->__pyx_v_timeout = __pyx_v_timeout; + __Pyx_INCREF(__pyx_cur_scope->__pyx_v_timeout); + __Pyx_GIVEREF(__pyx_cur_scope->__pyx_v_timeout); + { + __pyx_CoroutineObject *gen = __Pyx_Coroutine_New((__pyx_coroutine_body_t) __pyx_gb_7asyncpg_8protocol_8protocol_12BaseProtocol_22generator4, (PyObject *) __pyx_cur_scope, __pyx_n_s_execute, __pyx_n_s_BaseProtocol_execute, __pyx_n_s_asyncpg_protocol_protocol); if (unlikely(!gen)) __PYX_ERR(27, 219, __pyx_L1_error) + __Pyx_DECREF(__pyx_cur_scope); + __Pyx_RefNannyFinishContext(); + return (PyObject *) gen; + } + + /* function exit code */ + __pyx_L1_error:; + __Pyx_AddTraceback("asyncpg.protocol.protocol.BaseProtocol.execute", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __Pyx_DECREF(((PyObject *)__pyx_cur_scope)); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_gb_7asyncpg_8protocol_8protocol_12BaseProtocol_22generator4(__pyx_CoroutineObject *__pyx_generator, PyObject *__pyx_sent_value) /* generator body */ +{ + struct __pyx_obj_7asyncpg_8protocol_8protocol___pyx_scope_struct_5_execute *__pyx_cur_scope = ((struct __pyx_obj_7asyncpg_8protocol_8protocol___pyx_scope_struct_5_execute *)__pyx_generator->closure); + PyObject *__pyx_r = NULL; + int __pyx_t_1; + int __pyx_t_2; + PyObject *__pyx_t_3 = NULL; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("None", 0); + switch (__pyx_generator->resume_label) { + case 0: goto __pyx_L3_first_run; + case 1: goto __pyx_L5_resume_from_yield; + case 2: goto __pyx_L7_resume_from_yield; + case 3: goto __pyx_L8_resume_from_yield; + default: /* CPython raises the right error here */ + __Pyx_RefNannyFinishContext(); + return NULL; + } + __pyx_L3_first_run:; + if (unlikely(!__pyx_sent_value)) __PYX_ERR(27, 219, __pyx_L1_error) + + /* "asyncpg/protocol/protocol.pyx":223 + * timeout): + * + * if self.cancel_waiter is not None: # <<<<<<<<<<<<<< + * await self.cancel_waiter + * if self.cancel_sent_waiter is not None: + */ + __pyx_t_1 = (__pyx_cur_scope->__pyx_v_self->cancel_waiter != Py_None); + __pyx_t_2 = (__pyx_t_1 != 0); + if (__pyx_t_2) { + + /* "asyncpg/protocol/protocol.pyx":224 + * + * if self.cancel_waiter is not None: + * await self.cancel_waiter # <<<<<<<<<<<<<< + * if self.cancel_sent_waiter is not None: + * await self.cancel_sent_waiter + */ + __pyx_r = __Pyx_Coroutine_Yield_From(__pyx_generator, __pyx_cur_scope->__pyx_v_self->cancel_waiter); + __Pyx_XGOTREF(__pyx_r); + if (likely(__pyx_r)) { + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + /* return from generator, yielding value */ + __pyx_generator->resume_label = 1; + return __pyx_r; + __pyx_L5_resume_from_yield:; + if (unlikely(!__pyx_sent_value)) __PYX_ERR(27, 224, __pyx_L1_error) + } else { + PyObject* exc_type = PyErr_Occurred(); + if (exc_type) { + if (likely(exc_type == PyExc_StopIteration || PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) PyErr_Clear(); + else __PYX_ERR(27, 224, __pyx_L1_error) + } + } + + /* "asyncpg/protocol/protocol.pyx":223 + * timeout): + * + * if self.cancel_waiter is not None: # <<<<<<<<<<<<<< + * await self.cancel_waiter + * if self.cancel_sent_waiter is not None: + */ + } + + /* "asyncpg/protocol/protocol.pyx":225 + * if self.cancel_waiter is not None: + * await self.cancel_waiter + * if self.cancel_sent_waiter is not None: # <<<<<<<<<<<<<< + * await self.cancel_sent_waiter + * self.cancel_sent_waiter = None + */ + __pyx_t_2 = (__pyx_cur_scope->__pyx_v_self->cancel_sent_waiter != Py_None); + __pyx_t_1 = (__pyx_t_2 != 0); + if (__pyx_t_1) { + + /* "asyncpg/protocol/protocol.pyx":226 + * await self.cancel_waiter + * if self.cancel_sent_waiter is not None: + * await self.cancel_sent_waiter # <<<<<<<<<<<<<< + * self.cancel_sent_waiter = None + * + */ + __pyx_r = __Pyx_Coroutine_Yield_From(__pyx_generator, __pyx_cur_scope->__pyx_v_self->cancel_sent_waiter); + __Pyx_XGOTREF(__pyx_r); + if (likely(__pyx_r)) { + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + /* return from generator, yielding value */ + __pyx_generator->resume_label = 2; + return __pyx_r; + __pyx_L7_resume_from_yield:; + if (unlikely(!__pyx_sent_value)) __PYX_ERR(27, 226, __pyx_L1_error) + } else { + PyObject* exc_type = PyErr_Occurred(); + if (exc_type) { + if (likely(exc_type == PyExc_StopIteration || PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) PyErr_Clear(); + else __PYX_ERR(27, 226, __pyx_L1_error) + } + } + + /* "asyncpg/protocol/protocol.pyx":227 + * if self.cancel_sent_waiter is not None: + * await self.cancel_sent_waiter + * self.cancel_sent_waiter = None # <<<<<<<<<<<<<< + * + * self._ensure_clear_state() + */ + __Pyx_INCREF(Py_None); + __Pyx_GIVEREF(Py_None); + __Pyx_GOTREF(__pyx_cur_scope->__pyx_v_self->cancel_sent_waiter); + __Pyx_DECREF(__pyx_cur_scope->__pyx_v_self->cancel_sent_waiter); + __pyx_cur_scope->__pyx_v_self->cancel_sent_waiter = Py_None; + + /* "asyncpg/protocol/protocol.pyx":225 + * if self.cancel_waiter is not None: + * await self.cancel_waiter + * if self.cancel_sent_waiter is not None: # <<<<<<<<<<<<<< + * await self.cancel_sent_waiter + * self.cancel_sent_waiter = None + */ + } + + /* "asyncpg/protocol/protocol.pyx":229 + * self.cancel_sent_waiter = None + * + * self._ensure_clear_state() # <<<<<<<<<<<<<< + * + * self._execute( + */ + __pyx_t_3 = ((struct __pyx_vtabstruct_7asyncpg_8protocol_8protocol_BaseProtocol *)__pyx_cur_scope->__pyx_v_self->__pyx_base.__pyx_vtab)->_ensure_clear_state(__pyx_cur_scope->__pyx_v_self); if (unlikely(!__pyx_t_3)) __PYX_ERR(27, 229, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + + /* "asyncpg/protocol/protocol.pyx":231 + * self._ensure_clear_state() + * + * self._execute( # <<<<<<<<<<<<<< + * portal_name, + * limit) + */ + __pyx_t_3 = ((struct __pyx_vtabstruct_7asyncpg_8protocol_8protocol_BaseProtocol *)__pyx_cur_scope->__pyx_v_self->__pyx_base.__pyx_vtab)->__pyx_base._execute(((struct __pyx_obj_7asyncpg_8protocol_8protocol_CoreProtocol *)__pyx_cur_scope->__pyx_v_self), __pyx_cur_scope->__pyx_v_portal_name, __pyx_cur_scope->__pyx_v_limit); if (unlikely(!__pyx_t_3)) __PYX_ERR(27, 231, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + + /* "asyncpg/protocol/protocol.pyx":235 + * limit) + * + * self.last_query = state.query # <<<<<<<<<<<<<< + * self.statement = state + * self.return_extra = return_extra + */ + __pyx_t_3 = __pyx_cur_scope->__pyx_v_state->query; + __Pyx_INCREF(__pyx_t_3); + __Pyx_GIVEREF(__pyx_t_3); + __Pyx_GOTREF(__pyx_cur_scope->__pyx_v_self->last_query); + __Pyx_DECREF(__pyx_cur_scope->__pyx_v_self->last_query); + __pyx_cur_scope->__pyx_v_self->last_query = ((PyObject*)__pyx_t_3); + __pyx_t_3 = 0; + + /* "asyncpg/protocol/protocol.pyx":236 + * + * self.last_query = state.query + * self.statement = state # <<<<<<<<<<<<<< + * self.return_extra = return_extra + * self.queries_count += 1 + */ + __Pyx_INCREF(((PyObject *)__pyx_cur_scope->__pyx_v_state)); + __Pyx_GIVEREF(((PyObject *)__pyx_cur_scope->__pyx_v_state)); + __Pyx_GOTREF(__pyx_cur_scope->__pyx_v_self->statement); + __Pyx_DECREF(((PyObject *)__pyx_cur_scope->__pyx_v_self->statement)); + __pyx_cur_scope->__pyx_v_self->statement = __pyx_cur_scope->__pyx_v_state; + + /* "asyncpg/protocol/protocol.pyx":237 + * self.last_query = state.query + * self.statement = state + * self.return_extra = return_extra # <<<<<<<<<<<<<< + * self.queries_count += 1 + * + */ + __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_cur_scope->__pyx_v_return_extra); if (unlikely((__pyx_t_1 == (int)-1) && PyErr_Occurred())) __PYX_ERR(27, 237, __pyx_L1_error) + __pyx_cur_scope->__pyx_v_self->return_extra = __pyx_t_1; + + /* "asyncpg/protocol/protocol.pyx":238 + * self.statement = state + * self.return_extra = return_extra + * self.queries_count += 1 # <<<<<<<<<<<<<< + * + * return await self._new_waiter(timeout) + */ + __pyx_cur_scope->__pyx_v_self->queries_count = (__pyx_cur_scope->__pyx_v_self->queries_count + 1); + + /* "asyncpg/protocol/protocol.pyx":240 + * self.queries_count += 1 + * + * return await self._new_waiter(timeout) # <<<<<<<<<<<<<< + * + * async def query(self, query, timeout): + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_3 = ((struct __pyx_vtabstruct_7asyncpg_8protocol_8protocol_BaseProtocol *)__pyx_cur_scope->__pyx_v_self->__pyx_base.__pyx_vtab)->_new_waiter(__pyx_cur_scope->__pyx_v_self, __pyx_cur_scope->__pyx_v_timeout); if (unlikely(!__pyx_t_3)) __PYX_ERR(27, 240, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_r = __Pyx_Coroutine_Yield_From(__pyx_generator, __pyx_t_3); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_XGOTREF(__pyx_r); + if (likely(__pyx_r)) { + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + /* return from generator, yielding value */ + __pyx_generator->resume_label = 3; + return __pyx_r; + __pyx_L8_resume_from_yield:; + if (unlikely(!__pyx_sent_value)) __PYX_ERR(27, 240, __pyx_L1_error) + __pyx_t_3 = __pyx_sent_value; __Pyx_INCREF(__pyx_t_3); + } else { + __pyx_t_3 = NULL; + if (__Pyx_PyGen_FetchStopIterationValue(&__pyx_t_3) < 0) __PYX_ERR(27, 240, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + } + __pyx_r = NULL; __Pyx_ReturnWithStopIteration(__pyx_t_3); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_3 = 0; + goto __pyx_L0; + CYTHON_MAYBE_UNUSED_VAR(__pyx_cur_scope); + + /* "asyncpg/protocol/protocol.pyx":219 + * return await self._new_waiter(timeout) + * + * async def execute(self, PreparedStatementState state, # <<<<<<<<<<<<<< + * str portal_name, int limit, return_extra, + * timeout): + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_3); + __Pyx_AddTraceback("execute", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_L0:; + __Pyx_XDECREF(__pyx_r); __pyx_r = 0; + __pyx_generator->resume_label = -1; + __Pyx_Coroutine_clear((PyObject*)__pyx_generator); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} +static PyObject *__pyx_gb_7asyncpg_8protocol_8protocol_12BaseProtocol_25generator5(__pyx_CoroutineObject *__pyx_generator, PyObject *__pyx_sent_value); /* proto */ + +/* "asyncpg/protocol/protocol.pyx":242 + * return await self._new_waiter(timeout) + * + * async def query(self, query, timeout): # <<<<<<<<<<<<<< + * if self.cancel_waiter is not None: + * await self.cancel_waiter + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_7asyncpg_8protocol_8protocol_12BaseProtocol_24query(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ +static PyObject *__pyx_pw_7asyncpg_8protocol_8protocol_12BaseProtocol_24query(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { + PyObject *__pyx_v_query = 0; + PyObject *__pyx_v_timeout = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("query (wrapper)", 0); + { + static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_query,&__pyx_n_s_timeout,0}; + PyObject* values[2] = {0,0}; + if (unlikely(__pyx_kwds)) { + Py_ssize_t kw_args; + const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args); + switch (pos_args) { + case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); + case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = PyDict_Size(__pyx_kwds); + switch (pos_args) { + case 0: + if (likely((values[0] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_query)) != 0)) kw_args--; + else goto __pyx_L5_argtuple_error; + case 1: + if (likely((values[1] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_timeout)) != 0)) kw_args--; + else { + __Pyx_RaiseArgtupleInvalid("query", 1, 2, 2, 1); __PYX_ERR(27, 242, __pyx_L3_error) + } + } + if (unlikely(kw_args > 0)) { + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "query") < 0)) __PYX_ERR(27, 242, __pyx_L3_error) + } + } else if (PyTuple_GET_SIZE(__pyx_args) != 2) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + values[1] = PyTuple_GET_ITEM(__pyx_args, 1); + } + __pyx_v_query = values[0]; + __pyx_v_timeout = values[1]; + } + goto __pyx_L4_argument_unpacking_done; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("query", 1, 2, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(27, 242, __pyx_L3_error) + __pyx_L3_error:; + __Pyx_AddTraceback("asyncpg.protocol.protocol.BaseProtocol.query", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_7asyncpg_8protocol_8protocol_12BaseProtocol_23query(((struct __pyx_obj_7asyncpg_8protocol_8protocol_BaseProtocol *)__pyx_v_self), __pyx_v_query, __pyx_v_timeout); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_7asyncpg_8protocol_8protocol_12BaseProtocol_23query(struct __pyx_obj_7asyncpg_8protocol_8protocol_BaseProtocol *__pyx_v_self, PyObject *__pyx_v_query, PyObject *__pyx_v_timeout) { + struct __pyx_obj_7asyncpg_8protocol_8protocol___pyx_scope_struct_6_query *__pyx_cur_scope; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("query", 0); + __pyx_cur_scope = (struct __pyx_obj_7asyncpg_8protocol_8protocol___pyx_scope_struct_6_query *)__pyx_tp_new_7asyncpg_8protocol_8protocol___pyx_scope_struct_6_query(__pyx_ptype_7asyncpg_8protocol_8protocol___pyx_scope_struct_6_query, __pyx_empty_tuple, NULL); + if (unlikely(!__pyx_cur_scope)) { + __pyx_cur_scope = ((struct __pyx_obj_7asyncpg_8protocol_8protocol___pyx_scope_struct_6_query *)Py_None); + __Pyx_INCREF(Py_None); + __PYX_ERR(27, 242, __pyx_L1_error) + } else { + __Pyx_GOTREF(__pyx_cur_scope); + } + __pyx_cur_scope->__pyx_v_self = __pyx_v_self; + __Pyx_INCREF((PyObject *)__pyx_cur_scope->__pyx_v_self); + __Pyx_GIVEREF((PyObject *)__pyx_cur_scope->__pyx_v_self); + __pyx_cur_scope->__pyx_v_query = __pyx_v_query; + __Pyx_INCREF(__pyx_cur_scope->__pyx_v_query); + __Pyx_GIVEREF(__pyx_cur_scope->__pyx_v_query); + __pyx_cur_scope->__pyx_v_timeout = __pyx_v_timeout; + __Pyx_INCREF(__pyx_cur_scope->__pyx_v_timeout); + __Pyx_GIVEREF(__pyx_cur_scope->__pyx_v_timeout); + { + __pyx_CoroutineObject *gen = __Pyx_Coroutine_New((__pyx_coroutine_body_t) __pyx_gb_7asyncpg_8protocol_8protocol_12BaseProtocol_25generator5, (PyObject *) __pyx_cur_scope, __pyx_n_s_query, __pyx_n_s_BaseProtocol_query, __pyx_n_s_asyncpg_protocol_protocol); if (unlikely(!gen)) __PYX_ERR(27, 242, __pyx_L1_error) + __Pyx_DECREF(__pyx_cur_scope); + __Pyx_RefNannyFinishContext(); + return (PyObject *) gen; + } + + /* function exit code */ + __pyx_L1_error:; + __Pyx_AddTraceback("asyncpg.protocol.protocol.BaseProtocol.query", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __Pyx_DECREF(((PyObject *)__pyx_cur_scope)); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_gb_7asyncpg_8protocol_8protocol_12BaseProtocol_25generator5(__pyx_CoroutineObject *__pyx_generator, PyObject *__pyx_sent_value) /* generator body */ +{ + struct __pyx_obj_7asyncpg_8protocol_8protocol___pyx_scope_struct_6_query *__pyx_cur_scope = ((struct __pyx_obj_7asyncpg_8protocol_8protocol___pyx_scope_struct_6_query *)__pyx_generator->closure); + PyObject *__pyx_r = NULL; + int __pyx_t_1; + int __pyx_t_2; + PyObject *__pyx_t_3 = NULL; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("None", 0); + switch (__pyx_generator->resume_label) { + case 0: goto __pyx_L3_first_run; + case 1: goto __pyx_L5_resume_from_yield; + case 2: goto __pyx_L7_resume_from_yield; + case 3: goto __pyx_L8_resume_from_yield; + default: /* CPython raises the right error here */ + __Pyx_RefNannyFinishContext(); + return NULL; + } + __pyx_L3_first_run:; + if (unlikely(!__pyx_sent_value)) __PYX_ERR(27, 242, __pyx_L1_error) + + /* "asyncpg/protocol/protocol.pyx":243 + * + * async def query(self, query, timeout): + * if self.cancel_waiter is not None: # <<<<<<<<<<<<<< + * await self.cancel_waiter + * if self.cancel_sent_waiter is not None: + */ + __pyx_t_1 = (__pyx_cur_scope->__pyx_v_self->cancel_waiter != Py_None); + __pyx_t_2 = (__pyx_t_1 != 0); + if (__pyx_t_2) { + + /* "asyncpg/protocol/protocol.pyx":244 + * async def query(self, query, timeout): + * if self.cancel_waiter is not None: + * await self.cancel_waiter # <<<<<<<<<<<<<< + * if self.cancel_sent_waiter is not None: + * await self.cancel_sent_waiter + */ + __pyx_r = __Pyx_Coroutine_Yield_From(__pyx_generator, __pyx_cur_scope->__pyx_v_self->cancel_waiter); + __Pyx_XGOTREF(__pyx_r); + if (likely(__pyx_r)) { + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + /* return from generator, yielding value */ + __pyx_generator->resume_label = 1; + return __pyx_r; + __pyx_L5_resume_from_yield:; + if (unlikely(!__pyx_sent_value)) __PYX_ERR(27, 244, __pyx_L1_error) + } else { + PyObject* exc_type = PyErr_Occurred(); + if (exc_type) { + if (likely(exc_type == PyExc_StopIteration || PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) PyErr_Clear(); + else __PYX_ERR(27, 244, __pyx_L1_error) + } + } + + /* "asyncpg/protocol/protocol.pyx":243 + * + * async def query(self, query, timeout): + * if self.cancel_waiter is not None: # <<<<<<<<<<<<<< + * await self.cancel_waiter + * if self.cancel_sent_waiter is not None: + */ + } + + /* "asyncpg/protocol/protocol.pyx":245 + * if self.cancel_waiter is not None: + * await self.cancel_waiter + * if self.cancel_sent_waiter is not None: # <<<<<<<<<<<<<< + * await self.cancel_sent_waiter + * self.cancel_sent_waiter = None + */ + __pyx_t_2 = (__pyx_cur_scope->__pyx_v_self->cancel_sent_waiter != Py_None); + __pyx_t_1 = (__pyx_t_2 != 0); + if (__pyx_t_1) { + + /* "asyncpg/protocol/protocol.pyx":246 + * await self.cancel_waiter + * if self.cancel_sent_waiter is not None: + * await self.cancel_sent_waiter # <<<<<<<<<<<<<< + * self.cancel_sent_waiter = None + * + */ + __pyx_r = __Pyx_Coroutine_Yield_From(__pyx_generator, __pyx_cur_scope->__pyx_v_self->cancel_sent_waiter); + __Pyx_XGOTREF(__pyx_r); + if (likely(__pyx_r)) { + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + /* return from generator, yielding value */ + __pyx_generator->resume_label = 2; + return __pyx_r; + __pyx_L7_resume_from_yield:; + if (unlikely(!__pyx_sent_value)) __PYX_ERR(27, 246, __pyx_L1_error) + } else { + PyObject* exc_type = PyErr_Occurred(); + if (exc_type) { + if (likely(exc_type == PyExc_StopIteration || PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) PyErr_Clear(); + else __PYX_ERR(27, 246, __pyx_L1_error) + } + } + + /* "asyncpg/protocol/protocol.pyx":247 + * if self.cancel_sent_waiter is not None: + * await self.cancel_sent_waiter + * self.cancel_sent_waiter = None # <<<<<<<<<<<<<< + * + * self._ensure_clear_state() + */ + __Pyx_INCREF(Py_None); + __Pyx_GIVEREF(Py_None); + __Pyx_GOTREF(__pyx_cur_scope->__pyx_v_self->cancel_sent_waiter); + __Pyx_DECREF(__pyx_cur_scope->__pyx_v_self->cancel_sent_waiter); + __pyx_cur_scope->__pyx_v_self->cancel_sent_waiter = Py_None; + + /* "asyncpg/protocol/protocol.pyx":245 + * if self.cancel_waiter is not None: + * await self.cancel_waiter + * if self.cancel_sent_waiter is not None: # <<<<<<<<<<<<<< + * await self.cancel_sent_waiter + * self.cancel_sent_waiter = None + */ + } + + /* "asyncpg/protocol/protocol.pyx":249 + * self.cancel_sent_waiter = None + * + * self._ensure_clear_state() # <<<<<<<<<<<<<< + * + * self._simple_query(query) + */ + __pyx_t_3 = ((struct __pyx_vtabstruct_7asyncpg_8protocol_8protocol_BaseProtocol *)__pyx_cur_scope->__pyx_v_self->__pyx_base.__pyx_vtab)->_ensure_clear_state(__pyx_cur_scope->__pyx_v_self); if (unlikely(!__pyx_t_3)) __PYX_ERR(27, 249, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + + /* "asyncpg/protocol/protocol.pyx":251 + * self._ensure_clear_state() + * + * self._simple_query(query) # <<<<<<<<<<<<<< + * self.last_query = query + * self.queries_count += 1 + */ + if (!(likely(PyUnicode_CheckExact(__pyx_cur_scope->__pyx_v_query))||((__pyx_cur_scope->__pyx_v_query) == Py_None)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "unicode", Py_TYPE(__pyx_cur_scope->__pyx_v_query)->tp_name), 0))) __PYX_ERR(27, 251, __pyx_L1_error) + __pyx_t_3 = ((struct __pyx_vtabstruct_7asyncpg_8protocol_8protocol_BaseProtocol *)__pyx_cur_scope->__pyx_v_self->__pyx_base.__pyx_vtab)->__pyx_base._simple_query(((struct __pyx_obj_7asyncpg_8protocol_8protocol_CoreProtocol *)__pyx_cur_scope->__pyx_v_self), ((PyObject*)__pyx_cur_scope->__pyx_v_query)); if (unlikely(!__pyx_t_3)) __PYX_ERR(27, 251, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + + /* "asyncpg/protocol/protocol.pyx":252 + * + * self._simple_query(query) + * self.last_query = query # <<<<<<<<<<<<<< + * self.queries_count += 1 + * + */ + if (!(likely(PyUnicode_CheckExact(__pyx_cur_scope->__pyx_v_query))||((__pyx_cur_scope->__pyx_v_query) == Py_None)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "unicode", Py_TYPE(__pyx_cur_scope->__pyx_v_query)->tp_name), 0))) __PYX_ERR(27, 252, __pyx_L1_error) + __pyx_t_3 = __pyx_cur_scope->__pyx_v_query; + __Pyx_INCREF(__pyx_t_3); + __Pyx_GIVEREF(__pyx_t_3); + __Pyx_GOTREF(__pyx_cur_scope->__pyx_v_self->last_query); + __Pyx_DECREF(__pyx_cur_scope->__pyx_v_self->last_query); + __pyx_cur_scope->__pyx_v_self->last_query = ((PyObject*)__pyx_t_3); + __pyx_t_3 = 0; + + /* "asyncpg/protocol/protocol.pyx":253 + * self._simple_query(query) + * self.last_query = query + * self.queries_count += 1 # <<<<<<<<<<<<<< + * + * return await self._new_waiter(timeout) + */ + __pyx_cur_scope->__pyx_v_self->queries_count = (__pyx_cur_scope->__pyx_v_self->queries_count + 1); + + /* "asyncpg/protocol/protocol.pyx":255 + * self.queries_count += 1 + * + * return await self._new_waiter(timeout) # <<<<<<<<<<<<<< + * + * async def close_statement(self, PreparedStatementState state, timeout): + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_3 = ((struct __pyx_vtabstruct_7asyncpg_8protocol_8protocol_BaseProtocol *)__pyx_cur_scope->__pyx_v_self->__pyx_base.__pyx_vtab)->_new_waiter(__pyx_cur_scope->__pyx_v_self, __pyx_cur_scope->__pyx_v_timeout); if (unlikely(!__pyx_t_3)) __PYX_ERR(27, 255, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_r = __Pyx_Coroutine_Yield_From(__pyx_generator, __pyx_t_3); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_XGOTREF(__pyx_r); + if (likely(__pyx_r)) { + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + /* return from generator, yielding value */ + __pyx_generator->resume_label = 3; + return __pyx_r; + __pyx_L8_resume_from_yield:; + if (unlikely(!__pyx_sent_value)) __PYX_ERR(27, 255, __pyx_L1_error) + __pyx_t_3 = __pyx_sent_value; __Pyx_INCREF(__pyx_t_3); + } else { + __pyx_t_3 = NULL; + if (__Pyx_PyGen_FetchStopIterationValue(&__pyx_t_3) < 0) __PYX_ERR(27, 255, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + } + __pyx_r = NULL; __Pyx_ReturnWithStopIteration(__pyx_t_3); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_3 = 0; + goto __pyx_L0; + CYTHON_MAYBE_UNUSED_VAR(__pyx_cur_scope); + + /* "asyncpg/protocol/protocol.pyx":242 + * return await self._new_waiter(timeout) + * + * async def query(self, query, timeout): # <<<<<<<<<<<<<< + * if self.cancel_waiter is not None: + * await self.cancel_waiter + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_3); + __Pyx_AddTraceback("query", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_L0:; + __Pyx_XDECREF(__pyx_r); __pyx_r = 0; + __pyx_generator->resume_label = -1; + __Pyx_Coroutine_clear((PyObject*)__pyx_generator); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} +static PyObject *__pyx_gb_7asyncpg_8protocol_8protocol_12BaseProtocol_28generator6(__pyx_CoroutineObject *__pyx_generator, PyObject *__pyx_sent_value); /* proto */ + +/* "asyncpg/protocol/protocol.pyx":257 + * return await self._new_waiter(timeout) + * + * async def close_statement(self, PreparedStatementState state, timeout): # <<<<<<<<<<<<<< + * if self.cancel_waiter is not None: + * await self.cancel_waiter + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_7asyncpg_8protocol_8protocol_12BaseProtocol_27close_statement(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ +static PyObject *__pyx_pw_7asyncpg_8protocol_8protocol_12BaseProtocol_27close_statement(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { + struct __pyx_obj_7asyncpg_8protocol_8protocol_PreparedStatementState *__pyx_v_state = 0; + PyObject *__pyx_v_timeout = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("close_statement (wrapper)", 0); + { + static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_state,&__pyx_n_s_timeout,0}; + PyObject* values[2] = {0,0}; + if (unlikely(__pyx_kwds)) { + Py_ssize_t kw_args; + const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args); + switch (pos_args) { + case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); + case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = PyDict_Size(__pyx_kwds); + switch (pos_args) { + case 0: + if (likely((values[0] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_state)) != 0)) kw_args--; + else goto __pyx_L5_argtuple_error; + case 1: + if (likely((values[1] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_timeout)) != 0)) kw_args--; + else { + __Pyx_RaiseArgtupleInvalid("close_statement", 1, 2, 2, 1); __PYX_ERR(27, 257, __pyx_L3_error) + } + } + if (unlikely(kw_args > 0)) { + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "close_statement") < 0)) __PYX_ERR(27, 257, __pyx_L3_error) + } + } else if (PyTuple_GET_SIZE(__pyx_args) != 2) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + values[1] = PyTuple_GET_ITEM(__pyx_args, 1); + } + __pyx_v_state = ((struct __pyx_obj_7asyncpg_8protocol_8protocol_PreparedStatementState *)values[0]); + __pyx_v_timeout = values[1]; + } + goto __pyx_L4_argument_unpacking_done; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("close_statement", 1, 2, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(27, 257, __pyx_L3_error) + __pyx_L3_error:; + __Pyx_AddTraceback("asyncpg.protocol.protocol.BaseProtocol.close_statement", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_state), __pyx_ptype_7asyncpg_8protocol_8protocol_PreparedStatementState, 1, "state", 0))) __PYX_ERR(27, 257, __pyx_L1_error) + __pyx_r = __pyx_pf_7asyncpg_8protocol_8protocol_12BaseProtocol_26close_statement(((struct __pyx_obj_7asyncpg_8protocol_8protocol_BaseProtocol *)__pyx_v_self), __pyx_v_state, __pyx_v_timeout); + + /* function exit code */ + goto __pyx_L0; + __pyx_L1_error:; + __pyx_r = NULL; + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_7asyncpg_8protocol_8protocol_12BaseProtocol_26close_statement(struct __pyx_obj_7asyncpg_8protocol_8protocol_BaseProtocol *__pyx_v_self, struct __pyx_obj_7asyncpg_8protocol_8protocol_PreparedStatementState *__pyx_v_state, PyObject *__pyx_v_timeout) { + struct __pyx_obj_7asyncpg_8protocol_8protocol___pyx_scope_struct_7_close_statement *__pyx_cur_scope; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("close_statement", 0); + __pyx_cur_scope = (struct __pyx_obj_7asyncpg_8protocol_8protocol___pyx_scope_struct_7_close_statement *)__pyx_tp_new_7asyncpg_8protocol_8protocol___pyx_scope_struct_7_close_statement(__pyx_ptype_7asyncpg_8protocol_8protocol___pyx_scope_struct_7_close_statement, __pyx_empty_tuple, NULL); + if (unlikely(!__pyx_cur_scope)) { + __pyx_cur_scope = ((struct __pyx_obj_7asyncpg_8protocol_8protocol___pyx_scope_struct_7_close_statement *)Py_None); + __Pyx_INCREF(Py_None); + __PYX_ERR(27, 257, __pyx_L1_error) + } else { + __Pyx_GOTREF(__pyx_cur_scope); + } + __pyx_cur_scope->__pyx_v_self = __pyx_v_self; + __Pyx_INCREF((PyObject *)__pyx_cur_scope->__pyx_v_self); + __Pyx_GIVEREF((PyObject *)__pyx_cur_scope->__pyx_v_self); + __pyx_cur_scope->__pyx_v_state = __pyx_v_state; + __Pyx_INCREF((PyObject *)__pyx_cur_scope->__pyx_v_state); + __Pyx_GIVEREF((PyObject *)__pyx_cur_scope->__pyx_v_state); + __pyx_cur_scope->__pyx_v_timeout = __pyx_v_timeout; + __Pyx_INCREF(__pyx_cur_scope->__pyx_v_timeout); + __Pyx_GIVEREF(__pyx_cur_scope->__pyx_v_timeout); + { + __pyx_CoroutineObject *gen = __Pyx_Coroutine_New((__pyx_coroutine_body_t) __pyx_gb_7asyncpg_8protocol_8protocol_12BaseProtocol_28generator6, (PyObject *) __pyx_cur_scope, __pyx_n_s_close_statement, __pyx_n_s_BaseProtocol_close_statement, __pyx_n_s_asyncpg_protocol_protocol); if (unlikely(!gen)) __PYX_ERR(27, 257, __pyx_L1_error) + __Pyx_DECREF(__pyx_cur_scope); + __Pyx_RefNannyFinishContext(); + return (PyObject *) gen; + } + + /* function exit code */ + __pyx_L1_error:; + __Pyx_AddTraceback("asyncpg.protocol.protocol.BaseProtocol.close_statement", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __Pyx_DECREF(((PyObject *)__pyx_cur_scope)); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_gb_7asyncpg_8protocol_8protocol_12BaseProtocol_28generator6(__pyx_CoroutineObject *__pyx_generator, PyObject *__pyx_sent_value) /* generator body */ +{ + struct __pyx_obj_7asyncpg_8protocol_8protocol___pyx_scope_struct_7_close_statement *__pyx_cur_scope = ((struct __pyx_obj_7asyncpg_8protocol_8protocol___pyx_scope_struct_7_close_statement *)__pyx_generator->closure); + PyObject *__pyx_r = NULL; + int __pyx_t_1; + int __pyx_t_2; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + PyObject *__pyx_t_5 = NULL; + PyObject *__pyx_t_6 = NULL; + PyObject *__pyx_t_7 = NULL; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("None", 0); + switch (__pyx_generator->resume_label) { + case 0: goto __pyx_L3_first_run; + case 1: goto __pyx_L5_resume_from_yield; + case 2: goto __pyx_L7_resume_from_yield; + case 3: goto __pyx_L9_resume_from_yield; + default: /* CPython raises the right error here */ + __Pyx_RefNannyFinishContext(); + return NULL; + } + __pyx_L3_first_run:; + if (unlikely(!__pyx_sent_value)) __PYX_ERR(27, 257, __pyx_L1_error) + + /* "asyncpg/protocol/protocol.pyx":258 + * + * async def close_statement(self, PreparedStatementState state, timeout): + * if self.cancel_waiter is not None: # <<<<<<<<<<<<<< + * await self.cancel_waiter + * if self.cancel_sent_waiter is not None: + */ + __pyx_t_1 = (__pyx_cur_scope->__pyx_v_self->cancel_waiter != Py_None); + __pyx_t_2 = (__pyx_t_1 != 0); + if (__pyx_t_2) { + + /* "asyncpg/protocol/protocol.pyx":259 + * async def close_statement(self, PreparedStatementState state, timeout): + * if self.cancel_waiter is not None: + * await self.cancel_waiter # <<<<<<<<<<<<<< + * if self.cancel_sent_waiter is not None: + * await self.cancel_sent_waiter + */ + __pyx_r = __Pyx_Coroutine_Yield_From(__pyx_generator, __pyx_cur_scope->__pyx_v_self->cancel_waiter); + __Pyx_XGOTREF(__pyx_r); + if (likely(__pyx_r)) { + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + /* return from generator, yielding value */ + __pyx_generator->resume_label = 1; + return __pyx_r; + __pyx_L5_resume_from_yield:; + if (unlikely(!__pyx_sent_value)) __PYX_ERR(27, 259, __pyx_L1_error) + } else { + PyObject* exc_type = PyErr_Occurred(); + if (exc_type) { + if (likely(exc_type == PyExc_StopIteration || PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) PyErr_Clear(); + else __PYX_ERR(27, 259, __pyx_L1_error) + } + } + + /* "asyncpg/protocol/protocol.pyx":258 + * + * async def close_statement(self, PreparedStatementState state, timeout): + * if self.cancel_waiter is not None: # <<<<<<<<<<<<<< + * await self.cancel_waiter + * if self.cancel_sent_waiter is not None: + */ + } + + /* "asyncpg/protocol/protocol.pyx":260 + * if self.cancel_waiter is not None: + * await self.cancel_waiter + * if self.cancel_sent_waiter is not None: # <<<<<<<<<<<<<< + * await self.cancel_sent_waiter + * self.cancel_sent_waiter = None + */ + __pyx_t_2 = (__pyx_cur_scope->__pyx_v_self->cancel_sent_waiter != Py_None); + __pyx_t_1 = (__pyx_t_2 != 0); + if (__pyx_t_1) { + + /* "asyncpg/protocol/protocol.pyx":261 + * await self.cancel_waiter + * if self.cancel_sent_waiter is not None: + * await self.cancel_sent_waiter # <<<<<<<<<<<<<< + * self.cancel_sent_waiter = None + * + */ + __pyx_r = __Pyx_Coroutine_Yield_From(__pyx_generator, __pyx_cur_scope->__pyx_v_self->cancel_sent_waiter); + __Pyx_XGOTREF(__pyx_r); + if (likely(__pyx_r)) { + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + /* return from generator, yielding value */ + __pyx_generator->resume_label = 2; + return __pyx_r; + __pyx_L7_resume_from_yield:; + if (unlikely(!__pyx_sent_value)) __PYX_ERR(27, 261, __pyx_L1_error) + } else { + PyObject* exc_type = PyErr_Occurred(); + if (exc_type) { + if (likely(exc_type == PyExc_StopIteration || PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) PyErr_Clear(); + else __PYX_ERR(27, 261, __pyx_L1_error) + } + } + + /* "asyncpg/protocol/protocol.pyx":262 + * if self.cancel_sent_waiter is not None: + * await self.cancel_sent_waiter + * self.cancel_sent_waiter = None # <<<<<<<<<<<<<< + * + * self._ensure_clear_state() + */ + __Pyx_INCREF(Py_None); + __Pyx_GIVEREF(Py_None); + __Pyx_GOTREF(__pyx_cur_scope->__pyx_v_self->cancel_sent_waiter); + __Pyx_DECREF(__pyx_cur_scope->__pyx_v_self->cancel_sent_waiter); + __pyx_cur_scope->__pyx_v_self->cancel_sent_waiter = Py_None; + + /* "asyncpg/protocol/protocol.pyx":260 + * if self.cancel_waiter is not None: + * await self.cancel_waiter + * if self.cancel_sent_waiter is not None: # <<<<<<<<<<<<<< + * await self.cancel_sent_waiter + * self.cancel_sent_waiter = None + */ + } + + /* "asyncpg/protocol/protocol.pyx":264 + * self.cancel_sent_waiter = None + * + * self._ensure_clear_state() # <<<<<<<<<<<<<< + * + * if state.refs != 0: + */ + __pyx_t_3 = ((struct __pyx_vtabstruct_7asyncpg_8protocol_8protocol_BaseProtocol *)__pyx_cur_scope->__pyx_v_self->__pyx_base.__pyx_vtab)->_ensure_clear_state(__pyx_cur_scope->__pyx_v_self); if (unlikely(!__pyx_t_3)) __PYX_ERR(27, 264, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + + /* "asyncpg/protocol/protocol.pyx":266 + * self._ensure_clear_state() + * + * if state.refs != 0: # <<<<<<<<<<<<<< + * raise RuntimeError( + * 'cannot close prepared statement; refs == {} != 0'.format( + */ + __pyx_t_1 = ((__pyx_cur_scope->__pyx_v_state->refs != 0) != 0); + if (__pyx_t_1) { + + /* "asyncpg/protocol/protocol.pyx":268 + * if state.refs != 0: + * raise RuntimeError( + * 'cannot close prepared statement; refs == {} != 0'.format( # <<<<<<<<<<<<<< + * state.refs)) + * + */ + __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_kp_u_cannot_close_prepared_statement, __pyx_n_s_format); if (unlikely(!__pyx_t_4)) __PYX_ERR(27, 268, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + + /* "asyncpg/protocol/protocol.pyx":269 + * raise RuntimeError( + * 'cannot close prepared statement; refs == {} != 0'.format( + * state.refs)) # <<<<<<<<<<<<<< + * + * self._close(state.name, False) + */ + __pyx_t_5 = __Pyx_PyInt_From_int(__pyx_cur_scope->__pyx_v_state->refs); if (unlikely(!__pyx_t_5)) __PYX_ERR(27, 269, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_6 = NULL; + if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_4))) { + __pyx_t_6 = PyMethod_GET_SELF(__pyx_t_4); + if (likely(__pyx_t_6)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4); + __Pyx_INCREF(__pyx_t_6); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_4, function); + } + } + if (!__pyx_t_6) { + __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_t_5); if (unlikely(!__pyx_t_3)) __PYX_ERR(27, 268, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_GOTREF(__pyx_t_3); + } else { + #if CYTHON_FAST_PYCALL + if (PyFunction_Check(__pyx_t_4)) { + PyObject *__pyx_temp[2] = {__pyx_t_6, __pyx_t_5}; + __pyx_t_3 = __Pyx_PyFunction_FastCall(__pyx_t_4, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_3)) __PYX_ERR(27, 268, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + } else + #endif + #if CYTHON_FAST_PYCCALL + if (__Pyx_PyFastCFunction_Check(__pyx_t_4)) { + PyObject *__pyx_temp[2] = {__pyx_t_6, __pyx_t_5}; + __pyx_t_3 = __Pyx_PyCFunction_FastCall(__pyx_t_4, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_3)) __PYX_ERR(27, 268, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + } else + #endif + { + __pyx_t_7 = PyTuple_New(1+1); if (unlikely(!__pyx_t_7)) __PYX_ERR(27, 268, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __Pyx_GIVEREF(__pyx_t_6); PyTuple_SET_ITEM(__pyx_t_7, 0, __pyx_t_6); __pyx_t_6 = NULL; + __Pyx_GIVEREF(__pyx_t_5); + PyTuple_SET_ITEM(__pyx_t_7, 0+1, __pyx_t_5); + __pyx_t_5 = 0; + __pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_4, __pyx_t_7, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(27, 268, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + } + } + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + + /* "asyncpg/protocol/protocol.pyx":267 + * + * if state.refs != 0: + * raise RuntimeError( # <<<<<<<<<<<<<< + * 'cannot close prepared statement; refs == {} != 0'.format( + * state.refs)) + */ + __pyx_t_4 = PyTuple_New(1); if (unlikely(!__pyx_t_4)) __PYX_ERR(27, 267, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_GIVEREF(__pyx_t_3); + PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_3); + __pyx_t_3 = 0; + __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_RuntimeError, __pyx_t_4, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(27, 267, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_Raise(__pyx_t_3, 0, 0, 0); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __PYX_ERR(27, 267, __pyx_L1_error) + + /* "asyncpg/protocol/protocol.pyx":266 + * self._ensure_clear_state() + * + * if state.refs != 0: # <<<<<<<<<<<<<< + * raise RuntimeError( + * 'cannot close prepared statement; refs == {} != 0'.format( + */ + } + + /* "asyncpg/protocol/protocol.pyx":271 + * state.refs)) + * + * self._close(state.name, False) # <<<<<<<<<<<<<< + * state.closed = True + * return await self._new_waiter(timeout) + */ + __pyx_t_3 = __pyx_cur_scope->__pyx_v_state->name; + __Pyx_INCREF(__pyx_t_3); + __pyx_t_4 = ((struct __pyx_vtabstruct_7asyncpg_8protocol_8protocol_BaseProtocol *)__pyx_cur_scope->__pyx_v_self->__pyx_base.__pyx_vtab)->__pyx_base._close(((struct __pyx_obj_7asyncpg_8protocol_8protocol_CoreProtocol *)__pyx_cur_scope->__pyx_v_self), ((PyObject*)__pyx_t_3), 0); if (unlikely(!__pyx_t_4)) __PYX_ERR(27, 271, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + + /* "asyncpg/protocol/protocol.pyx":272 + * + * self._close(state.name, False) + * state.closed = True # <<<<<<<<<<<<<< + * return await self._new_waiter(timeout) + * + */ + __pyx_cur_scope->__pyx_v_state->closed = 1; + + /* "asyncpg/protocol/protocol.pyx":273 + * self._close(state.name, False) + * state.closed = True + * return await self._new_waiter(timeout) # <<<<<<<<<<<<<< + * + * def is_closed(self): + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_4 = ((struct __pyx_vtabstruct_7asyncpg_8protocol_8protocol_BaseProtocol *)__pyx_cur_scope->__pyx_v_self->__pyx_base.__pyx_vtab)->_new_waiter(__pyx_cur_scope->__pyx_v_self, __pyx_cur_scope->__pyx_v_timeout); if (unlikely(!__pyx_t_4)) __PYX_ERR(27, 273, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_r = __Pyx_Coroutine_Yield_From(__pyx_generator, __pyx_t_4); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_XGOTREF(__pyx_r); + if (likely(__pyx_r)) { + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + /* return from generator, yielding value */ + __pyx_generator->resume_label = 3; + return __pyx_r; + __pyx_L9_resume_from_yield:; + if (unlikely(!__pyx_sent_value)) __PYX_ERR(27, 273, __pyx_L1_error) + __pyx_t_4 = __pyx_sent_value; __Pyx_INCREF(__pyx_t_4); + } else { + __pyx_t_4 = NULL; + if (__Pyx_PyGen_FetchStopIterationValue(&__pyx_t_4) < 0) __PYX_ERR(27, 273, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + } + __pyx_r = NULL; __Pyx_ReturnWithStopIteration(__pyx_t_4); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_4 = 0; + goto __pyx_L0; + CYTHON_MAYBE_UNUSED_VAR(__pyx_cur_scope); + + /* "asyncpg/protocol/protocol.pyx":257 + * return await self._new_waiter(timeout) + * + * async def close_statement(self, PreparedStatementState state, timeout): # <<<<<<<<<<<<<< + * if self.cancel_waiter is not None: + * await self.cancel_waiter + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_XDECREF(__pyx_t_6); + __Pyx_XDECREF(__pyx_t_7); + __Pyx_AddTraceback("close_statement", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_L0:; + __Pyx_XDECREF(__pyx_r); __pyx_r = 0; + __pyx_generator->resume_label = -1; + __Pyx_Coroutine_clear((PyObject*)__pyx_generator); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "asyncpg/protocol/protocol.pyx":275 + * return await self._new_waiter(timeout) + * + * def is_closed(self): # <<<<<<<<<<<<<< + * return self.closing + * + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_7asyncpg_8protocol_8protocol_12BaseProtocol_30is_closed(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/ +static PyObject *__pyx_pw_7asyncpg_8protocol_8protocol_12BaseProtocol_30is_closed(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("is_closed (wrapper)", 0); + __pyx_r = __pyx_pf_7asyncpg_8protocol_8protocol_12BaseProtocol_29is_closed(((struct __pyx_obj_7asyncpg_8protocol_8protocol_BaseProtocol *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_7asyncpg_8protocol_8protocol_12BaseProtocol_29is_closed(struct __pyx_obj_7asyncpg_8protocol_8protocol_BaseProtocol *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + __Pyx_RefNannySetupContext("is_closed", 0); + + /* "asyncpg/protocol/protocol.pyx":276 + * + * def is_closed(self): + * return self.closing # <<<<<<<<<<<<<< + * + * def is_connected(self): + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyBool_FromLong(__pyx_v_self->closing); if (unlikely(!__pyx_t_1)) __PYX_ERR(27, 276, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "asyncpg/protocol/protocol.pyx":275 + * return await self._new_waiter(timeout) + * + * def is_closed(self): # <<<<<<<<<<<<<< + * return self.closing + * + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("asyncpg.protocol.protocol.BaseProtocol.is_closed", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "asyncpg/protocol/protocol.pyx":278 + * return self.closing + * + * def is_connected(self): # <<<<<<<<<<<<<< + * return not self.closing and self.con_status == CONNECTION_OK + * + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_7asyncpg_8protocol_8protocol_12BaseProtocol_32is_connected(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/ +static PyObject *__pyx_pw_7asyncpg_8protocol_8protocol_12BaseProtocol_32is_connected(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("is_connected (wrapper)", 0); + __pyx_r = __pyx_pf_7asyncpg_8protocol_8protocol_12BaseProtocol_31is_connected(((struct __pyx_obj_7asyncpg_8protocol_8protocol_BaseProtocol *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_7asyncpg_8protocol_8protocol_12BaseProtocol_31is_connected(struct __pyx_obj_7asyncpg_8protocol_8protocol_BaseProtocol *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_t_2; + PyObject *__pyx_t_3 = NULL; + __Pyx_RefNannySetupContext("is_connected", 0); + + /* "asyncpg/protocol/protocol.pyx":279 + * + * def is_connected(self): + * return not self.closing and self.con_status == CONNECTION_OK # <<<<<<<<<<<<<< + * + * def abort(self): + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_2 = (!(__pyx_v_self->closing != 0)); + if (__pyx_t_2) { + } else { + __pyx_t_3 = __Pyx_PyBool_FromLong(__pyx_t_2); if (unlikely(!__pyx_t_3)) __PYX_ERR(27, 279, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_1 = __pyx_t_3; + __pyx_t_3 = 0; + goto __pyx_L3_bool_binop_done; + } + __pyx_t_2 = (__pyx_v_self->__pyx_base.con_status == __pyx_e_7asyncpg_8protocol_8protocol_CONNECTION_OK); + __pyx_t_3 = __Pyx_PyBool_FromLong(__pyx_t_2); if (unlikely(!__pyx_t_3)) __PYX_ERR(27, 279, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_1 = __pyx_t_3; + __pyx_t_3 = 0; + __pyx_L3_bool_binop_done:; + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "asyncpg/protocol/protocol.pyx":278 + * return self.closing + * + * def is_connected(self): # <<<<<<<<<<<<<< + * return not self.closing and self.con_status == CONNECTION_OK + * + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_AddTraceback("asyncpg.protocol.protocol.BaseProtocol.is_connected", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "asyncpg/protocol/protocol.pyx":281 + * return not self.closing and self.con_status == CONNECTION_OK + * + * def abort(self): # <<<<<<<<<<<<<< + * if self.closing: + * return + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_7asyncpg_8protocol_8protocol_12BaseProtocol_34abort(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/ +static PyObject *__pyx_pw_7asyncpg_8protocol_8protocol_12BaseProtocol_34abort(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("abort (wrapper)", 0); + __pyx_r = __pyx_pf_7asyncpg_8protocol_8protocol_12BaseProtocol_33abort(((struct __pyx_obj_7asyncpg_8protocol_8protocol_BaseProtocol *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_7asyncpg_8protocol_8protocol_12BaseProtocol_33abort(struct __pyx_obj_7asyncpg_8protocol_8protocol_BaseProtocol *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + __Pyx_RefNannySetupContext("abort", 0); + + /* "asyncpg/protocol/protocol.pyx":282 + * + * def abort(self): + * if self.closing: # <<<<<<<<<<<<<< + * return + * self.closing = True + */ + __pyx_t_1 = (__pyx_v_self->closing != 0); + if (__pyx_t_1) { + + /* "asyncpg/protocol/protocol.pyx":283 + * def abort(self): + * if self.closing: + * return # <<<<<<<<<<<<<< + * self.closing = True + * self._handle_waiter_on_connection_lost(None) + */ + __Pyx_XDECREF(__pyx_r); + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + + /* "asyncpg/protocol/protocol.pyx":282 + * + * def abort(self): + * if self.closing: # <<<<<<<<<<<<<< + * return + * self.closing = True + */ + } + + /* "asyncpg/protocol/protocol.pyx":284 + * if self.closing: + * return + * self.closing = True # <<<<<<<<<<<<<< + * self._handle_waiter_on_connection_lost(None) + * self._terminate() + */ + __pyx_v_self->closing = 1; + + /* "asyncpg/protocol/protocol.pyx":285 + * return + * self.closing = True + * self._handle_waiter_on_connection_lost(None) # <<<<<<<<<<<<<< + * self._terminate() + * self.transport.abort() + */ + __pyx_t_2 = ((struct __pyx_vtabstruct_7asyncpg_8protocol_8protocol_BaseProtocol *)__pyx_v_self->__pyx_base.__pyx_vtab)->_handle_waiter_on_connection_lost(__pyx_v_self, Py_None); if (unlikely(!__pyx_t_2)) __PYX_ERR(27, 285, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "asyncpg/protocol/protocol.pyx":286 + * self.closing = True + * self._handle_waiter_on_connection_lost(None) + * self._terminate() # <<<<<<<<<<<<<< + * self.transport.abort() + * + */ + __pyx_t_2 = ((struct __pyx_vtabstruct_7asyncpg_8protocol_8protocol_BaseProtocol *)__pyx_v_self->__pyx_base.__pyx_vtab)->__pyx_base._terminate(((struct __pyx_obj_7asyncpg_8protocol_8protocol_CoreProtocol *)__pyx_v_self)); if (unlikely(!__pyx_t_2)) __PYX_ERR(27, 286, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "asyncpg/protocol/protocol.pyx":287 + * self._handle_waiter_on_connection_lost(None) + * self._terminate() + * self.transport.abort() # <<<<<<<<<<<<<< + * + * async def close(self): + */ + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_self->__pyx_base.transport, __pyx_n_s_abort); if (unlikely(!__pyx_t_3)) __PYX_ERR(27, 287, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = NULL; + if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_3))) { + __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_3); + if (likely(__pyx_t_4)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); + __Pyx_INCREF(__pyx_t_4); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_3, function); + } + } + if (__pyx_t_4) { + __pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_4); if (unlikely(!__pyx_t_2)) __PYX_ERR(27, 287, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + } else { + __pyx_t_2 = __Pyx_PyObject_CallNoArg(__pyx_t_3); if (unlikely(!__pyx_t_2)) __PYX_ERR(27, 287, __pyx_L1_error) + } + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "asyncpg/protocol/protocol.pyx":281 + * return not self.closing and self.con_status == CONNECTION_OK + * + * def abort(self): # <<<<<<<<<<<<<< + * if self.closing: + * return + */ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_AddTraceback("asyncpg.protocol.protocol.BaseProtocol.abort", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} +static PyObject *__pyx_gb_7asyncpg_8protocol_8protocol_12BaseProtocol_37generator7(__pyx_CoroutineObject *__pyx_generator, PyObject *__pyx_sent_value); /* proto */ + +/* "asyncpg/protocol/protocol.pyx":289 + * self.transport.abort() + * + * async def close(self): # <<<<<<<<<<<<<< + * if self.cancel_waiter is not None: + * await self.cancel_waiter + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_7asyncpg_8protocol_8protocol_12BaseProtocol_36close(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/ +static PyObject *__pyx_pw_7asyncpg_8protocol_8protocol_12BaseProtocol_36close(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("close (wrapper)", 0); + __pyx_r = __pyx_pf_7asyncpg_8protocol_8protocol_12BaseProtocol_35close(((struct __pyx_obj_7asyncpg_8protocol_8protocol_BaseProtocol *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_7asyncpg_8protocol_8protocol_12BaseProtocol_35close(struct __pyx_obj_7asyncpg_8protocol_8protocol_BaseProtocol *__pyx_v_self) { + struct __pyx_obj_7asyncpg_8protocol_8protocol___pyx_scope_struct_8_close *__pyx_cur_scope; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("close", 0); + __pyx_cur_scope = (struct __pyx_obj_7asyncpg_8protocol_8protocol___pyx_scope_struct_8_close *)__pyx_tp_new_7asyncpg_8protocol_8protocol___pyx_scope_struct_8_close(__pyx_ptype_7asyncpg_8protocol_8protocol___pyx_scope_struct_8_close, __pyx_empty_tuple, NULL); + if (unlikely(!__pyx_cur_scope)) { + __pyx_cur_scope = ((struct __pyx_obj_7asyncpg_8protocol_8protocol___pyx_scope_struct_8_close *)Py_None); + __Pyx_INCREF(Py_None); + __PYX_ERR(27, 289, __pyx_L1_error) + } else { + __Pyx_GOTREF(__pyx_cur_scope); + } + __pyx_cur_scope->__pyx_v_self = __pyx_v_self; + __Pyx_INCREF((PyObject *)__pyx_cur_scope->__pyx_v_self); + __Pyx_GIVEREF((PyObject *)__pyx_cur_scope->__pyx_v_self); + { + __pyx_CoroutineObject *gen = __Pyx_Coroutine_New((__pyx_coroutine_body_t) __pyx_gb_7asyncpg_8protocol_8protocol_12BaseProtocol_37generator7, (PyObject *) __pyx_cur_scope, __pyx_n_s_close, __pyx_n_s_BaseProtocol_close, __pyx_n_s_asyncpg_protocol_protocol); if (unlikely(!gen)) __PYX_ERR(27, 289, __pyx_L1_error) + __Pyx_DECREF(__pyx_cur_scope); + __Pyx_RefNannyFinishContext(); + return (PyObject *) gen; + } + + /* function exit code */ + __pyx_L1_error:; + __Pyx_AddTraceback("asyncpg.protocol.protocol.BaseProtocol.close", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __Pyx_DECREF(((PyObject *)__pyx_cur_scope)); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_gb_7asyncpg_8protocol_8protocol_12BaseProtocol_37generator7(__pyx_CoroutineObject *__pyx_generator, PyObject *__pyx_sent_value) /* generator body */ +{ + struct __pyx_obj_7asyncpg_8protocol_8protocol___pyx_scope_struct_8_close *__pyx_cur_scope = ((struct __pyx_obj_7asyncpg_8protocol_8protocol___pyx_scope_struct_8_close *)__pyx_generator->closure); + PyObject *__pyx_r = NULL; + int __pyx_t_1; + int __pyx_t_2; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + PyObject *__pyx_t_5 = NULL; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("None", 0); + switch (__pyx_generator->resume_label) { + case 0: goto __pyx_L3_first_run; + case 1: goto __pyx_L5_resume_from_yield; + case 2: goto __pyx_L7_resume_from_yield; + case 3: goto __pyx_L9_resume_from_yield; + default: /* CPython raises the right error here */ + __Pyx_RefNannyFinishContext(); + return NULL; + } + __pyx_L3_first_run:; + if (unlikely(!__pyx_sent_value)) __PYX_ERR(27, 289, __pyx_L1_error) + + /* "asyncpg/protocol/protocol.pyx":290 + * + * async def close(self): + * if self.cancel_waiter is not None: # <<<<<<<<<<<<<< + * await self.cancel_waiter + * if self.cancel_sent_waiter is not None: + */ + __pyx_t_1 = (__pyx_cur_scope->__pyx_v_self->cancel_waiter != Py_None); + __pyx_t_2 = (__pyx_t_1 != 0); + if (__pyx_t_2) { + + /* "asyncpg/protocol/protocol.pyx":291 + * async def close(self): + * if self.cancel_waiter is not None: + * await self.cancel_waiter # <<<<<<<<<<<<<< + * if self.cancel_sent_waiter is not None: + * await self.cancel_sent_waiter + */ + __pyx_r = __Pyx_Coroutine_Yield_From(__pyx_generator, __pyx_cur_scope->__pyx_v_self->cancel_waiter); + __Pyx_XGOTREF(__pyx_r); + if (likely(__pyx_r)) { + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + /* return from generator, yielding value */ + __pyx_generator->resume_label = 1; + return __pyx_r; + __pyx_L5_resume_from_yield:; + if (unlikely(!__pyx_sent_value)) __PYX_ERR(27, 291, __pyx_L1_error) + } else { + PyObject* exc_type = PyErr_Occurred(); + if (exc_type) { + if (likely(exc_type == PyExc_StopIteration || PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) PyErr_Clear(); + else __PYX_ERR(27, 291, __pyx_L1_error) + } + } + + /* "asyncpg/protocol/protocol.pyx":290 + * + * async def close(self): + * if self.cancel_waiter is not None: # <<<<<<<<<<<<<< + * await self.cancel_waiter + * if self.cancel_sent_waiter is not None: + */ + } + + /* "asyncpg/protocol/protocol.pyx":292 + * if self.cancel_waiter is not None: + * await self.cancel_waiter + * if self.cancel_sent_waiter is not None: # <<<<<<<<<<<<<< + * await self.cancel_sent_waiter + * self.cancel_sent_waiter = None + */ + __pyx_t_2 = (__pyx_cur_scope->__pyx_v_self->cancel_sent_waiter != Py_None); + __pyx_t_1 = (__pyx_t_2 != 0); + if (__pyx_t_1) { + + /* "asyncpg/protocol/protocol.pyx":293 + * await self.cancel_waiter + * if self.cancel_sent_waiter is not None: + * await self.cancel_sent_waiter # <<<<<<<<<<<<<< + * self.cancel_sent_waiter = None + * + */ + __pyx_r = __Pyx_Coroutine_Yield_From(__pyx_generator, __pyx_cur_scope->__pyx_v_self->cancel_sent_waiter); + __Pyx_XGOTREF(__pyx_r); + if (likely(__pyx_r)) { + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + /* return from generator, yielding value */ + __pyx_generator->resume_label = 2; + return __pyx_r; + __pyx_L7_resume_from_yield:; + if (unlikely(!__pyx_sent_value)) __PYX_ERR(27, 293, __pyx_L1_error) + } else { + PyObject* exc_type = PyErr_Occurred(); + if (exc_type) { + if (likely(exc_type == PyExc_StopIteration || PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) PyErr_Clear(); + else __PYX_ERR(27, 293, __pyx_L1_error) + } + } + + /* "asyncpg/protocol/protocol.pyx":294 + * if self.cancel_sent_waiter is not None: + * await self.cancel_sent_waiter + * self.cancel_sent_waiter = None # <<<<<<<<<<<<<< + * + * self._handle_waiter_on_connection_lost(None) + */ + __Pyx_INCREF(Py_None); + __Pyx_GIVEREF(Py_None); + __Pyx_GOTREF(__pyx_cur_scope->__pyx_v_self->cancel_sent_waiter); + __Pyx_DECREF(__pyx_cur_scope->__pyx_v_self->cancel_sent_waiter); + __pyx_cur_scope->__pyx_v_self->cancel_sent_waiter = Py_None; + + /* "asyncpg/protocol/protocol.pyx":292 + * if self.cancel_waiter is not None: + * await self.cancel_waiter + * if self.cancel_sent_waiter is not None: # <<<<<<<<<<<<<< + * await self.cancel_sent_waiter + * self.cancel_sent_waiter = None + */ + } + + /* "asyncpg/protocol/protocol.pyx":296 + * self.cancel_sent_waiter = None + * + * self._handle_waiter_on_connection_lost(None) # <<<<<<<<<<<<<< + * assert self.waiter is None + * + */ + __pyx_t_3 = ((struct __pyx_vtabstruct_7asyncpg_8protocol_8protocol_BaseProtocol *)__pyx_cur_scope->__pyx_v_self->__pyx_base.__pyx_vtab)->_handle_waiter_on_connection_lost(__pyx_cur_scope->__pyx_v_self, Py_None); if (unlikely(!__pyx_t_3)) __PYX_ERR(27, 296, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + + /* "asyncpg/protocol/protocol.pyx":297 + * + * self._handle_waiter_on_connection_lost(None) + * assert self.waiter is None # <<<<<<<<<<<<<< + * + * if self.closing: + */ + #ifndef CYTHON_WITHOUT_ASSERTIONS + if (unlikely(!Py_OptimizeFlag)) { + __pyx_t_1 = (__pyx_cur_scope->__pyx_v_self->waiter == Py_None); + if (unlikely(!(__pyx_t_1 != 0))) { + PyErr_SetNone(PyExc_AssertionError); + __PYX_ERR(27, 297, __pyx_L1_error) + } + } + #endif + + /* "asyncpg/protocol/protocol.pyx":299 + * assert self.waiter is None + * + * if self.closing: # <<<<<<<<<<<<<< + * return + * + */ + __pyx_t_1 = (__pyx_cur_scope->__pyx_v_self->closing != 0); + if (__pyx_t_1) { + + /* "asyncpg/protocol/protocol.pyx":300 + * + * if self.closing: + * return # <<<<<<<<<<<<<< + * + * self._terminate() + */ + __Pyx_XDECREF(__pyx_r); + __pyx_r = NULL; + goto __pyx_L0; + + /* "asyncpg/protocol/protocol.pyx":299 + * assert self.waiter is None + * + * if self.closing: # <<<<<<<<<<<<<< + * return + * + */ + } + + /* "asyncpg/protocol/protocol.pyx":302 + * return + * + * self._terminate() # <<<<<<<<<<<<<< + * self.waiter = self.create_future() + * self.closing = True + */ + __pyx_t_3 = ((struct __pyx_vtabstruct_7asyncpg_8protocol_8protocol_BaseProtocol *)__pyx_cur_scope->__pyx_v_self->__pyx_base.__pyx_vtab)->__pyx_base._terminate(((struct __pyx_obj_7asyncpg_8protocol_8protocol_CoreProtocol *)__pyx_cur_scope->__pyx_v_self)); if (unlikely(!__pyx_t_3)) __PYX_ERR(27, 302, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + + /* "asyncpg/protocol/protocol.pyx":303 + * + * self._terminate() + * self.waiter = self.create_future() # <<<<<<<<<<<<<< + * self.closing = True + * self.transport.abort() + */ + __Pyx_INCREF(__pyx_cur_scope->__pyx_v_self->create_future); + __pyx_t_4 = __pyx_cur_scope->__pyx_v_self->create_future; __pyx_t_5 = NULL; + if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_4))) { + __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_4); + if (likely(__pyx_t_5)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4); + __Pyx_INCREF(__pyx_t_5); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_4, function); + } + } + if (__pyx_t_5) { + __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_t_5); if (unlikely(!__pyx_t_3)) __PYX_ERR(27, 303, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + } else { + __pyx_t_3 = __Pyx_PyObject_CallNoArg(__pyx_t_4); if (unlikely(!__pyx_t_3)) __PYX_ERR(27, 303, __pyx_L1_error) + } + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_GIVEREF(__pyx_t_3); + __Pyx_GOTREF(__pyx_cur_scope->__pyx_v_self->waiter); + __Pyx_DECREF(__pyx_cur_scope->__pyx_v_self->waiter); + __pyx_cur_scope->__pyx_v_self->waiter = __pyx_t_3; + __pyx_t_3 = 0; + + /* "asyncpg/protocol/protocol.pyx":304 + * self._terminate() + * self.waiter = self.create_future() + * self.closing = True # <<<<<<<<<<<<<< + * self.transport.abort() + * return await self.waiter + */ + __pyx_cur_scope->__pyx_v_self->closing = 1; + + /* "asyncpg/protocol/protocol.pyx":305 + * self.waiter = self.create_future() + * self.closing = True + * self.transport.abort() # <<<<<<<<<<<<<< + * return await self.waiter + * + */ + __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_cur_scope->__pyx_v_self->__pyx_base.transport, __pyx_n_s_abort); if (unlikely(!__pyx_t_4)) __PYX_ERR(27, 305, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_5 = NULL; + if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_4))) { + __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_4); + if (likely(__pyx_t_5)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4); + __Pyx_INCREF(__pyx_t_5); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_4, function); + } + } + if (__pyx_t_5) { + __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_t_5); if (unlikely(!__pyx_t_3)) __PYX_ERR(27, 305, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + } else { + __pyx_t_3 = __Pyx_PyObject_CallNoArg(__pyx_t_4); if (unlikely(!__pyx_t_3)) __PYX_ERR(27, 305, __pyx_L1_error) + } + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + + /* "asyncpg/protocol/protocol.pyx":306 + * self.closing = True + * self.transport.abort() + * return await self.waiter # <<<<<<<<<<<<<< + * + * def _request_cancel(self): + */ + __Pyx_XDECREF(__pyx_r); + __pyx_r = __Pyx_Coroutine_Yield_From(__pyx_generator, __pyx_cur_scope->__pyx_v_self->waiter); + __Pyx_XGOTREF(__pyx_r); + if (likely(__pyx_r)) { + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + /* return from generator, yielding value */ + __pyx_generator->resume_label = 3; + return __pyx_r; + __pyx_L9_resume_from_yield:; + if (unlikely(!__pyx_sent_value)) __PYX_ERR(27, 306, __pyx_L1_error) + __pyx_t_3 = __pyx_sent_value; __Pyx_INCREF(__pyx_t_3); + } else { + __pyx_t_3 = NULL; + if (__Pyx_PyGen_FetchStopIterationValue(&__pyx_t_3) < 0) __PYX_ERR(27, 306, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + } + __pyx_r = NULL; __Pyx_ReturnWithStopIteration(__pyx_t_3); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_3 = 0; + goto __pyx_L0; + CYTHON_MAYBE_UNUSED_VAR(__pyx_cur_scope); + + /* "asyncpg/protocol/protocol.pyx":289 + * self.transport.abort() + * + * async def close(self): # <<<<<<<<<<<<<< + * if self.cancel_waiter is not None: + * await self.cancel_waiter + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_AddTraceback("close", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_L0:; + __Pyx_XDECREF(__pyx_r); __pyx_r = 0; + __pyx_generator->resume_label = -1; + __Pyx_Coroutine_clear((PyObject*)__pyx_generator); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "asyncpg/protocol/protocol.pyx":308 + * return await self.waiter + * + * def _request_cancel(self): # <<<<<<<<<<<<<< + * self.cancel_waiter = self.create_future() + * self.cancel_sent_waiter = self.create_future() + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_7asyncpg_8protocol_8protocol_12BaseProtocol_39_request_cancel(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/ +static PyObject *__pyx_pw_7asyncpg_8protocol_8protocol_12BaseProtocol_39_request_cancel(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("_request_cancel (wrapper)", 0); + __pyx_r = __pyx_pf_7asyncpg_8protocol_8protocol_12BaseProtocol_38_request_cancel(((struct __pyx_obj_7asyncpg_8protocol_8protocol_BaseProtocol *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_7asyncpg_8protocol_8protocol_12BaseProtocol_38_request_cancel(struct __pyx_obj_7asyncpg_8protocol_8protocol_BaseProtocol *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + __Pyx_RefNannySetupContext("_request_cancel", 0); + + /* "asyncpg/protocol/protocol.pyx":309 + * + * def _request_cancel(self): + * self.cancel_waiter = self.create_future() # <<<<<<<<<<<<<< + * self.cancel_sent_waiter = self.create_future() + * self.connection._cancel_current_command(self.cancel_sent_waiter) + */ + __Pyx_INCREF(__pyx_v_self->create_future); + __pyx_t_2 = __pyx_v_self->create_future; __pyx_t_3 = NULL; + if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_3)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_3); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + } + } + if (__pyx_t_3) { + __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_3); if (unlikely(!__pyx_t_1)) __PYX_ERR(27, 309, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + } else { + __pyx_t_1 = __Pyx_PyObject_CallNoArg(__pyx_t_2); if (unlikely(!__pyx_t_1)) __PYX_ERR(27, 309, __pyx_L1_error) + } + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_GIVEREF(__pyx_t_1); + __Pyx_GOTREF(__pyx_v_self->cancel_waiter); + __Pyx_DECREF(__pyx_v_self->cancel_waiter); + __pyx_v_self->cancel_waiter = __pyx_t_1; + __pyx_t_1 = 0; + + /* "asyncpg/protocol/protocol.pyx":310 + * def _request_cancel(self): + * self.cancel_waiter = self.create_future() + * self.cancel_sent_waiter = self.create_future() # <<<<<<<<<<<<<< + * self.connection._cancel_current_command(self.cancel_sent_waiter) + * + */ + __Pyx_INCREF(__pyx_v_self->create_future); + __pyx_t_2 = __pyx_v_self->create_future; __pyx_t_3 = NULL; + if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_3)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_3); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + } + } + if (__pyx_t_3) { + __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_3); if (unlikely(!__pyx_t_1)) __PYX_ERR(27, 310, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + } else { + __pyx_t_1 = __Pyx_PyObject_CallNoArg(__pyx_t_2); if (unlikely(!__pyx_t_1)) __PYX_ERR(27, 310, __pyx_L1_error) + } + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_GIVEREF(__pyx_t_1); + __Pyx_GOTREF(__pyx_v_self->cancel_sent_waiter); + __Pyx_DECREF(__pyx_v_self->cancel_sent_waiter); + __pyx_v_self->cancel_sent_waiter = __pyx_t_1; + __pyx_t_1 = 0; + + /* "asyncpg/protocol/protocol.pyx":311 + * self.cancel_waiter = self.create_future() + * self.cancel_sent_waiter = self.create_future() + * self.connection._cancel_current_command(self.cancel_sent_waiter) # <<<<<<<<<<<<<< + * + * def _on_timeout(self, fut): + */ + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_self->connection, __pyx_n_s_cancel_current_command); if (unlikely(!__pyx_t_2)) __PYX_ERR(27, 311, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = NULL; + if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_3)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_3); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + } + } + if (!__pyx_t_3) { + __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_v_self->cancel_sent_waiter); if (unlikely(!__pyx_t_1)) __PYX_ERR(27, 311, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + } else { + #if CYTHON_FAST_PYCALL + if (PyFunction_Check(__pyx_t_2)) { + PyObject *__pyx_temp[2] = {__pyx_t_3, __pyx_v_self->cancel_sent_waiter}; + __pyx_t_1 = __Pyx_PyFunction_FastCall(__pyx_t_2, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_1)) __PYX_ERR(27, 311, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_GOTREF(__pyx_t_1); + } else + #endif + #if CYTHON_FAST_PYCCALL + if (__Pyx_PyFastCFunction_Check(__pyx_t_2)) { + PyObject *__pyx_temp[2] = {__pyx_t_3, __pyx_v_self->cancel_sent_waiter}; + __pyx_t_1 = __Pyx_PyCFunction_FastCall(__pyx_t_2, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_1)) __PYX_ERR(27, 311, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_GOTREF(__pyx_t_1); + } else + #endif + { + __pyx_t_4 = PyTuple_New(1+1); if (unlikely(!__pyx_t_4)) __PYX_ERR(27, 311, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_GIVEREF(__pyx_t_3); PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_3); __pyx_t_3 = NULL; + __Pyx_INCREF(__pyx_v_self->cancel_sent_waiter); + __Pyx_GIVEREF(__pyx_v_self->cancel_sent_waiter); + PyTuple_SET_ITEM(__pyx_t_4, 0+1, __pyx_v_self->cancel_sent_waiter); + __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_t_4, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(27, 311, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + } + } + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "asyncpg/protocol/protocol.pyx":308 + * return await self.waiter + * + * def _request_cancel(self): # <<<<<<<<<<<<<< + * self.cancel_waiter = self.create_future() + * self.cancel_sent_waiter = self.create_future() + */ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_AddTraceback("asyncpg.protocol.protocol.BaseProtocol._request_cancel", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "asyncpg/protocol/protocol.pyx":313 + * self.connection._cancel_current_command(self.cancel_sent_waiter) + * + * def _on_timeout(self, fut): # <<<<<<<<<<<<<< + * if self.waiter is not fut or fut.done() or \ + * self.cancel_waiter is not None or \ + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_7asyncpg_8protocol_8protocol_12BaseProtocol_41_on_timeout(PyObject *__pyx_v_self, PyObject *__pyx_v_fut); /*proto*/ +static PyObject *__pyx_pw_7asyncpg_8protocol_8protocol_12BaseProtocol_41_on_timeout(PyObject *__pyx_v_self, PyObject *__pyx_v_fut) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("_on_timeout (wrapper)", 0); + __pyx_r = __pyx_pf_7asyncpg_8protocol_8protocol_12BaseProtocol_40_on_timeout(((struct __pyx_obj_7asyncpg_8protocol_8protocol_BaseProtocol *)__pyx_v_self), ((PyObject *)__pyx_v_fut)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_7asyncpg_8protocol_8protocol_12BaseProtocol_40_on_timeout(struct __pyx_obj_7asyncpg_8protocol_8protocol_BaseProtocol *__pyx_v_self, PyObject *__pyx_v_fut) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + int __pyx_t_2; + int __pyx_t_3; + PyObject *__pyx_t_4 = NULL; + PyObject *__pyx_t_5 = NULL; + PyObject *__pyx_t_6 = NULL; + PyObject *__pyx_t_7 = NULL; + PyObject *__pyx_t_8 = NULL; + __Pyx_RefNannySetupContext("_on_timeout", 0); + + /* "asyncpg/protocol/protocol.pyx":314 + * + * def _on_timeout(self, fut): + * if self.waiter is not fut or fut.done() or \ # <<<<<<<<<<<<<< + * self.cancel_waiter is not None or \ + * self.timeout_handle is None: + */ + __pyx_t_2 = (__pyx_v_self->waiter != __pyx_v_fut); + __pyx_t_3 = (__pyx_t_2 != 0); + if (!__pyx_t_3) { + } else { + __pyx_t_1 = __pyx_t_3; + goto __pyx_L4_bool_binop_done; + } + __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_v_fut, __pyx_n_s_done); if (unlikely(!__pyx_t_5)) __PYX_ERR(27, 314, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_6 = NULL; + if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_5))) { + __pyx_t_6 = PyMethod_GET_SELF(__pyx_t_5); + if (likely(__pyx_t_6)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_5); + __Pyx_INCREF(__pyx_t_6); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_5, function); + } + } + if (__pyx_t_6) { + __pyx_t_4 = __Pyx_PyObject_CallOneArg(__pyx_t_5, __pyx_t_6); if (unlikely(!__pyx_t_4)) __PYX_ERR(27, 314, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + } else { + __pyx_t_4 = __Pyx_PyObject_CallNoArg(__pyx_t_5); if (unlikely(!__pyx_t_4)) __PYX_ERR(27, 314, __pyx_L1_error) + } + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __pyx_t_3 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_3 < 0)) __PYX_ERR(27, 314, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + if (!__pyx_t_3) { + } else { + __pyx_t_1 = __pyx_t_3; + goto __pyx_L4_bool_binop_done; + } + + /* "asyncpg/protocol/protocol.pyx":315 + * def _on_timeout(self, fut): + * if self.waiter is not fut or fut.done() or \ + * self.cancel_waiter is not None or \ # <<<<<<<<<<<<<< + * self.timeout_handle is None: + * return + */ + __pyx_t_3 = (__pyx_v_self->cancel_waiter != Py_None); + __pyx_t_2 = (__pyx_t_3 != 0); + if (!__pyx_t_2) { + } else { + __pyx_t_1 = __pyx_t_2; + goto __pyx_L4_bool_binop_done; + } + + /* "asyncpg/protocol/protocol.pyx":316 + * if self.waiter is not fut or fut.done() or \ + * self.cancel_waiter is not None or \ + * self.timeout_handle is None: # <<<<<<<<<<<<<< + * return + * self._request_cancel() + */ + __pyx_t_2 = (__pyx_v_self->timeout_handle == Py_None); + __pyx_t_3 = (__pyx_t_2 != 0); + __pyx_t_1 = __pyx_t_3; + __pyx_L4_bool_binop_done:; + + /* "asyncpg/protocol/protocol.pyx":314 + * + * def _on_timeout(self, fut): + * if self.waiter is not fut or fut.done() or \ # <<<<<<<<<<<<<< + * self.cancel_waiter is not None or \ + * self.timeout_handle is None: + */ + if (__pyx_t_1) { + + /* "asyncpg/protocol/protocol.pyx":317 + * self.cancel_waiter is not None or \ + * self.timeout_handle is None: + * return # <<<<<<<<<<<<<< + * self._request_cancel() + * self.waiter.set_exception(asyncio.TimeoutError()) + */ + __Pyx_XDECREF(__pyx_r); + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + + /* "asyncpg/protocol/protocol.pyx":314 + * + * def _on_timeout(self, fut): + * if self.waiter is not fut or fut.done() or \ # <<<<<<<<<<<<<< + * self.cancel_waiter is not None or \ + * self.timeout_handle is None: + */ + } + + /* "asyncpg/protocol/protocol.pyx":318 + * self.timeout_handle is None: + * return + * self._request_cancel() # <<<<<<<<<<<<<< + * self.waiter.set_exception(asyncio.TimeoutError()) + * + */ + __pyx_t_5 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_request_cancel); if (unlikely(!__pyx_t_5)) __PYX_ERR(27, 318, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_6 = NULL; + if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_5))) { + __pyx_t_6 = PyMethod_GET_SELF(__pyx_t_5); + if (likely(__pyx_t_6)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_5); + __Pyx_INCREF(__pyx_t_6); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_5, function); + } + } + if (__pyx_t_6) { + __pyx_t_4 = __Pyx_PyObject_CallOneArg(__pyx_t_5, __pyx_t_6); if (unlikely(!__pyx_t_4)) __PYX_ERR(27, 318, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + } else { + __pyx_t_4 = __Pyx_PyObject_CallNoArg(__pyx_t_5); if (unlikely(!__pyx_t_4)) __PYX_ERR(27, 318, __pyx_L1_error) + } + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + + /* "asyncpg/protocol/protocol.pyx":319 + * return + * self._request_cancel() + * self.waiter.set_exception(asyncio.TimeoutError()) # <<<<<<<<<<<<<< + * + * def _on_waiter_completed(self, fut): + */ + __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_v_self->waiter, __pyx_n_s_set_exception); if (unlikely(!__pyx_t_5)) __PYX_ERR(27, 319, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_7 = __Pyx_GetModuleGlobalName(__pyx_n_s_asyncio); if (unlikely(!__pyx_t_7)) __PYX_ERR(27, 319, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __pyx_t_8 = __Pyx_PyObject_GetAttrStr(__pyx_t_7, __pyx_n_s_TimeoutError); if (unlikely(!__pyx_t_8)) __PYX_ERR(27, 319, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __pyx_t_7 = NULL; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_8))) { + __pyx_t_7 = PyMethod_GET_SELF(__pyx_t_8); + if (likely(__pyx_t_7)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_8); + __Pyx_INCREF(__pyx_t_7); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_8, function); + } + } + if (__pyx_t_7) { + __pyx_t_6 = __Pyx_PyObject_CallOneArg(__pyx_t_8, __pyx_t_7); if (unlikely(!__pyx_t_6)) __PYX_ERR(27, 319, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + } else { + __pyx_t_6 = __Pyx_PyObject_CallNoArg(__pyx_t_8); if (unlikely(!__pyx_t_6)) __PYX_ERR(27, 319, __pyx_L1_error) + } + __Pyx_GOTREF(__pyx_t_6); + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + __pyx_t_8 = NULL; + if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_5))) { + __pyx_t_8 = PyMethod_GET_SELF(__pyx_t_5); + if (likely(__pyx_t_8)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_5); + __Pyx_INCREF(__pyx_t_8); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_5, function); + } + } + if (!__pyx_t_8) { + __pyx_t_4 = __Pyx_PyObject_CallOneArg(__pyx_t_5, __pyx_t_6); if (unlikely(!__pyx_t_4)) __PYX_ERR(27, 319, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_GOTREF(__pyx_t_4); + } else { + #if CYTHON_FAST_PYCALL + if (PyFunction_Check(__pyx_t_5)) { + PyObject *__pyx_temp[2] = {__pyx_t_8, __pyx_t_6}; + __pyx_t_4 = __Pyx_PyFunction_FastCall(__pyx_t_5, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_4)) __PYX_ERR(27, 319, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + } else + #endif + #if CYTHON_FAST_PYCCALL + if (__Pyx_PyFastCFunction_Check(__pyx_t_5)) { + PyObject *__pyx_temp[2] = {__pyx_t_8, __pyx_t_6}; + __pyx_t_4 = __Pyx_PyCFunction_FastCall(__pyx_t_5, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_4)) __PYX_ERR(27, 319, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + } else + #endif + { + __pyx_t_7 = PyTuple_New(1+1); if (unlikely(!__pyx_t_7)) __PYX_ERR(27, 319, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __Pyx_GIVEREF(__pyx_t_8); PyTuple_SET_ITEM(__pyx_t_7, 0, __pyx_t_8); __pyx_t_8 = NULL; + __Pyx_GIVEREF(__pyx_t_6); + PyTuple_SET_ITEM(__pyx_t_7, 0+1, __pyx_t_6); + __pyx_t_6 = 0; + __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_5, __pyx_t_7, NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(27, 319, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + } + } + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + + /* "asyncpg/protocol/protocol.pyx":313 + * self.connection._cancel_current_command(self.cancel_sent_waiter) + * + * def _on_timeout(self, fut): # <<<<<<<<<<<<<< + * if self.waiter is not fut or fut.done() or \ + * self.cancel_waiter is not None or \ + */ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_4); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_XDECREF(__pyx_t_6); + __Pyx_XDECREF(__pyx_t_7); + __Pyx_XDECREF(__pyx_t_8); + __Pyx_AddTraceback("asyncpg.protocol.protocol.BaseProtocol._on_timeout", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "asyncpg/protocol/protocol.pyx":321 + * self.waiter.set_exception(asyncio.TimeoutError()) + * + * def _on_waiter_completed(self, fut): # <<<<<<<<<<<<<< + * if fut is not self.waiter or self.cancel_waiter is not None: + * return + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_7asyncpg_8protocol_8protocol_12BaseProtocol_43_on_waiter_completed(PyObject *__pyx_v_self, PyObject *__pyx_v_fut); /*proto*/ +static PyObject *__pyx_pw_7asyncpg_8protocol_8protocol_12BaseProtocol_43_on_waiter_completed(PyObject *__pyx_v_self, PyObject *__pyx_v_fut) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("_on_waiter_completed (wrapper)", 0); + __pyx_r = __pyx_pf_7asyncpg_8protocol_8protocol_12BaseProtocol_42_on_waiter_completed(((struct __pyx_obj_7asyncpg_8protocol_8protocol_BaseProtocol *)__pyx_v_self), ((PyObject *)__pyx_v_fut)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_7asyncpg_8protocol_8protocol_12BaseProtocol_42_on_waiter_completed(struct __pyx_obj_7asyncpg_8protocol_8protocol_BaseProtocol *__pyx_v_self, PyObject *__pyx_v_fut) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + int __pyx_t_2; + int __pyx_t_3; + PyObject *__pyx_t_4 = NULL; + PyObject *__pyx_t_5 = NULL; + PyObject *__pyx_t_6 = NULL; + __Pyx_RefNannySetupContext("_on_waiter_completed", 0); + + /* "asyncpg/protocol/protocol.pyx":322 + * + * def _on_waiter_completed(self, fut): + * if fut is not self.waiter or self.cancel_waiter is not None: # <<<<<<<<<<<<<< + * return + * if fut.cancelled(): + */ + __pyx_t_2 = (__pyx_v_fut != __pyx_v_self->waiter); + __pyx_t_3 = (__pyx_t_2 != 0); + if (!__pyx_t_3) { + } else { + __pyx_t_1 = __pyx_t_3; + goto __pyx_L4_bool_binop_done; + } + __pyx_t_3 = (__pyx_v_self->cancel_waiter != Py_None); + __pyx_t_2 = (__pyx_t_3 != 0); + __pyx_t_1 = __pyx_t_2; + __pyx_L4_bool_binop_done:; + if (__pyx_t_1) { + + /* "asyncpg/protocol/protocol.pyx":323 + * def _on_waiter_completed(self, fut): + * if fut is not self.waiter or self.cancel_waiter is not None: + * return # <<<<<<<<<<<<<< + * if fut.cancelled(): + * if self.timeout_handle: + */ + __Pyx_XDECREF(__pyx_r); + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + + /* "asyncpg/protocol/protocol.pyx":322 + * + * def _on_waiter_completed(self, fut): + * if fut is not self.waiter or self.cancel_waiter is not None: # <<<<<<<<<<<<<< + * return + * if fut.cancelled(): + */ + } + + /* "asyncpg/protocol/protocol.pyx":324 + * if fut is not self.waiter or self.cancel_waiter is not None: + * return + * if fut.cancelled(): # <<<<<<<<<<<<<< + * if self.timeout_handle: + * self.timeout_handle.cancel() + */ + __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_v_fut, __pyx_n_s_cancelled); if (unlikely(!__pyx_t_5)) __PYX_ERR(27, 324, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_6 = NULL; + if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_5))) { + __pyx_t_6 = PyMethod_GET_SELF(__pyx_t_5); + if (likely(__pyx_t_6)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_5); + __Pyx_INCREF(__pyx_t_6); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_5, function); + } + } + if (__pyx_t_6) { + __pyx_t_4 = __Pyx_PyObject_CallOneArg(__pyx_t_5, __pyx_t_6); if (unlikely(!__pyx_t_4)) __PYX_ERR(27, 324, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + } else { + __pyx_t_4 = __Pyx_PyObject_CallNoArg(__pyx_t_5); if (unlikely(!__pyx_t_4)) __PYX_ERR(27, 324, __pyx_L1_error) + } + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(27, 324, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + if (__pyx_t_1) { + + /* "asyncpg/protocol/protocol.pyx":325 + * return + * if fut.cancelled(): + * if self.timeout_handle: # <<<<<<<<<<<<<< + * self.timeout_handle.cancel() + * self.timeout_handle = None + */ + __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_v_self->timeout_handle); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(27, 325, __pyx_L1_error) + if (__pyx_t_1) { + + /* "asyncpg/protocol/protocol.pyx":326 + * if fut.cancelled(): + * if self.timeout_handle: + * self.timeout_handle.cancel() # <<<<<<<<<<<<<< + * self.timeout_handle = None + * self._request_cancel() + */ + __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_v_self->timeout_handle, __pyx_n_s_cancel); if (unlikely(!__pyx_t_5)) __PYX_ERR(27, 326, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_6 = NULL; + if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_5))) { + __pyx_t_6 = PyMethod_GET_SELF(__pyx_t_5); + if (likely(__pyx_t_6)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_5); + __Pyx_INCREF(__pyx_t_6); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_5, function); + } + } + if (__pyx_t_6) { + __pyx_t_4 = __Pyx_PyObject_CallOneArg(__pyx_t_5, __pyx_t_6); if (unlikely(!__pyx_t_4)) __PYX_ERR(27, 326, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + } else { + __pyx_t_4 = __Pyx_PyObject_CallNoArg(__pyx_t_5); if (unlikely(!__pyx_t_4)) __PYX_ERR(27, 326, __pyx_L1_error) + } + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + + /* "asyncpg/protocol/protocol.pyx":327 + * if self.timeout_handle: + * self.timeout_handle.cancel() + * self.timeout_handle = None # <<<<<<<<<<<<<< + * self._request_cancel() + * + */ + __Pyx_INCREF(Py_None); + __Pyx_GIVEREF(Py_None); + __Pyx_GOTREF(__pyx_v_self->timeout_handle); + __Pyx_DECREF(__pyx_v_self->timeout_handle); + __pyx_v_self->timeout_handle = Py_None; + + /* "asyncpg/protocol/protocol.pyx":325 + * return + * if fut.cancelled(): + * if self.timeout_handle: # <<<<<<<<<<<<<< + * self.timeout_handle.cancel() + * self.timeout_handle = None + */ + } + + /* "asyncpg/protocol/protocol.pyx":328 + * self.timeout_handle.cancel() + * self.timeout_handle = None + * self._request_cancel() # <<<<<<<<<<<<<< + * + * def _create_future_fallback(self): + */ + __pyx_t_5 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_request_cancel); if (unlikely(!__pyx_t_5)) __PYX_ERR(27, 328, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_6 = NULL; + if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_5))) { + __pyx_t_6 = PyMethod_GET_SELF(__pyx_t_5); + if (likely(__pyx_t_6)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_5); + __Pyx_INCREF(__pyx_t_6); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_5, function); + } + } + if (__pyx_t_6) { + __pyx_t_4 = __Pyx_PyObject_CallOneArg(__pyx_t_5, __pyx_t_6); if (unlikely(!__pyx_t_4)) __PYX_ERR(27, 328, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + } else { + __pyx_t_4 = __Pyx_PyObject_CallNoArg(__pyx_t_5); if (unlikely(!__pyx_t_4)) __PYX_ERR(27, 328, __pyx_L1_error) + } + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + + /* "asyncpg/protocol/protocol.pyx":324 + * if fut is not self.waiter or self.cancel_waiter is not None: + * return + * if fut.cancelled(): # <<<<<<<<<<<<<< + * if self.timeout_handle: + * self.timeout_handle.cancel() + */ + } + + /* "asyncpg/protocol/protocol.pyx":321 + * self.waiter.set_exception(asyncio.TimeoutError()) + * + * def _on_waiter_completed(self, fut): # <<<<<<<<<<<<<< + * if fut is not self.waiter or self.cancel_waiter is not None: + * return + */ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_4); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_XDECREF(__pyx_t_6); + __Pyx_AddTraceback("asyncpg.protocol.protocol.BaseProtocol._on_waiter_completed", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "asyncpg/protocol/protocol.pyx":330 + * self._request_cancel() + * + * def _create_future_fallback(self): # <<<<<<<<<<<<<< + * return asyncio.Future(loop=self.loop) + * + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_7asyncpg_8protocol_8protocol_12BaseProtocol_45_create_future_fallback(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/ +static PyObject *__pyx_pw_7asyncpg_8protocol_8protocol_12BaseProtocol_45_create_future_fallback(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("_create_future_fallback (wrapper)", 0); + __pyx_r = __pyx_pf_7asyncpg_8protocol_8protocol_12BaseProtocol_44_create_future_fallback(((struct __pyx_obj_7asyncpg_8protocol_8protocol_BaseProtocol *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_7asyncpg_8protocol_8protocol_12BaseProtocol_44_create_future_fallback(struct __pyx_obj_7asyncpg_8protocol_8protocol_BaseProtocol *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + __Pyx_RefNannySetupContext("_create_future_fallback", 0); + + /* "asyncpg/protocol/protocol.pyx":331 + * + * def _create_future_fallback(self): + * return asyncio.Future(loop=self.loop) # <<<<<<<<<<<<<< + * + * cdef _handle_waiter_on_connection_lost(self, cause): + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_GetModuleGlobalName(__pyx_n_s_asyncio); if (unlikely(!__pyx_t_1)) __PYX_ERR(27, 331, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_Future); if (unlikely(!__pyx_t_2)) __PYX_ERR(27, 331, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_1 = PyDict_New(); if (unlikely(!__pyx_t_1)) __PYX_ERR(27, 331, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (PyDict_SetItem(__pyx_t_1, __pyx_n_s_loop, __pyx_v_self->loop) < 0) __PYX_ERR(27, 331, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_empty_tuple, __pyx_t_1); if (unlikely(!__pyx_t_3)) __PYX_ERR(27, 331, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_r = __pyx_t_3; + __pyx_t_3 = 0; + goto __pyx_L0; + + /* "asyncpg/protocol/protocol.pyx":330 + * self._request_cancel() + * + * def _create_future_fallback(self): # <<<<<<<<<<<<<< + * return asyncio.Future(loop=self.loop) + * + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_AddTraceback("asyncpg.protocol.protocol.BaseProtocol._create_future_fallback", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "asyncpg/protocol/protocol.pyx":333 + * return asyncio.Future(loop=self.loop) + * + * cdef _handle_waiter_on_connection_lost(self, cause): # <<<<<<<<<<<<<< + * if self.waiter is not None and not self.waiter.done(): + * exc = apg_exc.ConnectionDoesNotExistError( + */ + +static PyObject *__pyx_f_7asyncpg_8protocol_8protocol_12BaseProtocol__handle_waiter_on_connection_lost(struct __pyx_obj_7asyncpg_8protocol_8protocol_BaseProtocol *__pyx_v_self, PyObject *__pyx_v_cause) { + PyObject *__pyx_v_exc = NULL; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + int __pyx_t_2; + int __pyx_t_3; + PyObject *__pyx_t_4 = NULL; + PyObject *__pyx_t_5 = NULL; + PyObject *__pyx_t_6 = NULL; + PyObject *__pyx_t_7 = NULL; + __Pyx_RefNannySetupContext("_handle_waiter_on_connection_lost", 0); + + /* "asyncpg/protocol/protocol.pyx":334 + * + * cdef _handle_waiter_on_connection_lost(self, cause): + * if self.waiter is not None and not self.waiter.done(): # <<<<<<<<<<<<<< + * exc = apg_exc.ConnectionDoesNotExistError( + * 'connection was closed in the middle of ' + */ + __pyx_t_2 = (__pyx_v_self->waiter != Py_None); + __pyx_t_3 = (__pyx_t_2 != 0); + if (__pyx_t_3) { + } else { + __pyx_t_1 = __pyx_t_3; + goto __pyx_L4_bool_binop_done; + } + __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_v_self->waiter, __pyx_n_s_done); if (unlikely(!__pyx_t_5)) __PYX_ERR(27, 334, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_6 = NULL; + if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_5))) { + __pyx_t_6 = PyMethod_GET_SELF(__pyx_t_5); + if (likely(__pyx_t_6)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_5); + __Pyx_INCREF(__pyx_t_6); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_5, function); + } + } + if (__pyx_t_6) { + __pyx_t_4 = __Pyx_PyObject_CallOneArg(__pyx_t_5, __pyx_t_6); if (unlikely(!__pyx_t_4)) __PYX_ERR(27, 334, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + } else { + __pyx_t_4 = __Pyx_PyObject_CallNoArg(__pyx_t_5); if (unlikely(!__pyx_t_4)) __PYX_ERR(27, 334, __pyx_L1_error) + } + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __pyx_t_3 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_3 < 0)) __PYX_ERR(27, 334, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_2 = ((!__pyx_t_3) != 0); + __pyx_t_1 = __pyx_t_2; + __pyx_L4_bool_binop_done:; + if (__pyx_t_1) { + + /* "asyncpg/protocol/protocol.pyx":335 + * cdef _handle_waiter_on_connection_lost(self, cause): + * if self.waiter is not None and not self.waiter.done(): + * exc = apg_exc.ConnectionDoesNotExistError( # <<<<<<<<<<<<<< + * 'connection was closed in the middle of ' + * 'operation') + */ + __pyx_t_4 = __Pyx_GetModuleGlobalName(__pyx_n_s_apg_exc); if (unlikely(!__pyx_t_4)) __PYX_ERR(27, 335, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_n_s_ConnectionDoesNotExistError); if (unlikely(!__pyx_t_5)) __PYX_ERR(27, 335, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_5, __pyx_tuple__71, NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(27, 335, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __pyx_v_exc = __pyx_t_4; + __pyx_t_4 = 0; + + /* "asyncpg/protocol/protocol.pyx":338 + * 'connection was closed in the middle of ' + * 'operation') + * if cause is not None: # <<<<<<<<<<<<<< + * exc.__cause__ = cause + * self.waiter.set_exception(exc) + */ + __pyx_t_1 = (__pyx_v_cause != Py_None); + __pyx_t_2 = (__pyx_t_1 != 0); + if (__pyx_t_2) { + + /* "asyncpg/protocol/protocol.pyx":339 + * 'operation') + * if cause is not None: + * exc.__cause__ = cause # <<<<<<<<<<<<<< + * self.waiter.set_exception(exc) + * self.waiter = None + */ + if (__Pyx_PyObject_SetAttrStr(__pyx_v_exc, __pyx_n_s_cause, __pyx_v_cause) < 0) __PYX_ERR(27, 339, __pyx_L1_error) + + /* "asyncpg/protocol/protocol.pyx":338 + * 'connection was closed in the middle of ' + * 'operation') + * if cause is not None: # <<<<<<<<<<<<<< + * exc.__cause__ = cause + * self.waiter.set_exception(exc) + */ + } + + /* "asyncpg/protocol/protocol.pyx":340 + * if cause is not None: + * exc.__cause__ = cause + * self.waiter.set_exception(exc) # <<<<<<<<<<<<<< + * self.waiter = None + * + */ + __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_v_self->waiter, __pyx_n_s_set_exception); if (unlikely(!__pyx_t_5)) __PYX_ERR(27, 340, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_6 = NULL; + if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_5))) { + __pyx_t_6 = PyMethod_GET_SELF(__pyx_t_5); + if (likely(__pyx_t_6)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_5); + __Pyx_INCREF(__pyx_t_6); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_5, function); + } + } + if (!__pyx_t_6) { + __pyx_t_4 = __Pyx_PyObject_CallOneArg(__pyx_t_5, __pyx_v_exc); if (unlikely(!__pyx_t_4)) __PYX_ERR(27, 340, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + } else { + #if CYTHON_FAST_PYCALL + if (PyFunction_Check(__pyx_t_5)) { + PyObject *__pyx_temp[2] = {__pyx_t_6, __pyx_v_exc}; + __pyx_t_4 = __Pyx_PyFunction_FastCall(__pyx_t_5, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_4)) __PYX_ERR(27, 340, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_GOTREF(__pyx_t_4); + } else + #endif + #if CYTHON_FAST_PYCCALL + if (__Pyx_PyFastCFunction_Check(__pyx_t_5)) { + PyObject *__pyx_temp[2] = {__pyx_t_6, __pyx_v_exc}; + __pyx_t_4 = __Pyx_PyCFunction_FastCall(__pyx_t_5, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_4)) __PYX_ERR(27, 340, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_GOTREF(__pyx_t_4); + } else + #endif + { + __pyx_t_7 = PyTuple_New(1+1); if (unlikely(!__pyx_t_7)) __PYX_ERR(27, 340, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __Pyx_GIVEREF(__pyx_t_6); PyTuple_SET_ITEM(__pyx_t_7, 0, __pyx_t_6); __pyx_t_6 = NULL; + __Pyx_INCREF(__pyx_v_exc); + __Pyx_GIVEREF(__pyx_v_exc); + PyTuple_SET_ITEM(__pyx_t_7, 0+1, __pyx_v_exc); + __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_5, __pyx_t_7, NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(27, 340, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + } + } + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + + /* "asyncpg/protocol/protocol.pyx":334 + * + * cdef _handle_waiter_on_connection_lost(self, cause): + * if self.waiter is not None and not self.waiter.done(): # <<<<<<<<<<<<<< + * exc = apg_exc.ConnectionDoesNotExistError( + * 'connection was closed in the middle of ' + */ + } + + /* "asyncpg/protocol/protocol.pyx":341 + * exc.__cause__ = cause + * self.waiter.set_exception(exc) + * self.waiter = None # <<<<<<<<<<<<<< + * + * cdef _set_server_parameter(self, name, val): + */ + __Pyx_INCREF(Py_None); + __Pyx_GIVEREF(Py_None); + __Pyx_GOTREF(__pyx_v_self->waiter); + __Pyx_DECREF(__pyx_v_self->waiter); + __pyx_v_self->waiter = Py_None; + + /* "asyncpg/protocol/protocol.pyx":333 + * return asyncio.Future(loop=self.loop) + * + * cdef _handle_waiter_on_connection_lost(self, cause): # <<<<<<<<<<<<<< + * if self.waiter is not None and not self.waiter.done(): + * exc = apg_exc.ConnectionDoesNotExistError( + */ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_4); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_XDECREF(__pyx_t_6); + __Pyx_XDECREF(__pyx_t_7); + __Pyx_AddTraceback("asyncpg.protocol.protocol.BaseProtocol._handle_waiter_on_connection_lost", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XDECREF(__pyx_v_exc); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "asyncpg/protocol/protocol.pyx":343 + * self.waiter = None + * + * cdef _set_server_parameter(self, name, val): # <<<<<<<<<<<<<< + * self.settings.add_setting(name, val) + * + */ + +static PyObject *__pyx_f_7asyncpg_8protocol_8protocol_12BaseProtocol__set_server_parameter(struct __pyx_obj_7asyncpg_8protocol_8protocol_BaseProtocol *__pyx_v_self, PyObject *__pyx_v_name, PyObject *__pyx_v_val) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + __Pyx_RefNannySetupContext("_set_server_parameter", 0); + + /* "asyncpg/protocol/protocol.pyx":344 + * + * cdef _set_server_parameter(self, name, val): + * self.settings.add_setting(name, val) # <<<<<<<<<<<<<< + * + * cdef _ensure_clear_state(self): + */ + if (!(likely(PyUnicode_CheckExact(__pyx_v_name))||((__pyx_v_name) == Py_None)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "unicode", Py_TYPE(__pyx_v_name)->tp_name), 0))) __PYX_ERR(27, 344, __pyx_L1_error) + if (!(likely(PyUnicode_CheckExact(__pyx_v_val))||((__pyx_v_val) == Py_None)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "unicode", Py_TYPE(__pyx_v_val)->tp_name), 0))) __PYX_ERR(27, 344, __pyx_L1_error) + __pyx_t_1 = __pyx_f_7asyncpg_8protocol_8protocol_18ConnectionSettings_add_setting(__pyx_v_self->settings, ((PyObject*)__pyx_v_name), ((PyObject*)__pyx_v_val)); if (unlikely(!__pyx_t_1)) __PYX_ERR(27, 344, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "asyncpg/protocol/protocol.pyx":343 + * self.waiter = None + * + * cdef _set_server_parameter(self, name, val): # <<<<<<<<<<<<<< + * self.settings.add_setting(name, val) + * + */ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("asyncpg.protocol.protocol.BaseProtocol._set_server_parameter", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "asyncpg/protocol/protocol.pyx":346 + * self.settings.add_setting(name, val) + * + * cdef _ensure_clear_state(self): # <<<<<<<<<<<<<< + * if self.cancel_waiter is not None: + * raise apg_exc.InterfaceError( + */ + +static PyObject *__pyx_f_7asyncpg_8protocol_8protocol_12BaseProtocol__ensure_clear_state(struct __pyx_obj_7asyncpg_8protocol_8protocol_BaseProtocol *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + int __pyx_t_2; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + int __pyx_t_5; + __Pyx_RefNannySetupContext("_ensure_clear_state", 0); + + /* "asyncpg/protocol/protocol.pyx":347 + * + * cdef _ensure_clear_state(self): + * if self.cancel_waiter is not None: # <<<<<<<<<<<<<< + * raise apg_exc.InterfaceError( + * 'cannot perform operation: another operation is cancelling') + */ + __pyx_t_1 = (__pyx_v_self->cancel_waiter != Py_None); + __pyx_t_2 = (__pyx_t_1 != 0); + if (__pyx_t_2) { + + /* "asyncpg/protocol/protocol.pyx":348 + * cdef _ensure_clear_state(self): + * if self.cancel_waiter is not None: + * raise apg_exc.InterfaceError( # <<<<<<<<<<<<<< + * 'cannot perform operation: another operation is cancelling') + * if self.closing: + */ + __pyx_t_3 = __Pyx_GetModuleGlobalName(__pyx_n_s_apg_exc); if (unlikely(!__pyx_t_3)) __PYX_ERR(27, 348, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_InterfaceError); if (unlikely(!__pyx_t_4)) __PYX_ERR(27, 348, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_4, __pyx_tuple__72, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(27, 348, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_Raise(__pyx_t_3, 0, 0, 0); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __PYX_ERR(27, 348, __pyx_L1_error) + + /* "asyncpg/protocol/protocol.pyx":347 + * + * cdef _ensure_clear_state(self): + * if self.cancel_waiter is not None: # <<<<<<<<<<<<<< + * raise apg_exc.InterfaceError( + * 'cannot perform operation: another operation is cancelling') + */ + } + + /* "asyncpg/protocol/protocol.pyx":350 + * raise apg_exc.InterfaceError( + * 'cannot perform operation: another operation is cancelling') + * if self.closing: # <<<<<<<<<<<<<< + * raise apg_exc.InterfaceError( + * 'cannot perform operation: connection is closed') + */ + __pyx_t_2 = (__pyx_v_self->closing != 0); + if (__pyx_t_2) { + + /* "asyncpg/protocol/protocol.pyx":351 + * 'cannot perform operation: another operation is cancelling') + * if self.closing: + * raise apg_exc.InterfaceError( # <<<<<<<<<<<<<< + * 'cannot perform operation: connection is closed') + * if self.waiter is not None or self.timeout_handle is not None: + */ + __pyx_t_3 = __Pyx_GetModuleGlobalName(__pyx_n_s_apg_exc); if (unlikely(!__pyx_t_3)) __PYX_ERR(27, 351, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_InterfaceError); if (unlikely(!__pyx_t_4)) __PYX_ERR(27, 351, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_4, __pyx_tuple__73, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(27, 351, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_Raise(__pyx_t_3, 0, 0, 0); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __PYX_ERR(27, 351, __pyx_L1_error) + + /* "asyncpg/protocol/protocol.pyx":350 + * raise apg_exc.InterfaceError( + * 'cannot perform operation: another operation is cancelling') + * if self.closing: # <<<<<<<<<<<<<< + * raise apg_exc.InterfaceError( + * 'cannot perform operation: connection is closed') + */ + } + + /* "asyncpg/protocol/protocol.pyx":353 + * raise apg_exc.InterfaceError( + * 'cannot perform operation: connection is closed') + * if self.waiter is not None or self.timeout_handle is not None: # <<<<<<<<<<<<<< + * raise apg_exc.InterfaceError( + * 'cannot perform operation: another operation is in progress') + */ + __pyx_t_1 = (__pyx_v_self->waiter != Py_None); + __pyx_t_5 = (__pyx_t_1 != 0); + if (!__pyx_t_5) { + } else { + __pyx_t_2 = __pyx_t_5; + goto __pyx_L6_bool_binop_done; + } + __pyx_t_5 = (__pyx_v_self->timeout_handle != Py_None); + __pyx_t_1 = (__pyx_t_5 != 0); + __pyx_t_2 = __pyx_t_1; + __pyx_L6_bool_binop_done:; + if (__pyx_t_2) { + + /* "asyncpg/protocol/protocol.pyx":354 + * 'cannot perform operation: connection is closed') + * if self.waiter is not None or self.timeout_handle is not None: + * raise apg_exc.InterfaceError( # <<<<<<<<<<<<<< + * 'cannot perform operation: another operation is in progress') + * + */ + __pyx_t_3 = __Pyx_GetModuleGlobalName(__pyx_n_s_apg_exc); if (unlikely(!__pyx_t_3)) __PYX_ERR(27, 354, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_InterfaceError); if (unlikely(!__pyx_t_4)) __PYX_ERR(27, 354, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_4, __pyx_tuple__74, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(27, 354, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_Raise(__pyx_t_3, 0, 0, 0); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __PYX_ERR(27, 354, __pyx_L1_error) + + /* "asyncpg/protocol/protocol.pyx":353 + * raise apg_exc.InterfaceError( + * 'cannot perform operation: connection is closed') + * if self.waiter is not None or self.timeout_handle is not None: # <<<<<<<<<<<<<< + * raise apg_exc.InterfaceError( + * 'cannot perform operation: another operation is in progress') + */ + } + + /* "asyncpg/protocol/protocol.pyx":346 + * self.settings.add_setting(name, val) + * + * cdef _ensure_clear_state(self): # <<<<<<<<<<<<<< + * if self.cancel_waiter is not None: + * raise apg_exc.InterfaceError( + */ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_AddTraceback("asyncpg.protocol.protocol.BaseProtocol._ensure_clear_state", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "asyncpg/protocol/protocol.pyx":357 + * 'cannot perform operation: another operation is in progress') + * + * cdef _new_waiter(self, timeout): # <<<<<<<<<<<<<< + * self.waiter = self.create_future() + * if timeout is not False: + */ + +static PyObject *__pyx_f_7asyncpg_8protocol_8protocol_12BaseProtocol__new_waiter(struct __pyx_obj_7asyncpg_8protocol_8protocol_BaseProtocol *__pyx_v_self, PyObject *__pyx_v_timeout) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + int __pyx_t_4; + int __pyx_t_5; + int __pyx_t_6; + int __pyx_t_7; + PyObject *__pyx_t_8 = NULL; + __Pyx_RefNannySetupContext("_new_waiter", 0); + __Pyx_INCREF(__pyx_v_timeout); + + /* "asyncpg/protocol/protocol.pyx":358 + * + * cdef _new_waiter(self, timeout): + * self.waiter = self.create_future() # <<<<<<<<<<<<<< + * if timeout is not False: + * timeout = timeout or self.connection._command_timeout + */ + __Pyx_INCREF(__pyx_v_self->create_future); + __pyx_t_2 = __pyx_v_self->create_future; __pyx_t_3 = NULL; + if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_3)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_3); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + } + } + if (__pyx_t_3) { + __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_3); if (unlikely(!__pyx_t_1)) __PYX_ERR(27, 358, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + } else { + __pyx_t_1 = __Pyx_PyObject_CallNoArg(__pyx_t_2); if (unlikely(!__pyx_t_1)) __PYX_ERR(27, 358, __pyx_L1_error) + } + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_GIVEREF(__pyx_t_1); + __Pyx_GOTREF(__pyx_v_self->waiter); + __Pyx_DECREF(__pyx_v_self->waiter); + __pyx_v_self->waiter = __pyx_t_1; + __pyx_t_1 = 0; + + /* "asyncpg/protocol/protocol.pyx":359 + * cdef _new_waiter(self, timeout): + * self.waiter = self.create_future() + * if timeout is not False: # <<<<<<<<<<<<<< + * timeout = timeout or self.connection._command_timeout + * if timeout is not None and timeout > 0: + */ + __pyx_t_4 = (__pyx_v_timeout != Py_False); + __pyx_t_5 = (__pyx_t_4 != 0); + if (__pyx_t_5) { + + /* "asyncpg/protocol/protocol.pyx":360 + * self.waiter = self.create_future() + * if timeout is not False: + * timeout = timeout or self.connection._command_timeout # <<<<<<<<<<<<<< + * if timeout is not None and timeout > 0: + * self.timeout_handle = self.connection._loop.call_later( + */ + __pyx_t_5 = __Pyx_PyObject_IsTrue(__pyx_v_timeout); if (unlikely(__pyx_t_5 < 0)) __PYX_ERR(27, 360, __pyx_L1_error) + if (!__pyx_t_5) { + } else { + __Pyx_INCREF(__pyx_v_timeout); + __pyx_t_1 = __pyx_v_timeout; + goto __pyx_L4_bool_binop_done; + } + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_self->connection, __pyx_n_s_command_timeout); if (unlikely(!__pyx_t_2)) __PYX_ERR(27, 360, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_INCREF(__pyx_t_2); + __pyx_t_1 = __pyx_t_2; + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_L4_bool_binop_done:; + __Pyx_DECREF_SET(__pyx_v_timeout, __pyx_t_1); + __pyx_t_1 = 0; + + /* "asyncpg/protocol/protocol.pyx":361 + * if timeout is not False: + * timeout = timeout or self.connection._command_timeout + * if timeout is not None and timeout > 0: # <<<<<<<<<<<<<< + * self.timeout_handle = self.connection._loop.call_later( + * timeout, self.timeout_callback, self.waiter) + */ + __pyx_t_4 = (__pyx_v_timeout != Py_None); + __pyx_t_6 = (__pyx_t_4 != 0); + if (__pyx_t_6) { + } else { + __pyx_t_5 = __pyx_t_6; + goto __pyx_L7_bool_binop_done; + } + __pyx_t_1 = PyObject_RichCompare(__pyx_v_timeout, __pyx_int_0, Py_GT); __Pyx_XGOTREF(__pyx_t_1); if (unlikely(!__pyx_t_1)) __PYX_ERR(27, 361, __pyx_L1_error) + __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_1); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(27, 361, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_5 = __pyx_t_6; + __pyx_L7_bool_binop_done:; + if (__pyx_t_5) { + + /* "asyncpg/protocol/protocol.pyx":362 + * timeout = timeout or self.connection._command_timeout + * if timeout is not None and timeout > 0: + * self.timeout_handle = self.connection._loop.call_later( # <<<<<<<<<<<<<< + * timeout, self.timeout_callback, self.waiter) + * self.waiter.add_done_callback(self.completed_callback) + */ + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_self->connection, __pyx_n_s_loop_2); if (unlikely(!__pyx_t_2)) __PYX_ERR(27, 362, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_call_later); if (unlikely(!__pyx_t_3)) __PYX_ERR(27, 362, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "asyncpg/protocol/protocol.pyx":363 + * if timeout is not None and timeout > 0: + * self.timeout_handle = self.connection._loop.call_later( + * timeout, self.timeout_callback, self.waiter) # <<<<<<<<<<<<<< + * self.waiter.add_done_callback(self.completed_callback) + * return self.waiter + */ + __pyx_t_2 = NULL; + __pyx_t_7 = 0; + if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_3))) { + __pyx_t_2 = PyMethod_GET_SELF(__pyx_t_3); + if (likely(__pyx_t_2)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); + __Pyx_INCREF(__pyx_t_2); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_3, function); + __pyx_t_7 = 1; + } + } + #if CYTHON_FAST_PYCALL + if (PyFunction_Check(__pyx_t_3)) { + PyObject *__pyx_temp[4] = {__pyx_t_2, __pyx_v_timeout, __pyx_v_self->timeout_callback, __pyx_v_self->waiter}; + __pyx_t_1 = __Pyx_PyFunction_FastCall(__pyx_t_3, __pyx_temp+1-__pyx_t_7, 3+__pyx_t_7); if (unlikely(!__pyx_t_1)) __PYX_ERR(27, 362, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_GOTREF(__pyx_t_1); + } else + #endif + #if CYTHON_FAST_PYCCALL + if (__Pyx_PyFastCFunction_Check(__pyx_t_3)) { + PyObject *__pyx_temp[4] = {__pyx_t_2, __pyx_v_timeout, __pyx_v_self->timeout_callback, __pyx_v_self->waiter}; + __pyx_t_1 = __Pyx_PyCFunction_FastCall(__pyx_t_3, __pyx_temp+1-__pyx_t_7, 3+__pyx_t_7); if (unlikely(!__pyx_t_1)) __PYX_ERR(27, 362, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_GOTREF(__pyx_t_1); + } else + #endif + { + __pyx_t_8 = PyTuple_New(3+__pyx_t_7); if (unlikely(!__pyx_t_8)) __PYX_ERR(27, 362, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + if (__pyx_t_2) { + __Pyx_GIVEREF(__pyx_t_2); PyTuple_SET_ITEM(__pyx_t_8, 0, __pyx_t_2); __pyx_t_2 = NULL; + } + __Pyx_INCREF(__pyx_v_timeout); + __Pyx_GIVEREF(__pyx_v_timeout); + PyTuple_SET_ITEM(__pyx_t_8, 0+__pyx_t_7, __pyx_v_timeout); + __Pyx_INCREF(__pyx_v_self->timeout_callback); + __Pyx_GIVEREF(__pyx_v_self->timeout_callback); + PyTuple_SET_ITEM(__pyx_t_8, 1+__pyx_t_7, __pyx_v_self->timeout_callback); + __Pyx_INCREF(__pyx_v_self->waiter); + __Pyx_GIVEREF(__pyx_v_self->waiter); + PyTuple_SET_ITEM(__pyx_t_8, 2+__pyx_t_7, __pyx_v_self->waiter); + __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_t_8, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(27, 362, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + } + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + + /* "asyncpg/protocol/protocol.pyx":362 + * timeout = timeout or self.connection._command_timeout + * if timeout is not None and timeout > 0: + * self.timeout_handle = self.connection._loop.call_later( # <<<<<<<<<<<<<< + * timeout, self.timeout_callback, self.waiter) + * self.waiter.add_done_callback(self.completed_callback) + */ + __Pyx_GIVEREF(__pyx_t_1); + __Pyx_GOTREF(__pyx_v_self->timeout_handle); + __Pyx_DECREF(__pyx_v_self->timeout_handle); + __pyx_v_self->timeout_handle = __pyx_t_1; + __pyx_t_1 = 0; + + /* "asyncpg/protocol/protocol.pyx":361 + * if timeout is not False: + * timeout = timeout or self.connection._command_timeout + * if timeout is not None and timeout > 0: # <<<<<<<<<<<<<< + * self.timeout_handle = self.connection._loop.call_later( + * timeout, self.timeout_callback, self.waiter) + */ + } + + /* "asyncpg/protocol/protocol.pyx":359 + * cdef _new_waiter(self, timeout): + * self.waiter = self.create_future() + * if timeout is not False: # <<<<<<<<<<<<<< + * timeout = timeout or self.connection._command_timeout + * if timeout is not None and timeout > 0: + */ + } + + /* "asyncpg/protocol/protocol.pyx":364 + * self.timeout_handle = self.connection._loop.call_later( + * timeout, self.timeout_callback, self.waiter) + * self.waiter.add_done_callback(self.completed_callback) # <<<<<<<<<<<<<< + * return self.waiter + * + */ + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_self->waiter, __pyx_n_s_add_done_callback); if (unlikely(!__pyx_t_3)) __PYX_ERR(27, 364, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_8 = NULL; + if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_3))) { + __pyx_t_8 = PyMethod_GET_SELF(__pyx_t_3); + if (likely(__pyx_t_8)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); + __Pyx_INCREF(__pyx_t_8); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_3, function); + } + } + if (!__pyx_t_8) { + __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_v_self->completed_callback); if (unlikely(!__pyx_t_1)) __PYX_ERR(27, 364, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + } else { + #if CYTHON_FAST_PYCALL + if (PyFunction_Check(__pyx_t_3)) { + PyObject *__pyx_temp[2] = {__pyx_t_8, __pyx_v_self->completed_callback}; + __pyx_t_1 = __Pyx_PyFunction_FastCall(__pyx_t_3, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_1)) __PYX_ERR(27, 364, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; + __Pyx_GOTREF(__pyx_t_1); + } else + #endif + #if CYTHON_FAST_PYCCALL + if (__Pyx_PyFastCFunction_Check(__pyx_t_3)) { + PyObject *__pyx_temp[2] = {__pyx_t_8, __pyx_v_self->completed_callback}; + __pyx_t_1 = __Pyx_PyCFunction_FastCall(__pyx_t_3, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_1)) __PYX_ERR(27, 364, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; + __Pyx_GOTREF(__pyx_t_1); + } else + #endif + { + __pyx_t_2 = PyTuple_New(1+1); if (unlikely(!__pyx_t_2)) __PYX_ERR(27, 364, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_GIVEREF(__pyx_t_8); PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_t_8); __pyx_t_8 = NULL; + __Pyx_INCREF(__pyx_v_self->completed_callback); + __Pyx_GIVEREF(__pyx_v_self->completed_callback); + PyTuple_SET_ITEM(__pyx_t_2, 0+1, __pyx_v_self->completed_callback); + __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_t_2, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(27, 364, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } + } + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "asyncpg/protocol/protocol.pyx":365 + * timeout, self.timeout_callback, self.waiter) + * self.waiter.add_done_callback(self.completed_callback) + * return self.waiter # <<<<<<<<<<<<<< + * + * cdef _on_result__connect(self, object waiter): + */ + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(__pyx_v_self->waiter); + __pyx_r = __pyx_v_self->waiter; + goto __pyx_L0; + + /* "asyncpg/protocol/protocol.pyx":357 + * 'cannot perform operation: another operation is in progress') + * + * cdef _new_waiter(self, timeout): # <<<<<<<<<<<<<< + * self.waiter = self.create_future() + * if timeout is not False: + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_8); + __Pyx_AddTraceback("asyncpg.protocol.protocol.BaseProtocol._new_waiter", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XDECREF(__pyx_v_timeout); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "asyncpg/protocol/protocol.pyx":367 + * return self.waiter + * + * cdef _on_result__connect(self, object waiter): # <<<<<<<<<<<<<< + * waiter.set_result(True) + * + */ + +static PyObject *__pyx_f_7asyncpg_8protocol_8protocol_12BaseProtocol__on_result__connect(CYTHON_UNUSED struct __pyx_obj_7asyncpg_8protocol_8protocol_BaseProtocol *__pyx_v_self, PyObject *__pyx_v_waiter) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + __Pyx_RefNannySetupContext("_on_result__connect", 0); + + /* "asyncpg/protocol/protocol.pyx":368 + * + * cdef _on_result__connect(self, object waiter): + * waiter.set_result(True) # <<<<<<<<<<<<<< + * + * cdef _on_result__prepare(self, object waiter): + */ + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_waiter, __pyx_n_s_set_result); if (unlikely(!__pyx_t_1)) __PYX_ERR(27, 368, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_tuple__75, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(27, 368, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "asyncpg/protocol/protocol.pyx":367 + * return self.waiter + * + * cdef _on_result__connect(self, object waiter): # <<<<<<<<<<<<<< + * waiter.set_result(True) + * + */ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_AddTraceback("asyncpg.protocol.protocol.BaseProtocol._on_result__connect", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "asyncpg/protocol/protocol.pyx":370 + * waiter.set_result(True) + * + * cdef _on_result__prepare(self, object waiter): # <<<<<<<<<<<<<< + * if ASYNCPG_DEBUG: + * if self.statement is None: + */ + +static PyObject *__pyx_f_7asyncpg_8protocol_8protocol_12BaseProtocol__on_result__prepare(struct __pyx_obj_7asyncpg_8protocol_8protocol_BaseProtocol *__pyx_v_self, PyObject *__pyx_v_waiter) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + int __pyx_t_2; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + PyObject *__pyx_t_5 = NULL; + PyObject *__pyx_t_6 = NULL; + __Pyx_RefNannySetupContext("_on_result__prepare", 0); + + /* "asyncpg/protocol/protocol.pyx":371 + * + * cdef _on_result__prepare(self, object waiter): + * if ASYNCPG_DEBUG: # <<<<<<<<<<<<<< + * if self.statement is None: + * raise RuntimeError( + */ + __pyx_t_1 = (ASYNCPG_DEBUG != 0); + if (__pyx_t_1) { + + /* "asyncpg/protocol/protocol.pyx":372 + * cdef _on_result__prepare(self, object waiter): + * if ASYNCPG_DEBUG: + * if self.statement is None: # <<<<<<<<<<<<<< + * raise RuntimeError( + * '_on_result__prepare: statement is None') + */ + __pyx_t_1 = (((PyObject *)__pyx_v_self->statement) == Py_None); + __pyx_t_2 = (__pyx_t_1 != 0); + if (__pyx_t_2) { + + /* "asyncpg/protocol/protocol.pyx":373 + * if ASYNCPG_DEBUG: + * if self.statement is None: + * raise RuntimeError( # <<<<<<<<<<<<<< + * '_on_result__prepare: statement is None') + * + */ + __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_RuntimeError, __pyx_tuple__76, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(27, 373, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_Raise(__pyx_t_3, 0, 0, 0); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __PYX_ERR(27, 373, __pyx_L1_error) + + /* "asyncpg/protocol/protocol.pyx":372 + * cdef _on_result__prepare(self, object waiter): + * if ASYNCPG_DEBUG: + * if self.statement is None: # <<<<<<<<<<<<<< + * raise RuntimeError( + * '_on_result__prepare: statement is None') + */ + } + + /* "asyncpg/protocol/protocol.pyx":371 + * + * cdef _on_result__prepare(self, object waiter): + * if ASYNCPG_DEBUG: # <<<<<<<<<<<<<< + * if self.statement is None: + * raise RuntimeError( + */ + } + + /* "asyncpg/protocol/protocol.pyx":376 + * '_on_result__prepare: statement is None') + * + * if self.result_param_desc is not None: # <<<<<<<<<<<<<< + * self.statement._set_args_desc(self.result_param_desc) + * if self.result_row_desc is not None: + */ + __pyx_t_2 = (__pyx_v_self->__pyx_base.result_param_desc != ((PyObject*)Py_None)); + __pyx_t_1 = (__pyx_t_2 != 0); + if (__pyx_t_1) { + + /* "asyncpg/protocol/protocol.pyx":377 + * + * if self.result_param_desc is not None: + * self.statement._set_args_desc(self.result_param_desc) # <<<<<<<<<<<<<< + * if self.result_row_desc is not None: + * self.statement._set_row_desc(self.result_row_desc) + */ + __pyx_t_3 = __pyx_v_self->__pyx_base.result_param_desc; + __Pyx_INCREF(__pyx_t_3); + __pyx_t_4 = __pyx_f_7asyncpg_8protocol_8protocol_22PreparedStatementState__set_args_desc(__pyx_v_self->statement, __pyx_t_3); if (unlikely(!__pyx_t_4)) __PYX_ERR(27, 377, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + + /* "asyncpg/protocol/protocol.pyx":376 + * '_on_result__prepare: statement is None') + * + * if self.result_param_desc is not None: # <<<<<<<<<<<<<< + * self.statement._set_args_desc(self.result_param_desc) + * if self.result_row_desc is not None: + */ + } + + /* "asyncpg/protocol/protocol.pyx":378 + * if self.result_param_desc is not None: + * self.statement._set_args_desc(self.result_param_desc) + * if self.result_row_desc is not None: # <<<<<<<<<<<<<< + * self.statement._set_row_desc(self.result_row_desc) + * waiter.set_result(self.statement) + */ + __pyx_t_1 = (__pyx_v_self->__pyx_base.result_row_desc != ((PyObject*)Py_None)); + __pyx_t_2 = (__pyx_t_1 != 0); + if (__pyx_t_2) { + + /* "asyncpg/protocol/protocol.pyx":379 + * self.statement._set_args_desc(self.result_param_desc) + * if self.result_row_desc is not None: + * self.statement._set_row_desc(self.result_row_desc) # <<<<<<<<<<<<<< + * waiter.set_result(self.statement) + * + */ + __pyx_t_4 = __pyx_v_self->__pyx_base.result_row_desc; + __Pyx_INCREF(__pyx_t_4); + __pyx_t_3 = __pyx_f_7asyncpg_8protocol_8protocol_22PreparedStatementState__set_row_desc(__pyx_v_self->statement, __pyx_t_4); if (unlikely(!__pyx_t_3)) __PYX_ERR(27, 379, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + + /* "asyncpg/protocol/protocol.pyx":378 + * if self.result_param_desc is not None: + * self.statement._set_args_desc(self.result_param_desc) + * if self.result_row_desc is not None: # <<<<<<<<<<<<<< + * self.statement._set_row_desc(self.result_row_desc) + * waiter.set_result(self.statement) + */ + } + + /* "asyncpg/protocol/protocol.pyx":380 + * if self.result_row_desc is not None: + * self.statement._set_row_desc(self.result_row_desc) + * waiter.set_result(self.statement) # <<<<<<<<<<<<<< + * + * cdef _on_result__bind_and_exec(self, object waiter): + */ + __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_waiter, __pyx_n_s_set_result); if (unlikely(!__pyx_t_4)) __PYX_ERR(27, 380, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_5 = NULL; + if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_4))) { + __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_4); + if (likely(__pyx_t_5)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4); + __Pyx_INCREF(__pyx_t_5); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_4, function); + } + } + if (!__pyx_t_5) { + __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_t_4, ((PyObject *)__pyx_v_self->statement)); if (unlikely(!__pyx_t_3)) __PYX_ERR(27, 380, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + } else { + #if CYTHON_FAST_PYCALL + if (PyFunction_Check(__pyx_t_4)) { + PyObject *__pyx_temp[2] = {__pyx_t_5, ((PyObject *)__pyx_v_self->statement)}; + __pyx_t_3 = __Pyx_PyFunction_FastCall(__pyx_t_4, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_3)) __PYX_ERR(27, 380, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_GOTREF(__pyx_t_3); + } else + #endif + #if CYTHON_FAST_PYCCALL + if (__Pyx_PyFastCFunction_Check(__pyx_t_4)) { + PyObject *__pyx_temp[2] = {__pyx_t_5, ((PyObject *)__pyx_v_self->statement)}; + __pyx_t_3 = __Pyx_PyCFunction_FastCall(__pyx_t_4, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_3)) __PYX_ERR(27, 380, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_GOTREF(__pyx_t_3); + } else + #endif + { + __pyx_t_6 = PyTuple_New(1+1); if (unlikely(!__pyx_t_6)) __PYX_ERR(27, 380, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_GIVEREF(__pyx_t_5); PyTuple_SET_ITEM(__pyx_t_6, 0, __pyx_t_5); __pyx_t_5 = NULL; + __Pyx_INCREF(((PyObject *)__pyx_v_self->statement)); + __Pyx_GIVEREF(((PyObject *)__pyx_v_self->statement)); + PyTuple_SET_ITEM(__pyx_t_6, 0+1, ((PyObject *)__pyx_v_self->statement)); + __pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_4, __pyx_t_6, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(27, 380, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + } + } + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + + /* "asyncpg/protocol/protocol.pyx":370 + * waiter.set_result(True) + * + * cdef _on_result__prepare(self, object waiter): # <<<<<<<<<<<<<< + * if ASYNCPG_DEBUG: + * if self.statement is None: + */ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_XDECREF(__pyx_t_6); + __Pyx_AddTraceback("asyncpg.protocol.protocol.BaseProtocol._on_result__prepare", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "asyncpg/protocol/protocol.pyx":382 + * waiter.set_result(self.statement) + * + * cdef _on_result__bind_and_exec(self, object waiter): # <<<<<<<<<<<<<< + * if self.return_extra: + * waiter.set_result(( + */ + +static PyObject *__pyx_f_7asyncpg_8protocol_8protocol_12BaseProtocol__on_result__bind_and_exec(struct __pyx_obj_7asyncpg_8protocol_8protocol_BaseProtocol *__pyx_v_self, PyObject *__pyx_v_waiter) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + PyObject *__pyx_t_5 = NULL; + PyObject *__pyx_t_6 = NULL; + __Pyx_RefNannySetupContext("_on_result__bind_and_exec", 0); + + /* "asyncpg/protocol/protocol.pyx":383 + * + * cdef _on_result__bind_and_exec(self, object waiter): + * if self.return_extra: # <<<<<<<<<<<<<< + * waiter.set_result(( + * self.result, + */ + __pyx_t_1 = (__pyx_v_self->return_extra != 0); + if (__pyx_t_1) { + + /* "asyncpg/protocol/protocol.pyx":384 + * cdef _on_result__bind_and_exec(self, object waiter): + * if self.return_extra: + * waiter.set_result(( # <<<<<<<<<<<<<< + * self.result, + * self.result_status_msg, + */ + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_waiter, __pyx_n_s_set_result); if (unlikely(!__pyx_t_3)) __PYX_ERR(27, 384, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + + /* "asyncpg/protocol/protocol.pyx":387 + * self.result, + * self.result_status_msg, + * self.result_execute_completed)) # <<<<<<<<<<<<<< + * else: + * waiter.set_result(self.result) + */ + __pyx_t_4 = __Pyx_PyBool_FromLong(__pyx_v_self->__pyx_base.result_execute_completed); if (unlikely(!__pyx_t_4)) __PYX_ERR(27, 387, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + + /* "asyncpg/protocol/protocol.pyx":385 + * if self.return_extra: + * waiter.set_result(( + * self.result, # <<<<<<<<<<<<<< + * self.result_status_msg, + * self.result_execute_completed)) + */ + __pyx_t_5 = PyTuple_New(3); if (unlikely(!__pyx_t_5)) __PYX_ERR(27, 385, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_INCREF(__pyx_v_self->__pyx_base.result); + __Pyx_GIVEREF(__pyx_v_self->__pyx_base.result); + PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_v_self->__pyx_base.result); + __Pyx_INCREF(__pyx_v_self->__pyx_base.result_status_msg); + __Pyx_GIVEREF(__pyx_v_self->__pyx_base.result_status_msg); + PyTuple_SET_ITEM(__pyx_t_5, 1, __pyx_v_self->__pyx_base.result_status_msg); + __Pyx_GIVEREF(__pyx_t_4); + PyTuple_SET_ITEM(__pyx_t_5, 2, __pyx_t_4); + __pyx_t_4 = 0; + __pyx_t_4 = NULL; + if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_3))) { + __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_3); + if (likely(__pyx_t_4)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); + __Pyx_INCREF(__pyx_t_4); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_3, function); + } + } + if (!__pyx_t_4) { + __pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_5); if (unlikely(!__pyx_t_2)) __PYX_ERR(27, 384, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_GOTREF(__pyx_t_2); + } else { + #if CYTHON_FAST_PYCALL + if (PyFunction_Check(__pyx_t_3)) { + PyObject *__pyx_temp[2] = {__pyx_t_4, __pyx_t_5}; + __pyx_t_2 = __Pyx_PyFunction_FastCall(__pyx_t_3, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_2)) __PYX_ERR(27, 384, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + } else + #endif + #if CYTHON_FAST_PYCCALL + if (__Pyx_PyFastCFunction_Check(__pyx_t_3)) { + PyObject *__pyx_temp[2] = {__pyx_t_4, __pyx_t_5}; + __pyx_t_2 = __Pyx_PyCFunction_FastCall(__pyx_t_3, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_2)) __PYX_ERR(27, 384, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + } else + #endif + { + __pyx_t_6 = PyTuple_New(1+1); if (unlikely(!__pyx_t_6)) __PYX_ERR(27, 384, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_GIVEREF(__pyx_t_4); PyTuple_SET_ITEM(__pyx_t_6, 0, __pyx_t_4); __pyx_t_4 = NULL; + __Pyx_GIVEREF(__pyx_t_5); + PyTuple_SET_ITEM(__pyx_t_6, 0+1, __pyx_t_5); + __pyx_t_5 = 0; + __pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_t_6, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(27, 384, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + } + } + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "asyncpg/protocol/protocol.pyx":383 + * + * cdef _on_result__bind_and_exec(self, object waiter): + * if self.return_extra: # <<<<<<<<<<<<<< + * waiter.set_result(( + * self.result, + */ + goto __pyx_L3; + } + + /* "asyncpg/protocol/protocol.pyx":389 + * self.result_execute_completed)) + * else: + * waiter.set_result(self.result) # <<<<<<<<<<<<<< + * + * cdef _on_result__bind(self, object waiter): + */ + /*else*/ { + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_waiter, __pyx_n_s_set_result); if (unlikely(!__pyx_t_3)) __PYX_ERR(27, 389, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_6 = NULL; + if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_3))) { + __pyx_t_6 = PyMethod_GET_SELF(__pyx_t_3); + if (likely(__pyx_t_6)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); + __Pyx_INCREF(__pyx_t_6); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_3, function); + } + } + if (!__pyx_t_6) { + __pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_v_self->__pyx_base.result); if (unlikely(!__pyx_t_2)) __PYX_ERR(27, 389, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + } else { + #if CYTHON_FAST_PYCALL + if (PyFunction_Check(__pyx_t_3)) { + PyObject *__pyx_temp[2] = {__pyx_t_6, __pyx_v_self->__pyx_base.result}; + __pyx_t_2 = __Pyx_PyFunction_FastCall(__pyx_t_3, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_2)) __PYX_ERR(27, 389, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_GOTREF(__pyx_t_2); + } else + #endif + #if CYTHON_FAST_PYCCALL + if (__Pyx_PyFastCFunction_Check(__pyx_t_3)) { + PyObject *__pyx_temp[2] = {__pyx_t_6, __pyx_v_self->__pyx_base.result}; + __pyx_t_2 = __Pyx_PyCFunction_FastCall(__pyx_t_3, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_2)) __PYX_ERR(27, 389, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_GOTREF(__pyx_t_2); + } else + #endif + { + __pyx_t_5 = PyTuple_New(1+1); if (unlikely(!__pyx_t_5)) __PYX_ERR(27, 389, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_GIVEREF(__pyx_t_6); PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_t_6); __pyx_t_6 = NULL; + __Pyx_INCREF(__pyx_v_self->__pyx_base.result); + __Pyx_GIVEREF(__pyx_v_self->__pyx_base.result); + PyTuple_SET_ITEM(__pyx_t_5, 0+1, __pyx_v_self->__pyx_base.result); + __pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_t_5, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(27, 389, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + } + } + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } + __pyx_L3:; + + /* "asyncpg/protocol/protocol.pyx":382 + * waiter.set_result(self.statement) + * + * cdef _on_result__bind_and_exec(self, object waiter): # <<<<<<<<<<<<<< + * if self.return_extra: + * waiter.set_result(( + */ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_XDECREF(__pyx_t_6); + __Pyx_AddTraceback("asyncpg.protocol.protocol.BaseProtocol._on_result__bind_and_exec", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "asyncpg/protocol/protocol.pyx":391 + * waiter.set_result(self.result) + * + * cdef _on_result__bind(self, object waiter): # <<<<<<<<<<<<<< + * waiter.set_result(self.result) + * + */ + +static PyObject *__pyx_f_7asyncpg_8protocol_8protocol_12BaseProtocol__on_result__bind(struct __pyx_obj_7asyncpg_8protocol_8protocol_BaseProtocol *__pyx_v_self, PyObject *__pyx_v_waiter) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + __Pyx_RefNannySetupContext("_on_result__bind", 0); + + /* "asyncpg/protocol/protocol.pyx":392 + * + * cdef _on_result__bind(self, object waiter): + * waiter.set_result(self.result) # <<<<<<<<<<<<<< + * + * cdef _on_result__close_stmt_or_portal(self, object waiter): + */ + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_waiter, __pyx_n_s_set_result); if (unlikely(!__pyx_t_2)) __PYX_ERR(27, 392, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = NULL; + if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_3)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_3); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + } + } + if (!__pyx_t_3) { + __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_v_self->__pyx_base.result); if (unlikely(!__pyx_t_1)) __PYX_ERR(27, 392, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + } else { + #if CYTHON_FAST_PYCALL + if (PyFunction_Check(__pyx_t_2)) { + PyObject *__pyx_temp[2] = {__pyx_t_3, __pyx_v_self->__pyx_base.result}; + __pyx_t_1 = __Pyx_PyFunction_FastCall(__pyx_t_2, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_1)) __PYX_ERR(27, 392, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_GOTREF(__pyx_t_1); + } else + #endif + #if CYTHON_FAST_PYCCALL + if (__Pyx_PyFastCFunction_Check(__pyx_t_2)) { + PyObject *__pyx_temp[2] = {__pyx_t_3, __pyx_v_self->__pyx_base.result}; + __pyx_t_1 = __Pyx_PyCFunction_FastCall(__pyx_t_2, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_1)) __PYX_ERR(27, 392, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_GOTREF(__pyx_t_1); + } else + #endif + { + __pyx_t_4 = PyTuple_New(1+1); if (unlikely(!__pyx_t_4)) __PYX_ERR(27, 392, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_GIVEREF(__pyx_t_3); PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_3); __pyx_t_3 = NULL; + __Pyx_INCREF(__pyx_v_self->__pyx_base.result); + __Pyx_GIVEREF(__pyx_v_self->__pyx_base.result); + PyTuple_SET_ITEM(__pyx_t_4, 0+1, __pyx_v_self->__pyx_base.result); + __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_t_4, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(27, 392, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + } + } + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "asyncpg/protocol/protocol.pyx":391 + * waiter.set_result(self.result) + * + * cdef _on_result__bind(self, object waiter): # <<<<<<<<<<<<<< + * waiter.set_result(self.result) + * + */ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_AddTraceback("asyncpg.protocol.protocol.BaseProtocol._on_result__bind", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "asyncpg/protocol/protocol.pyx":394 + * waiter.set_result(self.result) + * + * cdef _on_result__close_stmt_or_portal(self, object waiter): # <<<<<<<<<<<<<< + * waiter.set_result(self.result) + * + */ + +static PyObject *__pyx_f_7asyncpg_8protocol_8protocol_12BaseProtocol__on_result__close_stmt_or_portal(struct __pyx_obj_7asyncpg_8protocol_8protocol_BaseProtocol *__pyx_v_self, PyObject *__pyx_v_waiter) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + __Pyx_RefNannySetupContext("_on_result__close_stmt_or_portal", 0); + + /* "asyncpg/protocol/protocol.pyx":395 + * + * cdef _on_result__close_stmt_or_portal(self, object waiter): + * waiter.set_result(self.result) # <<<<<<<<<<<<<< + * + * cdef _on_result__simple_query(self, object waiter): + */ + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_waiter, __pyx_n_s_set_result); if (unlikely(!__pyx_t_2)) __PYX_ERR(27, 395, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = NULL; + if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_3)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_3); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + } + } + if (!__pyx_t_3) { + __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_v_self->__pyx_base.result); if (unlikely(!__pyx_t_1)) __PYX_ERR(27, 395, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + } else { + #if CYTHON_FAST_PYCALL + if (PyFunction_Check(__pyx_t_2)) { + PyObject *__pyx_temp[2] = {__pyx_t_3, __pyx_v_self->__pyx_base.result}; + __pyx_t_1 = __Pyx_PyFunction_FastCall(__pyx_t_2, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_1)) __PYX_ERR(27, 395, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_GOTREF(__pyx_t_1); + } else + #endif + #if CYTHON_FAST_PYCCALL + if (__Pyx_PyFastCFunction_Check(__pyx_t_2)) { + PyObject *__pyx_temp[2] = {__pyx_t_3, __pyx_v_self->__pyx_base.result}; + __pyx_t_1 = __Pyx_PyCFunction_FastCall(__pyx_t_2, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_1)) __PYX_ERR(27, 395, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_GOTREF(__pyx_t_1); + } else + #endif + { + __pyx_t_4 = PyTuple_New(1+1); if (unlikely(!__pyx_t_4)) __PYX_ERR(27, 395, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_GIVEREF(__pyx_t_3); PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_3); __pyx_t_3 = NULL; + __Pyx_INCREF(__pyx_v_self->__pyx_base.result); + __Pyx_GIVEREF(__pyx_v_self->__pyx_base.result); + PyTuple_SET_ITEM(__pyx_t_4, 0+1, __pyx_v_self->__pyx_base.result); + __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_t_4, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(27, 395, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + } + } + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "asyncpg/protocol/protocol.pyx":394 + * waiter.set_result(self.result) + * + * cdef _on_result__close_stmt_or_portal(self, object waiter): # <<<<<<<<<<<<<< + * waiter.set_result(self.result) + * + */ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_AddTraceback("asyncpg.protocol.protocol.BaseProtocol._on_result__close_stmt_or_portal", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "asyncpg/protocol/protocol.pyx":397 + * waiter.set_result(self.result) + * + * cdef _on_result__simple_query(self, object waiter): # <<<<<<<<<<<<<< + * waiter.set_result(self.result_status_msg.decode(self.encoding)) + * + */ + +static PyObject *__pyx_f_7asyncpg_8protocol_8protocol_12BaseProtocol__on_result__simple_query(struct __pyx_obj_7asyncpg_8protocol_8protocol_BaseProtocol *__pyx_v_self, PyObject *__pyx_v_waiter) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + PyObject *__pyx_t_5 = NULL; + PyObject *__pyx_t_6 = NULL; + __Pyx_RefNannySetupContext("_on_result__simple_query", 0); + + /* "asyncpg/protocol/protocol.pyx":398 + * + * cdef _on_result__simple_query(self, object waiter): + * waiter.set_result(self.result_status_msg.decode(self.encoding)) # <<<<<<<<<<<<<< + * + * cdef _decode_row(self, const char* buf, ssize_t buf_len): + */ + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_waiter, __pyx_n_s_set_result); if (unlikely(!__pyx_t_2)) __PYX_ERR(27, 398, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_self->__pyx_base.result_status_msg, __pyx_n_s_decode); if (unlikely(!__pyx_t_4)) __PYX_ERR(27, 398, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_5 = NULL; + if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_4))) { + __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_4); + if (likely(__pyx_t_5)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4); + __Pyx_INCREF(__pyx_t_5); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_4, function); + } + } + if (!__pyx_t_5) { + __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_v_self->__pyx_base.encoding); if (unlikely(!__pyx_t_3)) __PYX_ERR(27, 398, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + } else { + #if CYTHON_FAST_PYCALL + if (PyFunction_Check(__pyx_t_4)) { + PyObject *__pyx_temp[2] = {__pyx_t_5, __pyx_v_self->__pyx_base.encoding}; + __pyx_t_3 = __Pyx_PyFunction_FastCall(__pyx_t_4, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_3)) __PYX_ERR(27, 398, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_GOTREF(__pyx_t_3); + } else + #endif + #if CYTHON_FAST_PYCCALL + if (__Pyx_PyFastCFunction_Check(__pyx_t_4)) { + PyObject *__pyx_temp[2] = {__pyx_t_5, __pyx_v_self->__pyx_base.encoding}; + __pyx_t_3 = __Pyx_PyCFunction_FastCall(__pyx_t_4, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_3)) __PYX_ERR(27, 398, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_GOTREF(__pyx_t_3); + } else + #endif + { + __pyx_t_6 = PyTuple_New(1+1); if (unlikely(!__pyx_t_6)) __PYX_ERR(27, 398, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_GIVEREF(__pyx_t_5); PyTuple_SET_ITEM(__pyx_t_6, 0, __pyx_t_5); __pyx_t_5 = NULL; + __Pyx_INCREF(__pyx_v_self->__pyx_base.encoding); + __Pyx_GIVEREF(__pyx_v_self->__pyx_base.encoding); + PyTuple_SET_ITEM(__pyx_t_6, 0+1, __pyx_v_self->__pyx_base.encoding); + __pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_4, __pyx_t_6, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(27, 398, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + } + } + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_4 = NULL; + if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_4)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_4); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + } + } + if (!__pyx_t_4) { + __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_3); if (unlikely(!__pyx_t_1)) __PYX_ERR(27, 398, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_GOTREF(__pyx_t_1); + } else { + #if CYTHON_FAST_PYCALL + if (PyFunction_Check(__pyx_t_2)) { + PyObject *__pyx_temp[2] = {__pyx_t_4, __pyx_t_3}; + __pyx_t_1 = __Pyx_PyFunction_FastCall(__pyx_t_2, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_1)) __PYX_ERR(27, 398, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + } else + #endif + #if CYTHON_FAST_PYCCALL + if (__Pyx_PyFastCFunction_Check(__pyx_t_2)) { + PyObject *__pyx_temp[2] = {__pyx_t_4, __pyx_t_3}; + __pyx_t_1 = __Pyx_PyCFunction_FastCall(__pyx_t_2, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_1)) __PYX_ERR(27, 398, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + } else + #endif + { + __pyx_t_6 = PyTuple_New(1+1); if (unlikely(!__pyx_t_6)) __PYX_ERR(27, 398, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_GIVEREF(__pyx_t_4); PyTuple_SET_ITEM(__pyx_t_6, 0, __pyx_t_4); __pyx_t_4 = NULL; + __Pyx_GIVEREF(__pyx_t_3); + PyTuple_SET_ITEM(__pyx_t_6, 0+1, __pyx_t_3); + __pyx_t_3 = 0; + __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_t_6, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(27, 398, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + } + } + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "asyncpg/protocol/protocol.pyx":397 + * waiter.set_result(self.result) + * + * cdef _on_result__simple_query(self, object waiter): # <<<<<<<<<<<<<< + * waiter.set_result(self.result_status_msg.decode(self.encoding)) + * + */ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_XDECREF(__pyx_t_6); + __Pyx_AddTraceback("asyncpg.protocol.protocol.BaseProtocol._on_result__simple_query", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "asyncpg/protocol/protocol.pyx":400 + * waiter.set_result(self.result_status_msg.decode(self.encoding)) + * + * cdef _decode_row(self, const char* buf, ssize_t buf_len): # <<<<<<<<<<<<<< + * if ASYNCPG_DEBUG: + * if self.statement is None: + */ + +static PyObject *__pyx_f_7asyncpg_8protocol_8protocol_12BaseProtocol__decode_row(struct __pyx_obj_7asyncpg_8protocol_8protocol_BaseProtocol *__pyx_v_self, char const *__pyx_v_buf, Py_ssize_t __pyx_v_buf_len) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + int __pyx_t_2; + PyObject *__pyx_t_3 = NULL; + __Pyx_RefNannySetupContext("_decode_row", 0); + + /* "asyncpg/protocol/protocol.pyx":401 + * + * cdef _decode_row(self, const char* buf, ssize_t buf_len): + * if ASYNCPG_DEBUG: # <<<<<<<<<<<<<< + * if self.statement is None: + * raise RuntimeError( + */ + __pyx_t_1 = (ASYNCPG_DEBUG != 0); + if (__pyx_t_1) { + + /* "asyncpg/protocol/protocol.pyx":402 + * cdef _decode_row(self, const char* buf, ssize_t buf_len): + * if ASYNCPG_DEBUG: + * if self.statement is None: # <<<<<<<<<<<<<< + * raise RuntimeError( + * '_decode_row: statement is None') + */ + __pyx_t_1 = (((PyObject *)__pyx_v_self->statement) == Py_None); + __pyx_t_2 = (__pyx_t_1 != 0); + if (__pyx_t_2) { + + /* "asyncpg/protocol/protocol.pyx":403 + * if ASYNCPG_DEBUG: + * if self.statement is None: + * raise RuntimeError( # <<<<<<<<<<<<<< + * '_decode_row: statement is None') + * + */ + __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_RuntimeError, __pyx_tuple__77, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(27, 403, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_Raise(__pyx_t_3, 0, 0, 0); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __PYX_ERR(27, 403, __pyx_L1_error) + + /* "asyncpg/protocol/protocol.pyx":402 + * cdef _decode_row(self, const char* buf, ssize_t buf_len): + * if ASYNCPG_DEBUG: + * if self.statement is None: # <<<<<<<<<<<<<< + * raise RuntimeError( + * '_decode_row: statement is None') + */ + } + + /* "asyncpg/protocol/protocol.pyx":401 + * + * cdef _decode_row(self, const char* buf, ssize_t buf_len): + * if ASYNCPG_DEBUG: # <<<<<<<<<<<<<< + * if self.statement is None: + * raise RuntimeError( + */ + } + + /* "asyncpg/protocol/protocol.pyx":406 + * '_decode_row: statement is None') + * + * return self.statement._decode_row(buf, buf_len) # <<<<<<<<<<<<<< + * + * cdef _dispatch_result(self): + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_3 = __pyx_f_7asyncpg_8protocol_8protocol_22PreparedStatementState__decode_row(__pyx_v_self->statement, __pyx_v_buf, __pyx_v_buf_len); if (unlikely(!__pyx_t_3)) __PYX_ERR(27, 406, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_r = __pyx_t_3; + __pyx_t_3 = 0; + goto __pyx_L0; + + /* "asyncpg/protocol/protocol.pyx":400 + * waiter.set_result(self.result_status_msg.decode(self.encoding)) + * + * cdef _decode_row(self, const char* buf, ssize_t buf_len): # <<<<<<<<<<<<<< + * if ASYNCPG_DEBUG: + * if self.statement is None: + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_3); + __Pyx_AddTraceback("asyncpg.protocol.protocol.BaseProtocol._decode_row", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "asyncpg/protocol/protocol.pyx":408 + * return self.statement._decode_row(buf, buf_len) + * + * cdef _dispatch_result(self): # <<<<<<<<<<<<<< + * waiter = self.waiter + * self.waiter = None + */ + +static PyObject *__pyx_f_7asyncpg_8protocol_8protocol_12BaseProtocol__dispatch_result(struct __pyx_obj_7asyncpg_8protocol_8protocol_BaseProtocol *__pyx_v_self) { + PyObject *__pyx_v_waiter = NULL; + PyObject *__pyx_v_exc = NULL; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_t_2; + int __pyx_t_3; + PyObject *__pyx_t_4 = NULL; + PyObject *__pyx_t_5 = NULL; + PyObject *__pyx_t_6 = NULL; + PyObject *__pyx_t_7 = NULL; + PyObject *__pyx_t_8 = NULL; + PyObject *__pyx_t_9 = NULL; + PyObject *__pyx_t_10 = NULL; + int __pyx_t_11; + PyObject *__pyx_t_12 = NULL; + PyObject *__pyx_t_13 = NULL; + int __pyx_t_14; + char const *__pyx_t_15; + PyObject *__pyx_t_16 = NULL; + PyObject *__pyx_t_17 = NULL; + PyObject *__pyx_t_18 = NULL; + PyObject *__pyx_t_19 = NULL; + PyObject *__pyx_t_20 = NULL; + PyObject *__pyx_t_21 = NULL; + __Pyx_RefNannySetupContext("_dispatch_result", 0); + + /* "asyncpg/protocol/protocol.pyx":409 + * + * cdef _dispatch_result(self): + * waiter = self.waiter # <<<<<<<<<<<<<< + * self.waiter = None + * + */ + __pyx_t_1 = __pyx_v_self->waiter; + __Pyx_INCREF(__pyx_t_1); + __pyx_v_waiter = __pyx_t_1; + __pyx_t_1 = 0; + + /* "asyncpg/protocol/protocol.pyx":410 + * cdef _dispatch_result(self): + * waiter = self.waiter + * self.waiter = None # <<<<<<<<<<<<<< + * + * if ASYNCPG_DEBUG: + */ + __Pyx_INCREF(Py_None); + __Pyx_GIVEREF(Py_None); + __Pyx_GOTREF(__pyx_v_self->waiter); + __Pyx_DECREF(__pyx_v_self->waiter); + __pyx_v_self->waiter = Py_None; + + /* "asyncpg/protocol/protocol.pyx":412 + * self.waiter = None + * + * if ASYNCPG_DEBUG: # <<<<<<<<<<<<<< + * if waiter is None: + * raise RuntimeError('_on_result: waiter is None') + */ + __pyx_t_2 = (ASYNCPG_DEBUG != 0); + if (__pyx_t_2) { + + /* "asyncpg/protocol/protocol.pyx":413 + * + * if ASYNCPG_DEBUG: + * if waiter is None: # <<<<<<<<<<<<<< + * raise RuntimeError('_on_result: waiter is None') + * + */ + __pyx_t_2 = (__pyx_v_waiter == Py_None); + __pyx_t_3 = (__pyx_t_2 != 0); + if (__pyx_t_3) { + + /* "asyncpg/protocol/protocol.pyx":414 + * if ASYNCPG_DEBUG: + * if waiter is None: + * raise RuntimeError('_on_result: waiter is None') # <<<<<<<<<<<<<< + * + * if waiter.cancelled(): + */ + __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_RuntimeError, __pyx_tuple__78, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(27, 414, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_Raise(__pyx_t_1, 0, 0, 0); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __PYX_ERR(27, 414, __pyx_L1_error) + + /* "asyncpg/protocol/protocol.pyx":413 + * + * if ASYNCPG_DEBUG: + * if waiter is None: # <<<<<<<<<<<<<< + * raise RuntimeError('_on_result: waiter is None') + * + */ + } + + /* "asyncpg/protocol/protocol.pyx":412 + * self.waiter = None + * + * if ASYNCPG_DEBUG: # <<<<<<<<<<<<<< + * if waiter is None: + * raise RuntimeError('_on_result: waiter is None') + */ + } + + /* "asyncpg/protocol/protocol.pyx":416 + * raise RuntimeError('_on_result: waiter is None') + * + * if waiter.cancelled(): # <<<<<<<<<<<<<< + * return + * + */ + __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_waiter, __pyx_n_s_cancelled); if (unlikely(!__pyx_t_4)) __PYX_ERR(27, 416, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_5 = NULL; + if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_4))) { + __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_4); + if (likely(__pyx_t_5)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4); + __Pyx_INCREF(__pyx_t_5); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_4, function); + } + } + if (__pyx_t_5) { + __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_t_5); if (unlikely(!__pyx_t_1)) __PYX_ERR(27, 416, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + } else { + __pyx_t_1 = __Pyx_PyObject_CallNoArg(__pyx_t_4); if (unlikely(!__pyx_t_1)) __PYX_ERR(27, 416, __pyx_L1_error) + } + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_3 = __Pyx_PyObject_IsTrue(__pyx_t_1); if (unlikely(__pyx_t_3 < 0)) __PYX_ERR(27, 416, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + if (__pyx_t_3) { + + /* "asyncpg/protocol/protocol.pyx":417 + * + * if waiter.cancelled(): + * return # <<<<<<<<<<<<<< + * + * if waiter.done(): + */ + __Pyx_XDECREF(__pyx_r); + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + + /* "asyncpg/protocol/protocol.pyx":416 + * raise RuntimeError('_on_result: waiter is None') + * + * if waiter.cancelled(): # <<<<<<<<<<<<<< + * return + * + */ + } + + /* "asyncpg/protocol/protocol.pyx":419 + * return + * + * if waiter.done(): # <<<<<<<<<<<<<< + * raise RuntimeError('_on_result: waiter is done') + * + */ + __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_waiter, __pyx_n_s_done); if (unlikely(!__pyx_t_4)) __PYX_ERR(27, 419, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_5 = NULL; + if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_4))) { + __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_4); + if (likely(__pyx_t_5)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4); + __Pyx_INCREF(__pyx_t_5); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_4, function); + } + } + if (__pyx_t_5) { + __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_t_5); if (unlikely(!__pyx_t_1)) __PYX_ERR(27, 419, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + } else { + __pyx_t_1 = __Pyx_PyObject_CallNoArg(__pyx_t_4); if (unlikely(!__pyx_t_1)) __PYX_ERR(27, 419, __pyx_L1_error) + } + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_3 = __Pyx_PyObject_IsTrue(__pyx_t_1); if (unlikely(__pyx_t_3 < 0)) __PYX_ERR(27, 419, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + if (__pyx_t_3) { + + /* "asyncpg/protocol/protocol.pyx":420 + * + * if waiter.done(): + * raise RuntimeError('_on_result: waiter is done') # <<<<<<<<<<<<<< + * + * if self.result_type == RESULT_FAILED: + */ + __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_RuntimeError, __pyx_tuple__79, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(27, 420, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_Raise(__pyx_t_1, 0, 0, 0); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __PYX_ERR(27, 420, __pyx_L1_error) + + /* "asyncpg/protocol/protocol.pyx":419 + * return + * + * if waiter.done(): # <<<<<<<<<<<<<< + * raise RuntimeError('_on_result: waiter is done') + * + */ + } + + /* "asyncpg/protocol/protocol.pyx":422 + * raise RuntimeError('_on_result: waiter is done') + * + * if self.result_type == RESULT_FAILED: # <<<<<<<<<<<<<< + * if isinstance(self.result, dict): + * exc = apg_exc_base.PostgresMessage.new( + */ + __pyx_t_3 = ((__pyx_v_self->__pyx_base.result_type == __pyx_e_7asyncpg_8protocol_8protocol_RESULT_FAILED) != 0); + if (__pyx_t_3) { + + /* "asyncpg/protocol/protocol.pyx":423 + * + * if self.result_type == RESULT_FAILED: + * if isinstance(self.result, dict): # <<<<<<<<<<<<<< + * exc = apg_exc_base.PostgresMessage.new( + * self.result, query=self.last_query) + */ + __pyx_t_1 = __pyx_v_self->__pyx_base.result; + __Pyx_INCREF(__pyx_t_1); + __pyx_t_3 = PyDict_Check(__pyx_t_1); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_2 = (__pyx_t_3 != 0); + if (__pyx_t_2) { + + /* "asyncpg/protocol/protocol.pyx":424 + * if self.result_type == RESULT_FAILED: + * if isinstance(self.result, dict): + * exc = apg_exc_base.PostgresMessage.new( # <<<<<<<<<<<<<< + * self.result, query=self.last_query) + * else: + */ + __pyx_t_1 = __Pyx_GetModuleGlobalName(__pyx_n_s_apg_exc_base); if (unlikely(!__pyx_t_1)) __PYX_ERR(27, 424, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_PostgresMessage); if (unlikely(!__pyx_t_4)) __PYX_ERR(27, 424, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_n_s_new); if (unlikely(!__pyx_t_1)) __PYX_ERR(27, 424, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + + /* "asyncpg/protocol/protocol.pyx":425 + * if isinstance(self.result, dict): + * exc = apg_exc_base.PostgresMessage.new( + * self.result, query=self.last_query) # <<<<<<<<<<<<<< + * else: + * exc = self.result + */ + __pyx_t_4 = PyTuple_New(1); if (unlikely(!__pyx_t_4)) __PYX_ERR(27, 424, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_INCREF(__pyx_v_self->__pyx_base.result); + __Pyx_GIVEREF(__pyx_v_self->__pyx_base.result); + PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_v_self->__pyx_base.result); + __pyx_t_5 = PyDict_New(); if (unlikely(!__pyx_t_5)) __PYX_ERR(27, 425, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + if (PyDict_SetItem(__pyx_t_5, __pyx_n_s_query, __pyx_v_self->last_query) < 0) __PYX_ERR(27, 425, __pyx_L1_error) + + /* "asyncpg/protocol/protocol.pyx":424 + * if self.result_type == RESULT_FAILED: + * if isinstance(self.result, dict): + * exc = apg_exc_base.PostgresMessage.new( # <<<<<<<<<<<<<< + * self.result, query=self.last_query) + * else: + */ + __pyx_t_6 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_t_4, __pyx_t_5); if (unlikely(!__pyx_t_6)) __PYX_ERR(27, 424, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __pyx_v_exc = __pyx_t_6; + __pyx_t_6 = 0; + + /* "asyncpg/protocol/protocol.pyx":423 + * + * if self.result_type == RESULT_FAILED: + * if isinstance(self.result, dict): # <<<<<<<<<<<<<< + * exc = apg_exc_base.PostgresMessage.new( + * self.result, query=self.last_query) + */ + goto __pyx_L8; + } + + /* "asyncpg/protocol/protocol.pyx":427 + * self.result, query=self.last_query) + * else: + * exc = self.result # <<<<<<<<<<<<<< + * waiter.set_exception(exc) + * return + */ + /*else*/ { + __pyx_t_6 = __pyx_v_self->__pyx_base.result; + __Pyx_INCREF(__pyx_t_6); + __pyx_v_exc = __pyx_t_6; + __pyx_t_6 = 0; + } + __pyx_L8:; + + /* "asyncpg/protocol/protocol.pyx":428 + * else: + * exc = self.result + * waiter.set_exception(exc) # <<<<<<<<<<<<<< + * return + * + */ + __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_v_waiter, __pyx_n_s_set_exception); if (unlikely(!__pyx_t_5)) __PYX_ERR(27, 428, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_4 = NULL; + if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_5))) { + __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_5); + if (likely(__pyx_t_4)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_5); + __Pyx_INCREF(__pyx_t_4); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_5, function); + } + } + if (!__pyx_t_4) { + __pyx_t_6 = __Pyx_PyObject_CallOneArg(__pyx_t_5, __pyx_v_exc); if (unlikely(!__pyx_t_6)) __PYX_ERR(27, 428, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + } else { + #if CYTHON_FAST_PYCALL + if (PyFunction_Check(__pyx_t_5)) { + PyObject *__pyx_temp[2] = {__pyx_t_4, __pyx_v_exc}; + __pyx_t_6 = __Pyx_PyFunction_FastCall(__pyx_t_5, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_6)) __PYX_ERR(27, 428, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_GOTREF(__pyx_t_6); + } else + #endif + #if CYTHON_FAST_PYCCALL + if (__Pyx_PyFastCFunction_Check(__pyx_t_5)) { + PyObject *__pyx_temp[2] = {__pyx_t_4, __pyx_v_exc}; + __pyx_t_6 = __Pyx_PyCFunction_FastCall(__pyx_t_5, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_6)) __PYX_ERR(27, 428, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_GOTREF(__pyx_t_6); + } else + #endif + { + __pyx_t_1 = PyTuple_New(1+1); if (unlikely(!__pyx_t_1)) __PYX_ERR(27, 428, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_GIVEREF(__pyx_t_4); PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_t_4); __pyx_t_4 = NULL; + __Pyx_INCREF(__pyx_v_exc); + __Pyx_GIVEREF(__pyx_v_exc); + PyTuple_SET_ITEM(__pyx_t_1, 0+1, __pyx_v_exc); + __pyx_t_6 = __Pyx_PyObject_Call(__pyx_t_5, __pyx_t_1, NULL); if (unlikely(!__pyx_t_6)) __PYX_ERR(27, 428, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + } + } + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + + /* "asyncpg/protocol/protocol.pyx":429 + * exc = self.result + * waiter.set_exception(exc) + * return # <<<<<<<<<<<<<< + * + * try: + */ + __Pyx_XDECREF(__pyx_r); + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + + /* "asyncpg/protocol/protocol.pyx":422 + * raise RuntimeError('_on_result: waiter is done') + * + * if self.result_type == RESULT_FAILED: # <<<<<<<<<<<<<< + * if isinstance(self.result, dict): + * exc = apg_exc_base.PostgresMessage.new( + */ + } + + /* "asyncpg/protocol/protocol.pyx":431 + * return + * + * try: # <<<<<<<<<<<<<< + * if self.state == PROTOCOL_AUTH: + * self._on_result__connect(waiter) + */ + { + __Pyx_PyThreadState_declare + __Pyx_PyThreadState_assign + __Pyx_ExceptionSave(&__pyx_t_7, &__pyx_t_8, &__pyx_t_9); + __Pyx_XGOTREF(__pyx_t_7); + __Pyx_XGOTREF(__pyx_t_8); + __Pyx_XGOTREF(__pyx_t_9); + /*try:*/ { + + /* "asyncpg/protocol/protocol.pyx":432 + * + * try: + * if self.state == PROTOCOL_AUTH: # <<<<<<<<<<<<<< + * self._on_result__connect(waiter) + * + */ + switch (__pyx_v_self->__pyx_base.state) { + case __pyx_e_7asyncpg_8protocol_8protocol_PROTOCOL_AUTH: + + /* "asyncpg/protocol/protocol.pyx":433 + * try: + * if self.state == PROTOCOL_AUTH: + * self._on_result__connect(waiter) # <<<<<<<<<<<<<< + * + * elif self.state == PROTOCOL_PREPARE: + */ + __pyx_t_6 = ((struct __pyx_vtabstruct_7asyncpg_8protocol_8protocol_BaseProtocol *)__pyx_v_self->__pyx_base.__pyx_vtab)->_on_result__connect(__pyx_v_self, __pyx_v_waiter); if (unlikely(!__pyx_t_6)) __PYX_ERR(27, 433, __pyx_L9_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + + /* "asyncpg/protocol/protocol.pyx":432 + * + * try: + * if self.state == PROTOCOL_AUTH: # <<<<<<<<<<<<<< + * self._on_result__connect(waiter) + * + */ + break; + + /* "asyncpg/protocol/protocol.pyx":435 + * self._on_result__connect(waiter) + * + * elif self.state == PROTOCOL_PREPARE: # <<<<<<<<<<<<<< + * self._on_result__prepare(waiter) + * + */ + case __pyx_e_7asyncpg_8protocol_8protocol_PROTOCOL_PREPARE: + + /* "asyncpg/protocol/protocol.pyx":436 + * + * elif self.state == PROTOCOL_PREPARE: + * self._on_result__prepare(waiter) # <<<<<<<<<<<<<< + * + * elif self.state == PROTOCOL_BIND_EXECUTE: + */ + __pyx_t_6 = ((struct __pyx_vtabstruct_7asyncpg_8protocol_8protocol_BaseProtocol *)__pyx_v_self->__pyx_base.__pyx_vtab)->_on_result__prepare(__pyx_v_self, __pyx_v_waiter); if (unlikely(!__pyx_t_6)) __PYX_ERR(27, 436, __pyx_L9_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + + /* "asyncpg/protocol/protocol.pyx":435 + * self._on_result__connect(waiter) + * + * elif self.state == PROTOCOL_PREPARE: # <<<<<<<<<<<<<< + * self._on_result__prepare(waiter) + * + */ + break; + + /* "asyncpg/protocol/protocol.pyx":438 + * self._on_result__prepare(waiter) + * + * elif self.state == PROTOCOL_BIND_EXECUTE: # <<<<<<<<<<<<<< + * self._on_result__bind_and_exec(waiter) + * + */ + case __pyx_e_7asyncpg_8protocol_8protocol_PROTOCOL_BIND_EXECUTE: + + /* "asyncpg/protocol/protocol.pyx":439 + * + * elif self.state == PROTOCOL_BIND_EXECUTE: + * self._on_result__bind_and_exec(waiter) # <<<<<<<<<<<<<< + * + * elif self.state == PROTOCOL_BIND_EXECUTE_MANY: + */ + __pyx_t_6 = ((struct __pyx_vtabstruct_7asyncpg_8protocol_8protocol_BaseProtocol *)__pyx_v_self->__pyx_base.__pyx_vtab)->_on_result__bind_and_exec(__pyx_v_self, __pyx_v_waiter); if (unlikely(!__pyx_t_6)) __PYX_ERR(27, 439, __pyx_L9_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + + /* "asyncpg/protocol/protocol.pyx":438 + * self._on_result__prepare(waiter) + * + * elif self.state == PROTOCOL_BIND_EXECUTE: # <<<<<<<<<<<<<< + * self._on_result__bind_and_exec(waiter) + * + */ + break; + + /* "asyncpg/protocol/protocol.pyx":441 + * self._on_result__bind_and_exec(waiter) + * + * elif self.state == PROTOCOL_BIND_EXECUTE_MANY: # <<<<<<<<<<<<<< + * self._on_result__bind_and_exec(waiter) + * + */ + case __pyx_e_7asyncpg_8protocol_8protocol_PROTOCOL_BIND_EXECUTE_MANY: + + /* "asyncpg/protocol/protocol.pyx":442 + * + * elif self.state == PROTOCOL_BIND_EXECUTE_MANY: + * self._on_result__bind_and_exec(waiter) # <<<<<<<<<<<<<< + * + * elif self.state == PROTOCOL_EXECUTE: + */ + __pyx_t_6 = ((struct __pyx_vtabstruct_7asyncpg_8protocol_8protocol_BaseProtocol *)__pyx_v_self->__pyx_base.__pyx_vtab)->_on_result__bind_and_exec(__pyx_v_self, __pyx_v_waiter); if (unlikely(!__pyx_t_6)) __PYX_ERR(27, 442, __pyx_L9_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + + /* "asyncpg/protocol/protocol.pyx":441 + * self._on_result__bind_and_exec(waiter) + * + * elif self.state == PROTOCOL_BIND_EXECUTE_MANY: # <<<<<<<<<<<<<< + * self._on_result__bind_and_exec(waiter) + * + */ + break; + + /* "asyncpg/protocol/protocol.pyx":444 + * self._on_result__bind_and_exec(waiter) + * + * elif self.state == PROTOCOL_EXECUTE: # <<<<<<<<<<<<<< + * self._on_result__bind_and_exec(waiter) + * + */ + case __pyx_e_7asyncpg_8protocol_8protocol_PROTOCOL_EXECUTE: + + /* "asyncpg/protocol/protocol.pyx":445 + * + * elif self.state == PROTOCOL_EXECUTE: + * self._on_result__bind_and_exec(waiter) # <<<<<<<<<<<<<< + * + * elif self.state == PROTOCOL_BIND: + */ + __pyx_t_6 = ((struct __pyx_vtabstruct_7asyncpg_8protocol_8protocol_BaseProtocol *)__pyx_v_self->__pyx_base.__pyx_vtab)->_on_result__bind_and_exec(__pyx_v_self, __pyx_v_waiter); if (unlikely(!__pyx_t_6)) __PYX_ERR(27, 445, __pyx_L9_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + + /* "asyncpg/protocol/protocol.pyx":444 + * self._on_result__bind_and_exec(waiter) + * + * elif self.state == PROTOCOL_EXECUTE: # <<<<<<<<<<<<<< + * self._on_result__bind_and_exec(waiter) + * + */ + break; + + /* "asyncpg/protocol/protocol.pyx":447 + * self._on_result__bind_and_exec(waiter) + * + * elif self.state == PROTOCOL_BIND: # <<<<<<<<<<<<<< + * self._on_result__bind(waiter) + * + */ + case __pyx_e_7asyncpg_8protocol_8protocol_PROTOCOL_BIND: + + /* "asyncpg/protocol/protocol.pyx":448 + * + * elif self.state == PROTOCOL_BIND: + * self._on_result__bind(waiter) # <<<<<<<<<<<<<< + * + * elif self.state == PROTOCOL_CLOSE_STMT_PORTAL: + */ + __pyx_t_6 = ((struct __pyx_vtabstruct_7asyncpg_8protocol_8protocol_BaseProtocol *)__pyx_v_self->__pyx_base.__pyx_vtab)->_on_result__bind(__pyx_v_self, __pyx_v_waiter); if (unlikely(!__pyx_t_6)) __PYX_ERR(27, 448, __pyx_L9_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + + /* "asyncpg/protocol/protocol.pyx":447 + * self._on_result__bind_and_exec(waiter) + * + * elif self.state == PROTOCOL_BIND: # <<<<<<<<<<<<<< + * self._on_result__bind(waiter) + * + */ + break; + + /* "asyncpg/protocol/protocol.pyx":450 + * self._on_result__bind(waiter) + * + * elif self.state == PROTOCOL_CLOSE_STMT_PORTAL: # <<<<<<<<<<<<<< + * self._on_result__close_stmt_or_portal(waiter) + * + */ + case __pyx_e_7asyncpg_8protocol_8protocol_PROTOCOL_CLOSE_STMT_PORTAL: + + /* "asyncpg/protocol/protocol.pyx":451 + * + * elif self.state == PROTOCOL_CLOSE_STMT_PORTAL: + * self._on_result__close_stmt_or_portal(waiter) # <<<<<<<<<<<<<< + * + * elif self.state == PROTOCOL_SIMPLE_QUERY: + */ + __pyx_t_6 = ((struct __pyx_vtabstruct_7asyncpg_8protocol_8protocol_BaseProtocol *)__pyx_v_self->__pyx_base.__pyx_vtab)->_on_result__close_stmt_or_portal(__pyx_v_self, __pyx_v_waiter); if (unlikely(!__pyx_t_6)) __PYX_ERR(27, 451, __pyx_L9_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + + /* "asyncpg/protocol/protocol.pyx":450 + * self._on_result__bind(waiter) + * + * elif self.state == PROTOCOL_CLOSE_STMT_PORTAL: # <<<<<<<<<<<<<< + * self._on_result__close_stmt_or_portal(waiter) + * + */ + break; + + /* "asyncpg/protocol/protocol.pyx":453 + * self._on_result__close_stmt_or_portal(waiter) + * + * elif self.state == PROTOCOL_SIMPLE_QUERY: # <<<<<<<<<<<<<< + * self._on_result__simple_query(waiter) + * + */ + case __pyx_e_7asyncpg_8protocol_8protocol_PROTOCOL_SIMPLE_QUERY: + + /* "asyncpg/protocol/protocol.pyx":454 + * + * elif self.state == PROTOCOL_SIMPLE_QUERY: + * self._on_result__simple_query(waiter) # <<<<<<<<<<<<<< + * + * else: + */ + __pyx_t_6 = ((struct __pyx_vtabstruct_7asyncpg_8protocol_8protocol_BaseProtocol *)__pyx_v_self->__pyx_base.__pyx_vtab)->_on_result__simple_query(__pyx_v_self, __pyx_v_waiter); if (unlikely(!__pyx_t_6)) __PYX_ERR(27, 454, __pyx_L9_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + + /* "asyncpg/protocol/protocol.pyx":453 + * self._on_result__close_stmt_or_portal(waiter) + * + * elif self.state == PROTOCOL_SIMPLE_QUERY: # <<<<<<<<<<<<<< + * self._on_result__simple_query(waiter) + * + */ + break; + default: + + /* "asyncpg/protocol/protocol.pyx":458 + * else: + * raise RuntimeError( + * 'got result for unknown protocol state {}'. # <<<<<<<<<<<<<< + * format(self.state)) + * + */ + __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_kp_u_got_result_for_unknown_protocol, __pyx_n_s_format); if (unlikely(!__pyx_t_5)) __PYX_ERR(27, 458, __pyx_L9_error) + __Pyx_GOTREF(__pyx_t_5); + + /* "asyncpg/protocol/protocol.pyx":459 + * raise RuntimeError( + * 'got result for unknown protocol state {}'. + * format(self.state)) # <<<<<<<<<<<<<< + * + * except Exception as exc: + */ + __pyx_t_1 = __Pyx_PyInt_From_enum____pyx_t_7asyncpg_8protocol_8protocol_ProtocolState(__pyx_v_self->__pyx_base.state); if (unlikely(!__pyx_t_1)) __PYX_ERR(27, 459, __pyx_L9_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_4 = NULL; + if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_5))) { + __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_5); + if (likely(__pyx_t_4)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_5); + __Pyx_INCREF(__pyx_t_4); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_5, function); + } + } + if (!__pyx_t_4) { + __pyx_t_6 = __Pyx_PyObject_CallOneArg(__pyx_t_5, __pyx_t_1); if (unlikely(!__pyx_t_6)) __PYX_ERR(27, 459, __pyx_L9_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_GOTREF(__pyx_t_6); + } else { + #if CYTHON_FAST_PYCALL + if (PyFunction_Check(__pyx_t_5)) { + PyObject *__pyx_temp[2] = {__pyx_t_4, __pyx_t_1}; + __pyx_t_6 = __Pyx_PyFunction_FastCall(__pyx_t_5, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_6)) __PYX_ERR(27, 459, __pyx_L9_error) + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_GOTREF(__pyx_t_6); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + } else + #endif + #if CYTHON_FAST_PYCCALL + if (__Pyx_PyFastCFunction_Check(__pyx_t_5)) { + PyObject *__pyx_temp[2] = {__pyx_t_4, __pyx_t_1}; + __pyx_t_6 = __Pyx_PyCFunction_FastCall(__pyx_t_5, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_6)) __PYX_ERR(27, 459, __pyx_L9_error) + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_GOTREF(__pyx_t_6); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + } else + #endif + { + __pyx_t_10 = PyTuple_New(1+1); if (unlikely(!__pyx_t_10)) __PYX_ERR(27, 459, __pyx_L9_error) + __Pyx_GOTREF(__pyx_t_10); + __Pyx_GIVEREF(__pyx_t_4); PyTuple_SET_ITEM(__pyx_t_10, 0, __pyx_t_4); __pyx_t_4 = NULL; + __Pyx_GIVEREF(__pyx_t_1); + PyTuple_SET_ITEM(__pyx_t_10, 0+1, __pyx_t_1); + __pyx_t_1 = 0; + __pyx_t_6 = __Pyx_PyObject_Call(__pyx_t_5, __pyx_t_10, NULL); if (unlikely(!__pyx_t_6)) __PYX_ERR(27, 459, __pyx_L9_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; + } + } + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + + /* "asyncpg/protocol/protocol.pyx":457 + * + * else: + * raise RuntimeError( # <<<<<<<<<<<<<< + * 'got result for unknown protocol state {}'. + * format(self.state)) + */ + __pyx_t_5 = PyTuple_New(1); if (unlikely(!__pyx_t_5)) __PYX_ERR(27, 457, __pyx_L9_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_GIVEREF(__pyx_t_6); + PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_t_6); + __pyx_t_6 = 0; + __pyx_t_6 = __Pyx_PyObject_Call(__pyx_builtin_RuntimeError, __pyx_t_5, NULL); if (unlikely(!__pyx_t_6)) __PYX_ERR(27, 457, __pyx_L9_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_Raise(__pyx_t_6, 0, 0, 0); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __PYX_ERR(27, 457, __pyx_L9_error) + break; + } + + /* "asyncpg/protocol/protocol.pyx":431 + * return + * + * try: # <<<<<<<<<<<<<< + * if self.state == PROTOCOL_AUTH: + * self._on_result__connect(waiter) + */ + } + __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; + __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0; + goto __pyx_L16_try_end; + __pyx_L9_error:; + __Pyx_PyThreadState_assign + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_XDECREF(__pyx_t_10); __pyx_t_10 = 0; + __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; + + /* "asyncpg/protocol/protocol.pyx":461 + * format(self.state)) + * + * except Exception as exc: # <<<<<<<<<<<<<< + * waiter.set_exception(exc) + * + */ + __pyx_t_11 = __Pyx_PyErr_ExceptionMatches(((PyObject *)(&((PyTypeObject*)PyExc_Exception)[0]))); + if (__pyx_t_11) { + __Pyx_AddTraceback("asyncpg.protocol.protocol.BaseProtocol._dispatch_result", __pyx_clineno, __pyx_lineno, __pyx_filename); + if (__Pyx_GetException(&__pyx_t_6, &__pyx_t_5, &__pyx_t_10) < 0) __PYX_ERR(27, 461, __pyx_L11_except_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_GOTREF(__pyx_t_5); + __Pyx_GOTREF(__pyx_t_10); + __Pyx_INCREF(__pyx_t_5); + __pyx_v_exc = __pyx_t_5; + /*try:*/ { + + /* "asyncpg/protocol/protocol.pyx":462 + * + * except Exception as exc: + * waiter.set_exception(exc) # <<<<<<<<<<<<<< + * + * cdef _on_result(self): + */ + __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_waiter, __pyx_n_s_set_exception); if (unlikely(!__pyx_t_4)) __PYX_ERR(27, 462, __pyx_L22_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_12 = NULL; + if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_4))) { + __pyx_t_12 = PyMethod_GET_SELF(__pyx_t_4); + if (likely(__pyx_t_12)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4); + __Pyx_INCREF(__pyx_t_12); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_4, function); + } + } + if (!__pyx_t_12) { + __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_v_exc); if (unlikely(!__pyx_t_1)) __PYX_ERR(27, 462, __pyx_L22_error) + __Pyx_GOTREF(__pyx_t_1); + } else { + #if CYTHON_FAST_PYCALL + if (PyFunction_Check(__pyx_t_4)) { + PyObject *__pyx_temp[2] = {__pyx_t_12, __pyx_v_exc}; + __pyx_t_1 = __Pyx_PyFunction_FastCall(__pyx_t_4, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_1)) __PYX_ERR(27, 462, __pyx_L22_error) + __Pyx_XDECREF(__pyx_t_12); __pyx_t_12 = 0; + __Pyx_GOTREF(__pyx_t_1); + } else + #endif + #if CYTHON_FAST_PYCCALL + if (__Pyx_PyFastCFunction_Check(__pyx_t_4)) { + PyObject *__pyx_temp[2] = {__pyx_t_12, __pyx_v_exc}; + __pyx_t_1 = __Pyx_PyCFunction_FastCall(__pyx_t_4, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_1)) __PYX_ERR(27, 462, __pyx_L22_error) + __Pyx_XDECREF(__pyx_t_12); __pyx_t_12 = 0; + __Pyx_GOTREF(__pyx_t_1); + } else + #endif + { + __pyx_t_13 = PyTuple_New(1+1); if (unlikely(!__pyx_t_13)) __PYX_ERR(27, 462, __pyx_L22_error) + __Pyx_GOTREF(__pyx_t_13); + __Pyx_GIVEREF(__pyx_t_12); PyTuple_SET_ITEM(__pyx_t_13, 0, __pyx_t_12); __pyx_t_12 = NULL; + __Pyx_INCREF(__pyx_v_exc); + __Pyx_GIVEREF(__pyx_v_exc); + PyTuple_SET_ITEM(__pyx_t_13, 0+1, __pyx_v_exc); + __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_4, __pyx_t_13, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(27, 462, __pyx_L22_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0; + } + } + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + } + + /* "asyncpg/protocol/protocol.pyx":461 + * format(self.state)) + * + * except Exception as exc: # <<<<<<<<<<<<<< + * waiter.set_exception(exc) + * + */ + /*finally:*/ { + /*normal exit:*/{ + __Pyx_DECREF(__pyx_v_exc); + __pyx_v_exc = NULL; + goto __pyx_L23; + } + /*exception exit:*/{ + __Pyx_PyThreadState_declare + __pyx_L22_error:; + __pyx_t_16 = 0; __pyx_t_17 = 0; __pyx_t_18 = 0; __pyx_t_19 = 0; __pyx_t_20 = 0; __pyx_t_21 = 0; + __Pyx_PyThreadState_assign + __Pyx_XDECREF(__pyx_t_12); __pyx_t_12 = 0; + __Pyx_XDECREF(__pyx_t_13); __pyx_t_13 = 0; + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; + if (PY_MAJOR_VERSION >= 3) __Pyx_ExceptionSwap(&__pyx_t_19, &__pyx_t_20, &__pyx_t_21); + if ((PY_MAJOR_VERSION < 3) || unlikely(__Pyx_GetException(&__pyx_t_16, &__pyx_t_17, &__pyx_t_18) < 0)) __Pyx_ErrFetch(&__pyx_t_16, &__pyx_t_17, &__pyx_t_18); + __Pyx_XGOTREF(__pyx_t_16); + __Pyx_XGOTREF(__pyx_t_17); + __Pyx_XGOTREF(__pyx_t_18); + __Pyx_XGOTREF(__pyx_t_19); + __Pyx_XGOTREF(__pyx_t_20); + __Pyx_XGOTREF(__pyx_t_21); + __pyx_t_11 = __pyx_lineno; __pyx_t_14 = __pyx_clineno; __pyx_t_15 = __pyx_filename; + { + __Pyx_DECREF(__pyx_v_exc); + __pyx_v_exc = NULL; + } + __Pyx_PyThreadState_assign + if (PY_MAJOR_VERSION >= 3) { + __Pyx_XGIVEREF(__pyx_t_19); + __Pyx_XGIVEREF(__pyx_t_20); + __Pyx_XGIVEREF(__pyx_t_21); + __Pyx_ExceptionReset(__pyx_t_19, __pyx_t_20, __pyx_t_21); + } + __Pyx_XGIVEREF(__pyx_t_16); + __Pyx_XGIVEREF(__pyx_t_17); + __Pyx_XGIVEREF(__pyx_t_18); + __Pyx_ErrRestore(__pyx_t_16, __pyx_t_17, __pyx_t_18); + __pyx_t_16 = 0; __pyx_t_17 = 0; __pyx_t_18 = 0; __pyx_t_19 = 0; __pyx_t_20 = 0; __pyx_t_21 = 0; + __pyx_lineno = __pyx_t_11; __pyx_clineno = __pyx_t_14; __pyx_filename = __pyx_t_15; + goto __pyx_L11_except_error; + } + __pyx_L23:; + } + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; + goto __pyx_L10_exception_handled; + } + goto __pyx_L11_except_error; + __pyx_L11_except_error:; + + /* "asyncpg/protocol/protocol.pyx":431 + * return + * + * try: # <<<<<<<<<<<<<< + * if self.state == PROTOCOL_AUTH: + * self._on_result__connect(waiter) + */ + __Pyx_PyThreadState_assign + __Pyx_XGIVEREF(__pyx_t_7); + __Pyx_XGIVEREF(__pyx_t_8); + __Pyx_XGIVEREF(__pyx_t_9); + __Pyx_ExceptionReset(__pyx_t_7, __pyx_t_8, __pyx_t_9); + goto __pyx_L1_error; + __pyx_L10_exception_handled:; + __Pyx_PyThreadState_assign + __Pyx_XGIVEREF(__pyx_t_7); + __Pyx_XGIVEREF(__pyx_t_8); + __Pyx_XGIVEREF(__pyx_t_9); + __Pyx_ExceptionReset(__pyx_t_7, __pyx_t_8, __pyx_t_9); + __pyx_L16_try_end:; + } + + /* "asyncpg/protocol/protocol.pyx":408 + * return self.statement._decode_row(buf, buf_len) + * + * cdef _dispatch_result(self): # <<<<<<<<<<<<<< + * waiter = self.waiter + * self.waiter = None + */ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_XDECREF(__pyx_t_6); + __Pyx_XDECREF(__pyx_t_10); + __Pyx_XDECREF(__pyx_t_12); + __Pyx_XDECREF(__pyx_t_13); + __Pyx_AddTraceback("asyncpg.protocol.protocol.BaseProtocol._dispatch_result", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XDECREF(__pyx_v_waiter); + __Pyx_XDECREF(__pyx_v_exc); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "asyncpg/protocol/protocol.pyx":464 + * waiter.set_exception(exc) + * + * cdef _on_result(self): # <<<<<<<<<<<<<< + * if self.timeout_handle is not None: + * self.timeout_handle.cancel() + */ + +static PyObject *__pyx_f_7asyncpg_8protocol_8protocol_12BaseProtocol__on_result(struct __pyx_obj_7asyncpg_8protocol_8protocol_BaseProtocol *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + int __pyx_t_2; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + PyObject *__pyx_t_5 = NULL; + int __pyx_t_6; + PyObject *__pyx_t_7 = NULL; + PyObject *__pyx_t_8 = NULL; + int __pyx_t_9; + int __pyx_t_10; + char const *__pyx_t_11; + PyObject *__pyx_t_12 = NULL; + PyObject *__pyx_t_13 = NULL; + PyObject *__pyx_t_14 = NULL; + PyObject *__pyx_t_15 = NULL; + PyObject *__pyx_t_16 = NULL; + PyObject *__pyx_t_17 = NULL; + __Pyx_RefNannySetupContext("_on_result", 0); + + /* "asyncpg/protocol/protocol.pyx":465 + * + * cdef _on_result(self): + * if self.timeout_handle is not None: # <<<<<<<<<<<<<< + * self.timeout_handle.cancel() + * self.timeout_handle = None + */ + __pyx_t_1 = (__pyx_v_self->timeout_handle != Py_None); + __pyx_t_2 = (__pyx_t_1 != 0); + if (__pyx_t_2) { + + /* "asyncpg/protocol/protocol.pyx":466 + * cdef _on_result(self): + * if self.timeout_handle is not None: + * self.timeout_handle.cancel() # <<<<<<<<<<<<<< + * self.timeout_handle = None + * + */ + __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_self->timeout_handle, __pyx_n_s_cancel); if (unlikely(!__pyx_t_4)) __PYX_ERR(27, 466, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_5 = NULL; + if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_4))) { + __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_4); + if (likely(__pyx_t_5)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4); + __Pyx_INCREF(__pyx_t_5); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_4, function); + } + } + if (__pyx_t_5) { + __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_t_5); if (unlikely(!__pyx_t_3)) __PYX_ERR(27, 466, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + } else { + __pyx_t_3 = __Pyx_PyObject_CallNoArg(__pyx_t_4); if (unlikely(!__pyx_t_3)) __PYX_ERR(27, 466, __pyx_L1_error) + } + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + + /* "asyncpg/protocol/protocol.pyx":467 + * if self.timeout_handle is not None: + * self.timeout_handle.cancel() + * self.timeout_handle = None # <<<<<<<<<<<<<< + * + * if self.cancel_waiter is not None: + */ + __Pyx_INCREF(Py_None); + __Pyx_GIVEREF(Py_None); + __Pyx_GOTREF(__pyx_v_self->timeout_handle); + __Pyx_DECREF(__pyx_v_self->timeout_handle); + __pyx_v_self->timeout_handle = Py_None; + + /* "asyncpg/protocol/protocol.pyx":465 + * + * cdef _on_result(self): + * if self.timeout_handle is not None: # <<<<<<<<<<<<<< + * self.timeout_handle.cancel() + * self.timeout_handle = None + */ + } + + /* "asyncpg/protocol/protocol.pyx":469 + * self.timeout_handle = None + * + * if self.cancel_waiter is not None: # <<<<<<<<<<<<<< + * if self.waiter is None or not self.waiter.cancelled(): + * self.cancel_waiter.set_result( + */ + __pyx_t_2 = (__pyx_v_self->cancel_waiter != Py_None); + __pyx_t_1 = (__pyx_t_2 != 0); + if (__pyx_t_1) { + + /* "asyncpg/protocol/protocol.pyx":470 + * + * if self.cancel_waiter is not None: + * if self.waiter is None or not self.waiter.cancelled(): # <<<<<<<<<<<<<< + * self.cancel_waiter.set_result( + * RuntimeError('invalid state after cancellation')) + */ + __pyx_t_2 = (__pyx_v_self->waiter == Py_None); + __pyx_t_6 = (__pyx_t_2 != 0); + if (!__pyx_t_6) { + } else { + __pyx_t_1 = __pyx_t_6; + goto __pyx_L6_bool_binop_done; + } + __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_self->waiter, __pyx_n_s_cancelled); if (unlikely(!__pyx_t_4)) __PYX_ERR(27, 470, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_5 = NULL; + if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_4))) { + __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_4); + if (likely(__pyx_t_5)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4); + __Pyx_INCREF(__pyx_t_5); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_4, function); + } + } + if (__pyx_t_5) { + __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_t_5); if (unlikely(!__pyx_t_3)) __PYX_ERR(27, 470, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + } else { + __pyx_t_3 = __Pyx_PyObject_CallNoArg(__pyx_t_4); if (unlikely(!__pyx_t_3)) __PYX_ERR(27, 470, __pyx_L1_error) + } + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(27, 470, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_2 = ((!__pyx_t_6) != 0); + __pyx_t_1 = __pyx_t_2; + __pyx_L6_bool_binop_done:; + if (__pyx_t_1) { + + /* "asyncpg/protocol/protocol.pyx":471 + * if self.cancel_waiter is not None: + * if self.waiter is None or not self.waiter.cancelled(): + * self.cancel_waiter.set_result( # <<<<<<<<<<<<<< + * RuntimeError('invalid state after cancellation')) + * else: + */ + __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_self->cancel_waiter, __pyx_n_s_set_result); if (unlikely(!__pyx_t_4)) __PYX_ERR(27, 471, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + + /* "asyncpg/protocol/protocol.pyx":472 + * if self.waiter is None or not self.waiter.cancelled(): + * self.cancel_waiter.set_result( + * RuntimeError('invalid state after cancellation')) # <<<<<<<<<<<<<< + * else: + * self.cancel_waiter.set_result(None) + */ + __pyx_t_5 = __Pyx_PyObject_Call(__pyx_builtin_RuntimeError, __pyx_tuple__80, NULL); if (unlikely(!__pyx_t_5)) __PYX_ERR(27, 472, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_7 = NULL; + if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_4))) { + __pyx_t_7 = PyMethod_GET_SELF(__pyx_t_4); + if (likely(__pyx_t_7)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4); + __Pyx_INCREF(__pyx_t_7); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_4, function); + } + } + if (!__pyx_t_7) { + __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_t_5); if (unlikely(!__pyx_t_3)) __PYX_ERR(27, 471, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_GOTREF(__pyx_t_3); + } else { + #if CYTHON_FAST_PYCALL + if (PyFunction_Check(__pyx_t_4)) { + PyObject *__pyx_temp[2] = {__pyx_t_7, __pyx_t_5}; + __pyx_t_3 = __Pyx_PyFunction_FastCall(__pyx_t_4, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_3)) __PYX_ERR(27, 471, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + } else + #endif + #if CYTHON_FAST_PYCCALL + if (__Pyx_PyFastCFunction_Check(__pyx_t_4)) { + PyObject *__pyx_temp[2] = {__pyx_t_7, __pyx_t_5}; + __pyx_t_3 = __Pyx_PyCFunction_FastCall(__pyx_t_4, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_3)) __PYX_ERR(27, 471, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + } else + #endif + { + __pyx_t_8 = PyTuple_New(1+1); if (unlikely(!__pyx_t_8)) __PYX_ERR(27, 471, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __Pyx_GIVEREF(__pyx_t_7); PyTuple_SET_ITEM(__pyx_t_8, 0, __pyx_t_7); __pyx_t_7 = NULL; + __Pyx_GIVEREF(__pyx_t_5); + PyTuple_SET_ITEM(__pyx_t_8, 0+1, __pyx_t_5); + __pyx_t_5 = 0; + __pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_4, __pyx_t_8, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(27, 471, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + } + } + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + + /* "asyncpg/protocol/protocol.pyx":470 + * + * if self.cancel_waiter is not None: + * if self.waiter is None or not self.waiter.cancelled(): # <<<<<<<<<<<<<< + * self.cancel_waiter.set_result( + * RuntimeError('invalid state after cancellation')) + */ + goto __pyx_L5; + } + + /* "asyncpg/protocol/protocol.pyx":474 + * RuntimeError('invalid state after cancellation')) + * else: + * self.cancel_waiter.set_result(None) # <<<<<<<<<<<<<< + * self.cancel_waiter = None + * self.waiter = None + */ + /*else*/ { + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_self->cancel_waiter, __pyx_n_s_set_result); if (unlikely(!__pyx_t_3)) __PYX_ERR(27, 474, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_tuple__81, NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(27, 474, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + } + __pyx_L5:; + + /* "asyncpg/protocol/protocol.pyx":475 + * else: + * self.cancel_waiter.set_result(None) + * self.cancel_waiter = None # <<<<<<<<<<<<<< + * self.waiter = None + * return + */ + __Pyx_INCREF(Py_None); + __Pyx_GIVEREF(Py_None); + __Pyx_GOTREF(__pyx_v_self->cancel_waiter); + __Pyx_DECREF(__pyx_v_self->cancel_waiter); + __pyx_v_self->cancel_waiter = Py_None; + + /* "asyncpg/protocol/protocol.pyx":476 + * self.cancel_waiter.set_result(None) + * self.cancel_waiter = None + * self.waiter = None # <<<<<<<<<<<<<< + * return + * + */ + __Pyx_INCREF(Py_None); + __Pyx_GIVEREF(Py_None); + __Pyx_GOTREF(__pyx_v_self->waiter); + __Pyx_DECREF(__pyx_v_self->waiter); + __pyx_v_self->waiter = Py_None; + + /* "asyncpg/protocol/protocol.pyx":477 + * self.cancel_waiter = None + * self.waiter = None + * return # <<<<<<<<<<<<<< + * + * try: + */ + __Pyx_XDECREF(__pyx_r); + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + + /* "asyncpg/protocol/protocol.pyx":469 + * self.timeout_handle = None + * + * if self.cancel_waiter is not None: # <<<<<<<<<<<<<< + * if self.waiter is None or not self.waiter.cancelled(): + * self.cancel_waiter.set_result( + */ + } + + /* "asyncpg/protocol/protocol.pyx":479 + * return + * + * try: # <<<<<<<<<<<<<< + * self._dispatch_result() + * finally: + */ + /*try:*/ { + + /* "asyncpg/protocol/protocol.pyx":480 + * + * try: + * self._dispatch_result() # <<<<<<<<<<<<<< + * finally: + * self.statement = None + */ + __pyx_t_4 = ((struct __pyx_vtabstruct_7asyncpg_8protocol_8protocol_BaseProtocol *)__pyx_v_self->__pyx_base.__pyx_vtab)->_dispatch_result(__pyx_v_self); if (unlikely(!__pyx_t_4)) __PYX_ERR(27, 480, __pyx_L9_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + } + + /* "asyncpg/protocol/protocol.pyx":482 + * self._dispatch_result() + * finally: + * self.statement = None # <<<<<<<<<<<<<< + * self.last_query = None + * self.return_extra = False + */ + /*finally:*/ { + /*normal exit:*/{ + __Pyx_INCREF(Py_None); + __Pyx_GIVEREF(Py_None); + __Pyx_GOTREF(__pyx_v_self->statement); + __Pyx_DECREF(((PyObject *)__pyx_v_self->statement)); + __pyx_v_self->statement = ((struct __pyx_obj_7asyncpg_8protocol_8protocol_PreparedStatementState *)Py_None); + + /* "asyncpg/protocol/protocol.pyx":483 + * finally: + * self.statement = None + * self.last_query = None # <<<<<<<<<<<<<< + * self.return_extra = False + * + */ + __Pyx_INCREF(Py_None); + __Pyx_GIVEREF(Py_None); + __Pyx_GOTREF(__pyx_v_self->last_query); + __Pyx_DECREF(__pyx_v_self->last_query); + __pyx_v_self->last_query = ((PyObject*)Py_None); + + /* "asyncpg/protocol/protocol.pyx":484 + * self.statement = None + * self.last_query = None + * self.return_extra = False # <<<<<<<<<<<<<< + * + * cdef _on_notification(self, pid, channel, payload): + */ + __pyx_v_self->return_extra = 0; + goto __pyx_L10; + } + /*exception exit:*/{ + __Pyx_PyThreadState_declare + __pyx_L9_error:; + __pyx_t_12 = 0; __pyx_t_13 = 0; __pyx_t_14 = 0; __pyx_t_15 = 0; __pyx_t_16 = 0; __pyx_t_17 = 0; + __Pyx_PyThreadState_assign + __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + if (PY_MAJOR_VERSION >= 3) __Pyx_ExceptionSwap(&__pyx_t_15, &__pyx_t_16, &__pyx_t_17); + if ((PY_MAJOR_VERSION < 3) || unlikely(__Pyx_GetException(&__pyx_t_12, &__pyx_t_13, &__pyx_t_14) < 0)) __Pyx_ErrFetch(&__pyx_t_12, &__pyx_t_13, &__pyx_t_14); + __Pyx_XGOTREF(__pyx_t_12); + __Pyx_XGOTREF(__pyx_t_13); + __Pyx_XGOTREF(__pyx_t_14); + __Pyx_XGOTREF(__pyx_t_15); + __Pyx_XGOTREF(__pyx_t_16); + __Pyx_XGOTREF(__pyx_t_17); + __pyx_t_9 = __pyx_lineno; __pyx_t_10 = __pyx_clineno; __pyx_t_11 = __pyx_filename; + { + + /* "asyncpg/protocol/protocol.pyx":482 + * self._dispatch_result() + * finally: + * self.statement = None # <<<<<<<<<<<<<< + * self.last_query = None + * self.return_extra = False + */ + __Pyx_INCREF(Py_None); + __Pyx_GIVEREF(Py_None); + __Pyx_GOTREF(__pyx_v_self->statement); + __Pyx_DECREF(((PyObject *)__pyx_v_self->statement)); + __pyx_v_self->statement = ((struct __pyx_obj_7asyncpg_8protocol_8protocol_PreparedStatementState *)Py_None); + + /* "asyncpg/protocol/protocol.pyx":483 + * finally: + * self.statement = None + * self.last_query = None # <<<<<<<<<<<<<< + * self.return_extra = False + * + */ + __Pyx_INCREF(Py_None); + __Pyx_GIVEREF(Py_None); + __Pyx_GOTREF(__pyx_v_self->last_query); + __Pyx_DECREF(__pyx_v_self->last_query); + __pyx_v_self->last_query = ((PyObject*)Py_None); + + /* "asyncpg/protocol/protocol.pyx":484 + * self.statement = None + * self.last_query = None + * self.return_extra = False # <<<<<<<<<<<<<< + * + * cdef _on_notification(self, pid, channel, payload): + */ + __pyx_v_self->return_extra = 0; + } + __Pyx_PyThreadState_assign + if (PY_MAJOR_VERSION >= 3) { + __Pyx_XGIVEREF(__pyx_t_15); + __Pyx_XGIVEREF(__pyx_t_16); + __Pyx_XGIVEREF(__pyx_t_17); + __Pyx_ExceptionReset(__pyx_t_15, __pyx_t_16, __pyx_t_17); + } + __Pyx_XGIVEREF(__pyx_t_12); + __Pyx_XGIVEREF(__pyx_t_13); + __Pyx_XGIVEREF(__pyx_t_14); + __Pyx_ErrRestore(__pyx_t_12, __pyx_t_13, __pyx_t_14); + __pyx_t_12 = 0; __pyx_t_13 = 0; __pyx_t_14 = 0; __pyx_t_15 = 0; __pyx_t_16 = 0; __pyx_t_17 = 0; + __pyx_lineno = __pyx_t_9; __pyx_clineno = __pyx_t_10; __pyx_filename = __pyx_t_11; + goto __pyx_L1_error; + } + __pyx_L10:; + } + + /* "asyncpg/protocol/protocol.pyx":464 + * waiter.set_exception(exc) + * + * cdef _on_result(self): # <<<<<<<<<<<<<< + * if self.timeout_handle is not None: + * self.timeout_handle.cancel() + */ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_XDECREF(__pyx_t_7); + __Pyx_XDECREF(__pyx_t_8); + __Pyx_AddTraceback("asyncpg.protocol.protocol.BaseProtocol._on_result", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "asyncpg/protocol/protocol.pyx":486 + * self.return_extra = False + * + * cdef _on_notification(self, pid, channel, payload): # <<<<<<<<<<<<<< + * self.connection._notify(pid, channel, payload) + * + */ + +static PyObject *__pyx_f_7asyncpg_8protocol_8protocol_12BaseProtocol__on_notification(struct __pyx_obj_7asyncpg_8protocol_8protocol_BaseProtocol *__pyx_v_self, PyObject *__pyx_v_pid, PyObject *__pyx_v_channel, PyObject *__pyx_v_payload) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + int __pyx_t_4; + PyObject *__pyx_t_5 = NULL; + __Pyx_RefNannySetupContext("_on_notification", 0); + + /* "asyncpg/protocol/protocol.pyx":487 + * + * cdef _on_notification(self, pid, channel, payload): + * self.connection._notify(pid, channel, payload) # <<<<<<<<<<<<<< + * + * cdef _on_connection_lost(self, exc): + */ + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_self->connection, __pyx_n_s_notify); if (unlikely(!__pyx_t_2)) __PYX_ERR(27, 487, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = NULL; + __pyx_t_4 = 0; + if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_3)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_3); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + __pyx_t_4 = 1; + } + } + #if CYTHON_FAST_PYCALL + if (PyFunction_Check(__pyx_t_2)) { + PyObject *__pyx_temp[4] = {__pyx_t_3, __pyx_v_pid, __pyx_v_channel, __pyx_v_payload}; + __pyx_t_1 = __Pyx_PyFunction_FastCall(__pyx_t_2, __pyx_temp+1-__pyx_t_4, 3+__pyx_t_4); if (unlikely(!__pyx_t_1)) __PYX_ERR(27, 487, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_GOTREF(__pyx_t_1); + } else + #endif + #if CYTHON_FAST_PYCCALL + if (__Pyx_PyFastCFunction_Check(__pyx_t_2)) { + PyObject *__pyx_temp[4] = {__pyx_t_3, __pyx_v_pid, __pyx_v_channel, __pyx_v_payload}; + __pyx_t_1 = __Pyx_PyCFunction_FastCall(__pyx_t_2, __pyx_temp+1-__pyx_t_4, 3+__pyx_t_4); if (unlikely(!__pyx_t_1)) __PYX_ERR(27, 487, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_GOTREF(__pyx_t_1); + } else + #endif + { + __pyx_t_5 = PyTuple_New(3+__pyx_t_4); if (unlikely(!__pyx_t_5)) __PYX_ERR(27, 487, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + if (__pyx_t_3) { + __Pyx_GIVEREF(__pyx_t_3); PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_t_3); __pyx_t_3 = NULL; + } + __Pyx_INCREF(__pyx_v_pid); + __Pyx_GIVEREF(__pyx_v_pid); + PyTuple_SET_ITEM(__pyx_t_5, 0+__pyx_t_4, __pyx_v_pid); + __Pyx_INCREF(__pyx_v_channel); + __Pyx_GIVEREF(__pyx_v_channel); + PyTuple_SET_ITEM(__pyx_t_5, 1+__pyx_t_4, __pyx_v_channel); + __Pyx_INCREF(__pyx_v_payload); + __Pyx_GIVEREF(__pyx_v_payload); + PyTuple_SET_ITEM(__pyx_t_5, 2+__pyx_t_4, __pyx_v_payload); + __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_t_5, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(27, 487, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + } + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "asyncpg/protocol/protocol.pyx":486 + * self.return_extra = False + * + * cdef _on_notification(self, pid, channel, payload): # <<<<<<<<<<<<<< + * self.connection._notify(pid, channel, payload) + * + */ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_AddTraceback("asyncpg.protocol.protocol.BaseProtocol._on_notification", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "asyncpg/protocol/protocol.pyx":489 + * self.connection._notify(pid, channel, payload) + * + * cdef _on_connection_lost(self, exc): # <<<<<<<<<<<<<< + * if self.closing: + * # The connection was lost because + */ + +static PyObject *__pyx_f_7asyncpg_8protocol_8protocol_12BaseProtocol__on_connection_lost(struct __pyx_obj_7asyncpg_8protocol_8protocol_BaseProtocol *__pyx_v_self, PyObject *__pyx_v_exc) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + int __pyx_t_2; + int __pyx_t_3; + PyObject *__pyx_t_4 = NULL; + PyObject *__pyx_t_5 = NULL; + PyObject *__pyx_t_6 = NULL; + PyObject *__pyx_t_7 = NULL; + __Pyx_RefNannySetupContext("_on_connection_lost", 0); + + /* "asyncpg/protocol/protocol.pyx":490 + * + * cdef _on_connection_lost(self, exc): + * if self.closing: # <<<<<<<<<<<<<< + * # The connection was lost because + * # Protocol.close() was called + */ + __pyx_t_1 = (__pyx_v_self->closing != 0); + if (__pyx_t_1) { + + /* "asyncpg/protocol/protocol.pyx":493 + * # The connection was lost because + * # Protocol.close() was called + * if self.waiter is not None and not self.waiter.done(): # <<<<<<<<<<<<<< + * if exc is None: + * self.waiter.set_result(None) + */ + __pyx_t_2 = (__pyx_v_self->waiter != Py_None); + __pyx_t_3 = (__pyx_t_2 != 0); + if (__pyx_t_3) { + } else { + __pyx_t_1 = __pyx_t_3; + goto __pyx_L5_bool_binop_done; + } + __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_v_self->waiter, __pyx_n_s_done); if (unlikely(!__pyx_t_5)) __PYX_ERR(27, 493, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_6 = NULL; + if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_5))) { + __pyx_t_6 = PyMethod_GET_SELF(__pyx_t_5); + if (likely(__pyx_t_6)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_5); + __Pyx_INCREF(__pyx_t_6); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_5, function); + } + } + if (__pyx_t_6) { + __pyx_t_4 = __Pyx_PyObject_CallOneArg(__pyx_t_5, __pyx_t_6); if (unlikely(!__pyx_t_4)) __PYX_ERR(27, 493, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + } else { + __pyx_t_4 = __Pyx_PyObject_CallNoArg(__pyx_t_5); if (unlikely(!__pyx_t_4)) __PYX_ERR(27, 493, __pyx_L1_error) + } + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __pyx_t_3 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_3 < 0)) __PYX_ERR(27, 493, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_2 = ((!__pyx_t_3) != 0); + __pyx_t_1 = __pyx_t_2; + __pyx_L5_bool_binop_done:; + if (__pyx_t_1) { + + /* "asyncpg/protocol/protocol.pyx":494 + * # Protocol.close() was called + * if self.waiter is not None and not self.waiter.done(): + * if exc is None: # <<<<<<<<<<<<<< + * self.waiter.set_result(None) + * else: + */ + __pyx_t_1 = (__pyx_v_exc == Py_None); + __pyx_t_2 = (__pyx_t_1 != 0); + if (__pyx_t_2) { + + /* "asyncpg/protocol/protocol.pyx":495 + * if self.waiter is not None and not self.waiter.done(): + * if exc is None: + * self.waiter.set_result(None) # <<<<<<<<<<<<<< + * else: + * self.waiter.set_exception(exc) + */ + __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_self->waiter, __pyx_n_s_set_result); if (unlikely(!__pyx_t_4)) __PYX_ERR(27, 495, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_5 = __Pyx_PyObject_Call(__pyx_t_4, __pyx_tuple__82, NULL); if (unlikely(!__pyx_t_5)) __PYX_ERR(27, 495, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + + /* "asyncpg/protocol/protocol.pyx":494 + * # Protocol.close() was called + * if self.waiter is not None and not self.waiter.done(): + * if exc is None: # <<<<<<<<<<<<<< + * self.waiter.set_result(None) + * else: + */ + goto __pyx_L7; + } + + /* "asyncpg/protocol/protocol.pyx":497 + * self.waiter.set_result(None) + * else: + * self.waiter.set_exception(exc) # <<<<<<<<<<<<<< + * self.waiter = None + * else: + */ + /*else*/ { + __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_self->waiter, __pyx_n_s_set_exception); if (unlikely(!__pyx_t_4)) __PYX_ERR(27, 497, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_6 = NULL; + if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_4))) { + __pyx_t_6 = PyMethod_GET_SELF(__pyx_t_4); + if (likely(__pyx_t_6)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4); + __Pyx_INCREF(__pyx_t_6); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_4, function); + } + } + if (!__pyx_t_6) { + __pyx_t_5 = __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_v_exc); if (unlikely(!__pyx_t_5)) __PYX_ERR(27, 497, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + } else { + #if CYTHON_FAST_PYCALL + if (PyFunction_Check(__pyx_t_4)) { + PyObject *__pyx_temp[2] = {__pyx_t_6, __pyx_v_exc}; + __pyx_t_5 = __Pyx_PyFunction_FastCall(__pyx_t_4, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_5)) __PYX_ERR(27, 497, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_GOTREF(__pyx_t_5); + } else + #endif + #if CYTHON_FAST_PYCCALL + if (__Pyx_PyFastCFunction_Check(__pyx_t_4)) { + PyObject *__pyx_temp[2] = {__pyx_t_6, __pyx_v_exc}; + __pyx_t_5 = __Pyx_PyCFunction_FastCall(__pyx_t_4, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_5)) __PYX_ERR(27, 497, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_GOTREF(__pyx_t_5); + } else + #endif + { + __pyx_t_7 = PyTuple_New(1+1); if (unlikely(!__pyx_t_7)) __PYX_ERR(27, 497, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __Pyx_GIVEREF(__pyx_t_6); PyTuple_SET_ITEM(__pyx_t_7, 0, __pyx_t_6); __pyx_t_6 = NULL; + __Pyx_INCREF(__pyx_v_exc); + __Pyx_GIVEREF(__pyx_v_exc); + PyTuple_SET_ITEM(__pyx_t_7, 0+1, __pyx_v_exc); + __pyx_t_5 = __Pyx_PyObject_Call(__pyx_t_4, __pyx_t_7, NULL); if (unlikely(!__pyx_t_5)) __PYX_ERR(27, 497, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + } + } + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + } + __pyx_L7:; + + /* "asyncpg/protocol/protocol.pyx":493 + * # The connection was lost because + * # Protocol.close() was called + * if self.waiter is not None and not self.waiter.done(): # <<<<<<<<<<<<<< + * if exc is None: + * self.waiter.set_result(None) + */ + } + + /* "asyncpg/protocol/protocol.pyx":498 + * else: + * self.waiter.set_exception(exc) + * self.waiter = None # <<<<<<<<<<<<<< + * else: + * # The connection was lost because it was + */ + __Pyx_INCREF(Py_None); + __Pyx_GIVEREF(Py_None); + __Pyx_GOTREF(__pyx_v_self->waiter); + __Pyx_DECREF(__pyx_v_self->waiter); + __pyx_v_self->waiter = Py_None; + + /* "asyncpg/protocol/protocol.pyx":490 + * + * cdef _on_connection_lost(self, exc): + * if self.closing: # <<<<<<<<<<<<<< + * # The connection was lost because + * # Protocol.close() was called + */ + goto __pyx_L3; + } + + /* "asyncpg/protocol/protocol.pyx":503 + * # terminated or due to another error; + * # Throw an error in any awaiting waiter. + * self.closing = True # <<<<<<<<<<<<<< + * self._handle_waiter_on_connection_lost(exc) + * + */ + /*else*/ { + __pyx_v_self->closing = 1; + + /* "asyncpg/protocol/protocol.pyx":504 + * # Throw an error in any awaiting waiter. + * self.closing = True + * self._handle_waiter_on_connection_lost(exc) # <<<<<<<<<<<<<< + * + * + */ + __pyx_t_5 = ((struct __pyx_vtabstruct_7asyncpg_8protocol_8protocol_BaseProtocol *)__pyx_v_self->__pyx_base.__pyx_vtab)->_handle_waiter_on_connection_lost(__pyx_v_self, __pyx_v_exc); if (unlikely(!__pyx_t_5)) __PYX_ERR(27, 504, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + } + __pyx_L3:; + + /* "asyncpg/protocol/protocol.pyx":489 + * self.connection._notify(pid, channel, payload) + * + * cdef _on_connection_lost(self, exc): # <<<<<<<<<<<<<< + * if self.closing: + * # The connection was lost because + */ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_4); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_XDECREF(__pyx_t_6); + __Pyx_XDECREF(__pyx_t_7); + __Pyx_AddTraceback("asyncpg.protocol.protocol.BaseProtocol._on_connection_lost", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "asyncpg/protocol/protocol.pxd":46 + * bint closing + * + * readonly uint64_t queries_count # <<<<<<<<<<<<<< + * + * PreparedStatementState statement + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_7asyncpg_8protocol_8protocol_12BaseProtocol_13queries_count_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_7asyncpg_8protocol_8protocol_12BaseProtocol_13queries_count_1__get__(PyObject *__pyx_v_self) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_r = __pyx_pf_7asyncpg_8protocol_8protocol_12BaseProtocol_13queries_count___get__(((struct __pyx_obj_7asyncpg_8protocol_8protocol_BaseProtocol *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_7asyncpg_8protocol_8protocol_12BaseProtocol_13queries_count___get__(struct __pyx_obj_7asyncpg_8protocol_8protocol_BaseProtocol *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + __Pyx_RefNannySetupContext("__get__", 0); + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyInt_From_uint64_t(__pyx_v_self->queries_count); if (unlikely(!__pyx_t_1)) __PYX_ERR(28, 46, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("asyncpg.protocol.protocol.BaseProtocol.queries_count.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "asyncpg/protocol/protocol.pyx":511 + * + * + * def _create_record(object mapping, tuple elems): # <<<<<<<<<<<<<< + * # Exposed only for testing purposes. + * + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_7asyncpg_8protocol_8protocol_1_create_record(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ +static PyMethodDef __pyx_mdef_7asyncpg_8protocol_8protocol_1_create_record = {"_create_record", (PyCFunction)__pyx_pw_7asyncpg_8protocol_8protocol_1_create_record, METH_VARARGS|METH_KEYWORDS, 0}; +static PyObject *__pyx_pw_7asyncpg_8protocol_8protocol_1_create_record(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { + PyObject *__pyx_v_mapping = 0; + PyObject *__pyx_v_elems = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("_create_record (wrapper)", 0); + { + static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_mapping,&__pyx_n_s_elems,0}; + PyObject* values[2] = {0,0}; + if (unlikely(__pyx_kwds)) { + Py_ssize_t kw_args; + const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args); + switch (pos_args) { + case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); + case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = PyDict_Size(__pyx_kwds); + switch (pos_args) { + case 0: + if (likely((values[0] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_mapping)) != 0)) kw_args--; + else goto __pyx_L5_argtuple_error; + case 1: + if (likely((values[1] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_elems)) != 0)) kw_args--; + else { + __Pyx_RaiseArgtupleInvalid("_create_record", 1, 2, 2, 1); __PYX_ERR(27, 511, __pyx_L3_error) + } + } + if (unlikely(kw_args > 0)) { + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "_create_record") < 0)) __PYX_ERR(27, 511, __pyx_L3_error) + } + } else if (PyTuple_GET_SIZE(__pyx_args) != 2) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + values[1] = PyTuple_GET_ITEM(__pyx_args, 1); + } + __pyx_v_mapping = values[0]; + __pyx_v_elems = ((PyObject*)values[1]); + } + goto __pyx_L4_argument_unpacking_done; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("_create_record", 1, 2, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(27, 511, __pyx_L3_error) + __pyx_L3_error:; + __Pyx_AddTraceback("asyncpg.protocol.protocol._create_record", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_elems), (&PyTuple_Type), 1, "elems", 1))) __PYX_ERR(27, 511, __pyx_L1_error) + __pyx_r = __pyx_pf_7asyncpg_8protocol_8protocol__create_record(__pyx_self, __pyx_v_mapping, __pyx_v_elems); + + /* function exit code */ + goto __pyx_L0; + __pyx_L1_error:; + __pyx_r = NULL; + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_7asyncpg_8protocol_8protocol__create_record(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_mapping, PyObject *__pyx_v_elems) { + PyObject *__pyx_v_rec = 0; + int32_t __pyx_v_i; + PyObject *__pyx_v_desc = NULL; + PyObject *__pyx_v_elem = NULL; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + int __pyx_t_2; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + Py_ssize_t __pyx_t_5; + int32_t __pyx_t_6; + __Pyx_RefNannySetupContext("_create_record", 0); + + /* "asyncpg/protocol/protocol.pyx":518 + * int32_t i + * + * if mapping is None: # <<<<<<<<<<<<<< + * desc = record.ApgRecordDesc_New({}, ()) + * else: + */ + __pyx_t_1 = (__pyx_v_mapping == Py_None); + __pyx_t_2 = (__pyx_t_1 != 0); + if (__pyx_t_2) { + + /* "asyncpg/protocol/protocol.pyx":519 + * + * if mapping is None: + * desc = record.ApgRecordDesc_New({}, ()) # <<<<<<<<<<<<<< + * else: + * desc = record.ApgRecordDesc_New( + */ + __pyx_t_3 = PyDict_New(); if (unlikely(!__pyx_t_3)) __PYX_ERR(27, 519, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = ApgRecordDesc_New(__pyx_t_3, __pyx_empty_tuple); if (unlikely(!__pyx_t_4)) __PYX_ERR(27, 519, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_v_desc = __pyx_t_4; + __pyx_t_4 = 0; + + /* "asyncpg/protocol/protocol.pyx":518 + * int32_t i + * + * if mapping is None: # <<<<<<<<<<<<<< + * desc = record.ApgRecordDesc_New({}, ()) + * else: + */ + goto __pyx_L3; + } + + /* "asyncpg/protocol/protocol.pyx":521 + * desc = record.ApgRecordDesc_New({}, ()) + * else: + * desc = record.ApgRecordDesc_New( # <<<<<<<<<<<<<< + * mapping, tuple(mapping) if mapping else ()) + * + */ + /*else*/ { + + /* "asyncpg/protocol/protocol.pyx":522 + * else: + * desc = record.ApgRecordDesc_New( + * mapping, tuple(mapping) if mapping else ()) # <<<<<<<<<<<<<< + * + * rec = record.ApgRecord_New(desc, len(elems)) + */ + __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_v_mapping); if (unlikely(__pyx_t_2 < 0)) __PYX_ERR(27, 522, __pyx_L1_error) + if (__pyx_t_2) { + __pyx_t_3 = PySequence_Tuple(__pyx_v_mapping); if (unlikely(!__pyx_t_3)) __PYX_ERR(27, 522, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = __pyx_t_3; + __pyx_t_3 = 0; + } else { + __Pyx_INCREF(__pyx_empty_tuple); + __pyx_t_4 = __pyx_empty_tuple; + } + + /* "asyncpg/protocol/protocol.pyx":521 + * desc = record.ApgRecordDesc_New({}, ()) + * else: + * desc = record.ApgRecordDesc_New( # <<<<<<<<<<<<<< + * mapping, tuple(mapping) if mapping else ()) + * + */ + __pyx_t_3 = ApgRecordDesc_New(__pyx_v_mapping, __pyx_t_4); if (unlikely(!__pyx_t_3)) __PYX_ERR(27, 521, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_v_desc = __pyx_t_3; + __pyx_t_3 = 0; + } + __pyx_L3:; + + /* "asyncpg/protocol/protocol.pyx":524 + * mapping, tuple(mapping) if mapping else ()) + * + * rec = record.ApgRecord_New(desc, len(elems)) # <<<<<<<<<<<<<< + * for i in range(len(elems)): + * elem = elems[i] + */ + if (unlikely(__pyx_v_elems == Py_None)) { + PyErr_SetString(PyExc_TypeError, "object of type 'NoneType' has no len()"); + __PYX_ERR(27, 524, __pyx_L1_error) + } + __pyx_t_5 = PyTuple_GET_SIZE(__pyx_v_elems); if (unlikely(__pyx_t_5 == -1)) __PYX_ERR(27, 524, __pyx_L1_error) + __pyx_t_3 = ApgRecord_New(__pyx_v_desc, __pyx_t_5); if (unlikely(!__pyx_t_3)) __PYX_ERR(27, 524, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_v_rec = __pyx_t_3; + __pyx_t_3 = 0; + + /* "asyncpg/protocol/protocol.pyx":525 + * + * rec = record.ApgRecord_New(desc, len(elems)) + * for i in range(len(elems)): # <<<<<<<<<<<<<< + * elem = elems[i] + * cpython.Py_INCREF(elem) + */ + if (unlikely(__pyx_v_elems == Py_None)) { + PyErr_SetString(PyExc_TypeError, "object of type 'NoneType' has no len()"); + __PYX_ERR(27, 525, __pyx_L1_error) + } + __pyx_t_5 = PyTuple_GET_SIZE(__pyx_v_elems); if (unlikely(__pyx_t_5 == -1)) __PYX_ERR(27, 525, __pyx_L1_error) + for (__pyx_t_6 = 0; __pyx_t_6 < __pyx_t_5; __pyx_t_6+=1) { + __pyx_v_i = __pyx_t_6; + + /* "asyncpg/protocol/protocol.pyx":526 + * rec = record.ApgRecord_New(desc, len(elems)) + * for i in range(len(elems)): + * elem = elems[i] # <<<<<<<<<<<<<< + * cpython.Py_INCREF(elem) + * record.ApgRecord_SET_ITEM(rec, i, elem) + */ + if (unlikely(__pyx_v_elems == Py_None)) { + PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable"); + __PYX_ERR(27, 526, __pyx_L1_error) + } + __pyx_t_3 = __Pyx_GetItemInt_Tuple(__pyx_v_elems, __pyx_v_i, int32_t, 1, __Pyx_PyInt_From_int32_t, 0, 1, 1); if (unlikely(!__pyx_t_3)) __PYX_ERR(27, 526, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_XDECREF_SET(__pyx_v_elem, __pyx_t_3); + __pyx_t_3 = 0; + + /* "asyncpg/protocol/protocol.pyx":527 + * for i in range(len(elems)): + * elem = elems[i] + * cpython.Py_INCREF(elem) # <<<<<<<<<<<<<< + * record.ApgRecord_SET_ITEM(rec, i, elem) + * return rec + */ + Py_INCREF(__pyx_v_elem); + + /* "asyncpg/protocol/protocol.pyx":528 + * elem = elems[i] + * cpython.Py_INCREF(elem) + * record.ApgRecord_SET_ITEM(rec, i, elem) # <<<<<<<<<<<<<< + * return rec + * + */ + ApgRecord_SET_ITEM(__pyx_v_rec, __pyx_v_i, __pyx_v_elem); + } + + /* "asyncpg/protocol/protocol.pyx":529 + * cpython.Py_INCREF(elem) + * record.ApgRecord_SET_ITEM(rec, i, elem) + * return rec # <<<<<<<<<<<<<< + * + * + */ + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(__pyx_v_rec); + __pyx_r = __pyx_v_rec; + goto __pyx_L0; + + /* "asyncpg/protocol/protocol.pyx":511 + * + * + * def _create_record(object mapping, tuple elems): # <<<<<<<<<<<<<< + * # Exposed only for testing purposes. + * + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_AddTraceback("asyncpg.protocol.protocol._create_record", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XDECREF(__pyx_v_rec); + __Pyx_XDECREF(__pyx_v_desc); + __Pyx_XDECREF(__pyx_v_elem); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "hton.pxd":25 + * + * + * cdef inline void pack_int16(char* buf, int16_t x): # <<<<<<<<<<<<<< + * (buf)[0] = htons(x) + * + */ + +static CYTHON_INLINE void __pyx_f_7asyncpg_8protocol_4hton_pack_int16(char *__pyx_v_buf, int16_t __pyx_v_x) { + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("pack_int16", 0); + + /* "hton.pxd":26 + * + * cdef inline void pack_int16(char* buf, int16_t x): + * (buf)[0] = htons(x) # <<<<<<<<<<<<<< + * + * + */ + (((uint16_t *)__pyx_v_buf)[0]) = htons(((uint16_t)__pyx_v_x)); + + /* "hton.pxd":25 + * + * + * cdef inline void pack_int16(char* buf, int16_t x): # <<<<<<<<<<<<<< + * (buf)[0] = htons(x) + * + */ + + /* function exit code */ + __Pyx_RefNannyFinishContext(); +} + +/* "hton.pxd":29 + * + * + * cdef inline int16_t unpack_int16(const char* buf): # <<<<<<<<<<<<<< + * return ntohs((buf)[0]) + * + */ + +static CYTHON_INLINE int16_t __pyx_f_7asyncpg_8protocol_4hton_unpack_int16(char const *__pyx_v_buf) { + int16_t __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("unpack_int16", 0); + + /* "hton.pxd":30 + * + * cdef inline int16_t unpack_int16(const char* buf): + * return ntohs((buf)[0]) # <<<<<<<<<<<<<< + * + * + */ + __pyx_r = ((int16_t)ntohs((((uint16_t *)__pyx_v_buf)[0]))); + goto __pyx_L0; + + /* "hton.pxd":29 + * + * + * cdef inline int16_t unpack_int16(const char* buf): # <<<<<<<<<<<<<< + * return ntohs((buf)[0]) + * + */ + + /* function exit code */ + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "hton.pxd":33 + * + * + * cdef inline void pack_int32(char* buf, int32_t x): # <<<<<<<<<<<<<< + * (buf)[0] = htonl(x) + * + */ + +static CYTHON_INLINE void __pyx_f_7asyncpg_8protocol_4hton_pack_int32(char *__pyx_v_buf, int32_t __pyx_v_x) { + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("pack_int32", 0); + + /* "hton.pxd":34 + * + * cdef inline void pack_int32(char* buf, int32_t x): + * (buf)[0] = htonl(x) # <<<<<<<<<<<<<< + * + * + */ + (((uint32_t *)__pyx_v_buf)[0]) = htonl(((uint32_t)__pyx_v_x)); + + /* "hton.pxd":33 + * + * + * cdef inline void pack_int32(char* buf, int32_t x): # <<<<<<<<<<<<<< + * (buf)[0] = htonl(x) + * + */ + + /* function exit code */ + __Pyx_RefNannyFinishContext(); +} + +/* "hton.pxd":37 + * + * + * cdef inline int32_t unpack_int32(const char* buf): # <<<<<<<<<<<<<< + * return ntohl((buf)[0]) + * + */ + +static CYTHON_INLINE int32_t __pyx_f_7asyncpg_8protocol_4hton_unpack_int32(char const *__pyx_v_buf) { + int32_t __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("unpack_int32", 0); + + /* "hton.pxd":38 + * + * cdef inline int32_t unpack_int32(const char* buf): + * return ntohl((buf)[0]) # <<<<<<<<<<<<<< + * + * + */ + __pyx_r = ((int32_t)ntohl((((uint32_t *)__pyx_v_buf)[0]))); + goto __pyx_L0; + + /* "hton.pxd":37 + * + * + * cdef inline int32_t unpack_int32(const char* buf): # <<<<<<<<<<<<<< + * return ntohl((buf)[0]) + * + */ + + /* function exit code */ + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "hton.pxd":41 + * + * + * cdef inline void pack_int64(char* buf, int64_t x): # <<<<<<<<<<<<<< + * (buf)[0] = htonl(((x) >> 32)) + * (&buf[4])[0] = htonl((x)) + */ + +static CYTHON_INLINE void __pyx_f_7asyncpg_8protocol_4hton_pack_int64(char *__pyx_v_buf, int64_t __pyx_v_x) { + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("pack_int64", 0); + + /* "hton.pxd":42 + * + * cdef inline void pack_int64(char* buf, int64_t x): + * (buf)[0] = htonl(((x) >> 32)) # <<<<<<<<<<<<<< + * (&buf[4])[0] = htonl((x)) + * + */ + (((uint32_t *)__pyx_v_buf)[0]) = htonl(((uint32_t)(((uint64_t)__pyx_v_x) >> 32))); + + /* "hton.pxd":43 + * cdef inline void pack_int64(char* buf, int64_t x): + * (buf)[0] = htonl(((x) >> 32)) + * (&buf[4])[0] = htonl((x)) # <<<<<<<<<<<<<< + * + * + */ + (((uint32_t *)(&(__pyx_v_buf[4])))[0]) = htonl(((uint32_t)__pyx_v_x)); + + /* "hton.pxd":41 + * + * + * cdef inline void pack_int64(char* buf, int64_t x): # <<<<<<<<<<<<<< + * (buf)[0] = htonl(((x) >> 32)) + * (&buf[4])[0] = htonl((x)) + */ + + /* function exit code */ + __Pyx_RefNannyFinishContext(); +} + +/* "hton.pxd":46 + * + * + * cdef inline int64_t unpack_int64(const char* buf): # <<<<<<<<<<<<<< + * cdef int64_t hh = unpack_int32(buf) + * cdef uint32_t hl = unpack_int32(&buf[4]) + */ + +static CYTHON_INLINE int64_t __pyx_f_7asyncpg_8protocol_4hton_unpack_int64(char const *__pyx_v_buf) { + int64_t __pyx_v_hh; + uint32_t __pyx_v_hl; + int64_t __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("unpack_int64", 0); + + /* "hton.pxd":47 + * + * cdef inline int64_t unpack_int64(const char* buf): + * cdef int64_t hh = unpack_int32(buf) # <<<<<<<<<<<<<< + * cdef uint32_t hl = unpack_int32(&buf[4]) + * + */ + __pyx_v_hh = __pyx_f_7asyncpg_8protocol_4hton_unpack_int32(__pyx_v_buf); + + /* "hton.pxd":48 + * cdef inline int64_t unpack_int64(const char* buf): + * cdef int64_t hh = unpack_int32(buf) + * cdef uint32_t hl = unpack_int32(&buf[4]) # <<<<<<<<<<<<<< + * + * return (hh << 32) | hl + */ + __pyx_v_hl = ((uint32_t)__pyx_f_7asyncpg_8protocol_4hton_unpack_int32((&(__pyx_v_buf[4])))); + + /* "hton.pxd":50 + * cdef uint32_t hl = unpack_int32(&buf[4]) + * + * return (hh << 32) | hl # <<<<<<<<<<<<<< + * + * + */ + __pyx_r = ((__pyx_v_hh << 32) | __pyx_v_hl); + goto __pyx_L0; + + /* "hton.pxd":46 + * + * + * cdef inline int64_t unpack_int64(const char* buf): # <<<<<<<<<<<<<< + * cdef int64_t hh = unpack_int32(buf) + * cdef uint32_t hl = unpack_int32(&buf[4]) + */ + + /* function exit code */ + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "hton.pxd":58 + * + * + * cdef inline int32_t pack_float(char* buf, float f): # <<<<<<<<<<<<<< + * cdef _floatconv v + * v.f = f + */ + +static CYTHON_INLINE int32_t __pyx_f_7asyncpg_8protocol_4hton_pack_float(char *__pyx_v_buf, float __pyx_v_f) { + union __pyx_t_7asyncpg_8protocol_4hton__floatconv __pyx_v_v; + int32_t __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("pack_float", 0); + + /* "hton.pxd":60 + * cdef inline int32_t pack_float(char* buf, float f): + * cdef _floatconv v + * v.f = f # <<<<<<<<<<<<<< + * pack_int32(buf, v.i) + * + */ + __pyx_v_v.f = __pyx_v_f; + + /* "hton.pxd":61 + * cdef _floatconv v + * v.f = f + * pack_int32(buf, v.i) # <<<<<<<<<<<<<< + * + * + */ + __pyx_f_7asyncpg_8protocol_4hton_pack_int32(__pyx_v_buf, ((int32_t)__pyx_v_v.i)); + + /* "hton.pxd":58 + * + * + * cdef inline int32_t pack_float(char* buf, float f): # <<<<<<<<<<<<<< + * cdef _floatconv v + * v.f = f + */ + + /* function exit code */ + __pyx_r = 0; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "hton.pxd":64 + * + * + * cdef inline float unpack_float(const char* buf): # <<<<<<<<<<<<<< + * cdef _floatconv v + * v.i = unpack_int32(buf) + */ + +static CYTHON_INLINE float __pyx_f_7asyncpg_8protocol_4hton_unpack_float(char const *__pyx_v_buf) { + union __pyx_t_7asyncpg_8protocol_4hton__floatconv __pyx_v_v; + float __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("unpack_float", 0); + + /* "hton.pxd":66 + * cdef inline float unpack_float(const char* buf): + * cdef _floatconv v + * v.i = unpack_int32(buf) # <<<<<<<<<<<<<< + * return v.f + * + */ + __pyx_v_v.i = ((uint32_t)__pyx_f_7asyncpg_8protocol_4hton_unpack_int32(__pyx_v_buf)); + + /* "hton.pxd":67 + * cdef _floatconv v + * v.i = unpack_int32(buf) + * return v.f # <<<<<<<<<<<<<< + * + * + */ + __pyx_r = __pyx_v_v.f; + goto __pyx_L0; + + /* "hton.pxd":64 + * + * + * cdef inline float unpack_float(const char* buf): # <<<<<<<<<<<<<< + * cdef _floatconv v + * v.i = unpack_int32(buf) + */ + + /* function exit code */ + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "hton.pxd":75 + * + * + * cdef inline int64_t pack_double(char* buf, double f): # <<<<<<<<<<<<<< + * cdef _doubleconv v + * v.f = f + */ + +static CYTHON_INLINE int64_t __pyx_f_7asyncpg_8protocol_4hton_pack_double(char *__pyx_v_buf, double __pyx_v_f) { + union __pyx_t_7asyncpg_8protocol_4hton__doubleconv __pyx_v_v; + int64_t __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("pack_double", 0); + + /* "hton.pxd":77 + * cdef inline int64_t pack_double(char* buf, double f): + * cdef _doubleconv v + * v.f = f # <<<<<<<<<<<<<< + * pack_int64(buf, v.i) + * + */ + __pyx_v_v.f = __pyx_v_f; + + /* "hton.pxd":78 + * cdef _doubleconv v + * v.f = f + * pack_int64(buf, v.i) # <<<<<<<<<<<<<< + * + * + */ + __pyx_f_7asyncpg_8protocol_4hton_pack_int64(__pyx_v_buf, ((int64_t)__pyx_v_v.i)); + + /* "hton.pxd":75 + * + * + * cdef inline int64_t pack_double(char* buf, double f): # <<<<<<<<<<<<<< + * cdef _doubleconv v + * v.f = f + */ + + /* function exit code */ + __pyx_r = 0; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "hton.pxd":81 + * + * + * cdef inline double unpack_double(const char* buf): # <<<<<<<<<<<<<< + * cdef _doubleconv v + * v.i = unpack_int64(buf) + */ + +static CYTHON_INLINE double __pyx_f_7asyncpg_8protocol_4hton_unpack_double(char const *__pyx_v_buf) { + union __pyx_t_7asyncpg_8protocol_4hton__doubleconv __pyx_v_v; + double __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("unpack_double", 0); + + /* "hton.pxd":83 + * cdef inline double unpack_double(const char* buf): + * cdef _doubleconv v + * v.i = unpack_int64(buf) # <<<<<<<<<<<<<< + * return v.f + */ + __pyx_v_v.i = ((uint64_t)__pyx_f_7asyncpg_8protocol_4hton_unpack_int64(__pyx_v_buf)); + + /* "hton.pxd":84 + * cdef _doubleconv v + * v.i = unpack_int64(buf) + * return v.f # <<<<<<<<<<<<<< + */ + __pyx_r = __pyx_v_v.f; + goto __pyx_L0; + + /* "hton.pxd":81 + * + * + * cdef inline double unpack_double(const char* buf): # <<<<<<<<<<<<<< + * cdef _doubleconv v + * v.i = unpack_int64(buf) + */ + + /* function exit code */ + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} +static struct __pyx_vtabstruct_7asyncpg_8protocol_8protocol_Memory __pyx_vtable_7asyncpg_8protocol_8protocol_Memory; + +static struct __pyx_obj_7asyncpg_8protocol_8protocol_Memory *__pyx_freelist_7asyncpg_8protocol_8protocol_Memory[1024]; +static int __pyx_freecount_7asyncpg_8protocol_8protocol_Memory = 0; + +static PyObject *__pyx_tp_new_7asyncpg_8protocol_8protocol_Memory(PyTypeObject *t, CYTHON_UNUSED PyObject *a, CYTHON_UNUSED PyObject *k) { + struct __pyx_obj_7asyncpg_8protocol_8protocol_Memory *p; + PyObject *o; + if (CYTHON_COMPILING_IN_CPYTHON && likely((__pyx_freecount_7asyncpg_8protocol_8protocol_Memory > 0) & (t->tp_basicsize == sizeof(struct __pyx_obj_7asyncpg_8protocol_8protocol_Memory)))) { + o = (PyObject*)__pyx_freelist_7asyncpg_8protocol_8protocol_Memory[--__pyx_freecount_7asyncpg_8protocol_8protocol_Memory]; + memset(o, 0, sizeof(struct __pyx_obj_7asyncpg_8protocol_8protocol_Memory)); + (void) PyObject_INIT(o, t); + PyObject_GC_Track(o); + } else { + o = (*t->tp_alloc)(t, 0); + if (unlikely(!o)) return 0; + } + p = ((struct __pyx_obj_7asyncpg_8protocol_8protocol_Memory *)o); + p->__pyx_vtab = __pyx_vtabptr_7asyncpg_8protocol_8protocol_Memory; + p->owner = Py_None; Py_INCREF(Py_None); + return o; +} + +static void __pyx_tp_dealloc_7asyncpg_8protocol_8protocol_Memory(PyObject *o) { + struct __pyx_obj_7asyncpg_8protocol_8protocol_Memory *p = (struct __pyx_obj_7asyncpg_8protocol_8protocol_Memory *)o; + PyObject_GC_UnTrack(o); + Py_CLEAR(p->owner); + if (CYTHON_COMPILING_IN_CPYTHON && ((__pyx_freecount_7asyncpg_8protocol_8protocol_Memory < 1024) & (Py_TYPE(o)->tp_basicsize == sizeof(struct __pyx_obj_7asyncpg_8protocol_8protocol_Memory)))) { + __pyx_freelist_7asyncpg_8protocol_8protocol_Memory[__pyx_freecount_7asyncpg_8protocol_8protocol_Memory++] = ((struct __pyx_obj_7asyncpg_8protocol_8protocol_Memory *)o); + } else { + (*Py_TYPE(o)->tp_free)(o); + } +} + +static int __pyx_tp_traverse_7asyncpg_8protocol_8protocol_Memory(PyObject *o, visitproc v, void *a) { + int e; + struct __pyx_obj_7asyncpg_8protocol_8protocol_Memory *p = (struct __pyx_obj_7asyncpg_8protocol_8protocol_Memory *)o; + if (p->owner) { + e = (*v)(p->owner, a); if (e) return e; + } + return 0; +} + +static PyTypeObject __pyx_type_7asyncpg_8protocol_8protocol_Memory = { + PyVarObject_HEAD_INIT(0, 0) + "asyncpg.protocol.protocol.Memory", /*tp_name*/ + sizeof(struct __pyx_obj_7asyncpg_8protocol_8protocol_Memory), /*tp_basicsize*/ + 0, /*tp_itemsize*/ + __pyx_tp_dealloc_7asyncpg_8protocol_8protocol_Memory, /*tp_dealloc*/ + 0, /*tp_print*/ + 0, /*tp_getattr*/ + 0, /*tp_setattr*/ + #if PY_MAJOR_VERSION < 3 + 0, /*tp_compare*/ + #endif + #if PY_MAJOR_VERSION >= 3 + 0, /*tp_as_async*/ + #endif + 0, /*tp_repr*/ + 0, /*tp_as_number*/ + 0, /*tp_as_sequence*/ + 0, /*tp_as_mapping*/ + 0, /*tp_hash*/ + 0, /*tp_call*/ + 0, /*tp_str*/ + 0, /*tp_getattro*/ + 0, /*tp_setattro*/ + 0, /*tp_as_buffer*/ + Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_HAVE_GC, /*tp_flags*/ + 0, /*tp_doc*/ + __pyx_tp_traverse_7asyncpg_8protocol_8protocol_Memory, /*tp_traverse*/ + 0, /*tp_clear*/ + 0, /*tp_richcompare*/ + 0, /*tp_weaklistoffset*/ + 0, /*tp_iter*/ + 0, /*tp_iternext*/ + 0, /*tp_methods*/ + 0, /*tp_members*/ + 0, /*tp_getset*/ + 0, /*tp_base*/ + 0, /*tp_dict*/ + 0, /*tp_descr_get*/ + 0, /*tp_descr_set*/ + 0, /*tp_dictoffset*/ + 0, /*tp_init*/ + 0, /*tp_alloc*/ + __pyx_tp_new_7asyncpg_8protocol_8protocol_Memory, /*tp_new*/ + 0, /*tp_free*/ + 0, /*tp_is_gc*/ + 0, /*tp_bases*/ + 0, /*tp_mro*/ + 0, /*tp_cache*/ + 0, /*tp_subclasses*/ + 0, /*tp_weaklist*/ + 0, /*tp_del*/ + 0, /*tp_version_tag*/ + #if PY_VERSION_HEX >= 0x030400a1 + 0, /*tp_finalize*/ + #endif +}; +static struct __pyx_vtabstruct_7asyncpg_8protocol_8protocol_WriteBuffer __pyx_vtable_7asyncpg_8protocol_8protocol_WriteBuffer; + +static struct __pyx_obj_7asyncpg_8protocol_8protocol_WriteBuffer *__pyx_freelist_7asyncpg_8protocol_8protocol_WriteBuffer[256]; +static int __pyx_freecount_7asyncpg_8protocol_8protocol_WriteBuffer = 0; + +static PyObject *__pyx_tp_new_7asyncpg_8protocol_8protocol_WriteBuffer(PyTypeObject *t, CYTHON_UNUSED PyObject *a, CYTHON_UNUSED PyObject *k) { + struct __pyx_obj_7asyncpg_8protocol_8protocol_WriteBuffer *p; + PyObject *o; + if (CYTHON_COMPILING_IN_CPYTHON && likely((__pyx_freecount_7asyncpg_8protocol_8protocol_WriteBuffer > 0) & (t->tp_basicsize == sizeof(struct __pyx_obj_7asyncpg_8protocol_8protocol_WriteBuffer)))) { + o = (PyObject*)__pyx_freelist_7asyncpg_8protocol_8protocol_WriteBuffer[--__pyx_freecount_7asyncpg_8protocol_8protocol_WriteBuffer]; + memset(o, 0, sizeof(struct __pyx_obj_7asyncpg_8protocol_8protocol_WriteBuffer)); + (void) PyObject_INIT(o, t); + } else { + o = (*t->tp_alloc)(t, 0); + if (unlikely(!o)) return 0; + } + p = ((struct __pyx_obj_7asyncpg_8protocol_8protocol_WriteBuffer *)o); + p->__pyx_vtab = __pyx_vtabptr_7asyncpg_8protocol_8protocol_WriteBuffer; + if (unlikely(__pyx_pw_7asyncpg_8protocol_8protocol_11WriteBuffer_1__cinit__(o, __pyx_empty_tuple, NULL) < 0)) goto bad; + return o; + bad: + Py_DECREF(o); o = 0; + return NULL; +} + +static void __pyx_tp_dealloc_7asyncpg_8protocol_8protocol_WriteBuffer(PyObject *o) { + { + PyObject *etype, *eval, *etb; + PyErr_Fetch(&etype, &eval, &etb); + ++Py_REFCNT(o); + __pyx_pw_7asyncpg_8protocol_8protocol_11WriteBuffer_3__dealloc__(o); + --Py_REFCNT(o); + PyErr_Restore(etype, eval, etb); + } + if (CYTHON_COMPILING_IN_CPYTHON && ((__pyx_freecount_7asyncpg_8protocol_8protocol_WriteBuffer < 256) & (Py_TYPE(o)->tp_basicsize == sizeof(struct __pyx_obj_7asyncpg_8protocol_8protocol_WriteBuffer)))) { + __pyx_freelist_7asyncpg_8protocol_8protocol_WriteBuffer[__pyx_freecount_7asyncpg_8protocol_8protocol_WriteBuffer++] = ((struct __pyx_obj_7asyncpg_8protocol_8protocol_WriteBuffer *)o); + } else { + (*Py_TYPE(o)->tp_free)(o); + } +} + +static PyMethodDef __pyx_methods_7asyncpg_8protocol_8protocol_WriteBuffer[] = { + {0, 0, 0, 0} +}; + +static PyBufferProcs __pyx_tp_as_buffer_WriteBuffer = { + #if PY_MAJOR_VERSION < 3 + 0, /*bf_getreadbuffer*/ + #endif + #if PY_MAJOR_VERSION < 3 + 0, /*bf_getwritebuffer*/ + #endif + #if PY_MAJOR_VERSION < 3 + 0, /*bf_getsegcount*/ + #endif + #if PY_MAJOR_VERSION < 3 + 0, /*bf_getcharbuffer*/ + #endif + __pyx_pw_7asyncpg_8protocol_8protocol_11WriteBuffer_5__getbuffer__, /*bf_getbuffer*/ + __pyx_pw_7asyncpg_8protocol_8protocol_11WriteBuffer_7__releasebuffer__, /*bf_releasebuffer*/ +}; + +static PyTypeObject __pyx_type_7asyncpg_8protocol_8protocol_WriteBuffer = { + PyVarObject_HEAD_INIT(0, 0) + "asyncpg.protocol.protocol.WriteBuffer", /*tp_name*/ + sizeof(struct __pyx_obj_7asyncpg_8protocol_8protocol_WriteBuffer), /*tp_basicsize*/ + 0, /*tp_itemsize*/ + __pyx_tp_dealloc_7asyncpg_8protocol_8protocol_WriteBuffer, /*tp_dealloc*/ + 0, /*tp_print*/ + 0, /*tp_getattr*/ + 0, /*tp_setattr*/ + #if PY_MAJOR_VERSION < 3 + 0, /*tp_compare*/ + #endif + #if PY_MAJOR_VERSION >= 3 + 0, /*tp_as_async*/ + #endif + 0, /*tp_repr*/ + 0, /*tp_as_number*/ + 0, /*tp_as_sequence*/ + 0, /*tp_as_mapping*/ + 0, /*tp_hash*/ + 0, /*tp_call*/ + 0, /*tp_str*/ + 0, /*tp_getattro*/ + 0, /*tp_setattro*/ + &__pyx_tp_as_buffer_WriteBuffer, /*tp_as_buffer*/ + Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER, /*tp_flags*/ + 0, /*tp_doc*/ + 0, /*tp_traverse*/ + 0, /*tp_clear*/ + 0, /*tp_richcompare*/ + 0, /*tp_weaklistoffset*/ + 0, /*tp_iter*/ + 0, /*tp_iternext*/ + __pyx_methods_7asyncpg_8protocol_8protocol_WriteBuffer, /*tp_methods*/ + 0, /*tp_members*/ + 0, /*tp_getset*/ + 0, /*tp_base*/ + 0, /*tp_dict*/ + 0, /*tp_descr_get*/ + 0, /*tp_descr_set*/ + 0, /*tp_dictoffset*/ + 0, /*tp_init*/ + 0, /*tp_alloc*/ + __pyx_tp_new_7asyncpg_8protocol_8protocol_WriteBuffer, /*tp_new*/ + 0, /*tp_free*/ + 0, /*tp_is_gc*/ + 0, /*tp_bases*/ + 0, /*tp_mro*/ + 0, /*tp_cache*/ + 0, /*tp_subclasses*/ + 0, /*tp_weaklist*/ + 0, /*tp_del*/ + 0, /*tp_version_tag*/ + #if PY_VERSION_HEX >= 0x030400a1 + 0, /*tp_finalize*/ + #endif +}; +static struct __pyx_vtabstruct_7asyncpg_8protocol_8protocol_ReadBuffer __pyx_vtable_7asyncpg_8protocol_8protocol_ReadBuffer; + +static struct __pyx_obj_7asyncpg_8protocol_8protocol_ReadBuffer *__pyx_freelist_7asyncpg_8protocol_8protocol_ReadBuffer[256]; +static int __pyx_freecount_7asyncpg_8protocol_8protocol_ReadBuffer = 0; + +static PyObject *__pyx_tp_new_7asyncpg_8protocol_8protocol_ReadBuffer(PyTypeObject *t, CYTHON_UNUSED PyObject *a, CYTHON_UNUSED PyObject *k) { + struct __pyx_obj_7asyncpg_8protocol_8protocol_ReadBuffer *p; + PyObject *o; + if (CYTHON_COMPILING_IN_CPYTHON && likely((__pyx_freecount_7asyncpg_8protocol_8protocol_ReadBuffer > 0) & (t->tp_basicsize == sizeof(struct __pyx_obj_7asyncpg_8protocol_8protocol_ReadBuffer)))) { + o = (PyObject*)__pyx_freelist_7asyncpg_8protocol_8protocol_ReadBuffer[--__pyx_freecount_7asyncpg_8protocol_8protocol_ReadBuffer]; + memset(o, 0, sizeof(struct __pyx_obj_7asyncpg_8protocol_8protocol_ReadBuffer)); + (void) PyObject_INIT(o, t); + PyObject_GC_Track(o); + } else { + o = (*t->tp_alloc)(t, 0); + if (unlikely(!o)) return 0; + } + p = ((struct __pyx_obj_7asyncpg_8protocol_8protocol_ReadBuffer *)o); + p->__pyx_vtab = __pyx_vtabptr_7asyncpg_8protocol_8protocol_ReadBuffer; + p->_bufs = Py_None; Py_INCREF(Py_None); + p->_bufs_append = Py_None; Py_INCREF(Py_None); + p->_bufs_popleft = Py_None; Py_INCREF(Py_None); + p->_buf0 = ((PyObject*)Py_None); Py_INCREF(Py_None); + p->_buf0_prev = ((PyObject*)Py_None); Py_INCREF(Py_None); + if (unlikely(__pyx_pw_7asyncpg_8protocol_8protocol_10ReadBuffer_1__cinit__(o, __pyx_empty_tuple, NULL) < 0)) goto bad; + return o; + bad: + Py_DECREF(o); o = 0; + return NULL; +} + +static void __pyx_tp_dealloc_7asyncpg_8protocol_8protocol_ReadBuffer(PyObject *o) { + struct __pyx_obj_7asyncpg_8protocol_8protocol_ReadBuffer *p = (struct __pyx_obj_7asyncpg_8protocol_8protocol_ReadBuffer *)o; + PyObject_GC_UnTrack(o); + Py_CLEAR(p->_bufs); + Py_CLEAR(p->_bufs_append); + Py_CLEAR(p->_bufs_popleft); + Py_CLEAR(p->_buf0); + Py_CLEAR(p->_buf0_prev); + if (CYTHON_COMPILING_IN_CPYTHON && ((__pyx_freecount_7asyncpg_8protocol_8protocol_ReadBuffer < 256) & (Py_TYPE(o)->tp_basicsize == sizeof(struct __pyx_obj_7asyncpg_8protocol_8protocol_ReadBuffer)))) { + __pyx_freelist_7asyncpg_8protocol_8protocol_ReadBuffer[__pyx_freecount_7asyncpg_8protocol_8protocol_ReadBuffer++] = ((struct __pyx_obj_7asyncpg_8protocol_8protocol_ReadBuffer *)o); + } else { + (*Py_TYPE(o)->tp_free)(o); + } +} + +static int __pyx_tp_traverse_7asyncpg_8protocol_8protocol_ReadBuffer(PyObject *o, visitproc v, void *a) { + int e; + struct __pyx_obj_7asyncpg_8protocol_8protocol_ReadBuffer *p = (struct __pyx_obj_7asyncpg_8protocol_8protocol_ReadBuffer *)o; + if (p->_bufs) { + e = (*v)(p->_bufs, a); if (e) return e; + } + if (p->_bufs_append) { + e = (*v)(p->_bufs_append, a); if (e) return e; + } + if (p->_bufs_popleft) { + e = (*v)(p->_bufs_popleft, a); if (e) return e; + } + return 0; +} + +static PyMethodDef __pyx_methods_7asyncpg_8protocol_8protocol_ReadBuffer[] = { + {0, 0, 0, 0} +}; + +static PyTypeObject __pyx_type_7asyncpg_8protocol_8protocol_ReadBuffer = { + PyVarObject_HEAD_INIT(0, 0) + "asyncpg.protocol.protocol.ReadBuffer", /*tp_name*/ + sizeof(struct __pyx_obj_7asyncpg_8protocol_8protocol_ReadBuffer), /*tp_basicsize*/ + 0, /*tp_itemsize*/ + __pyx_tp_dealloc_7asyncpg_8protocol_8protocol_ReadBuffer, /*tp_dealloc*/ + 0, /*tp_print*/ + 0, /*tp_getattr*/ + 0, /*tp_setattr*/ + #if PY_MAJOR_VERSION < 3 + 0, /*tp_compare*/ + #endif + #if PY_MAJOR_VERSION >= 3 + 0, /*tp_as_async*/ + #endif + 0, /*tp_repr*/ + 0, /*tp_as_number*/ + 0, /*tp_as_sequence*/ + 0, /*tp_as_mapping*/ + 0, /*tp_hash*/ + 0, /*tp_call*/ + 0, /*tp_str*/ + 0, /*tp_getattro*/ + 0, /*tp_setattro*/ + 0, /*tp_as_buffer*/ + Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_HAVE_GC, /*tp_flags*/ + 0, /*tp_doc*/ + __pyx_tp_traverse_7asyncpg_8protocol_8protocol_ReadBuffer, /*tp_traverse*/ + 0, /*tp_clear*/ + 0, /*tp_richcompare*/ + 0, /*tp_weaklistoffset*/ + 0, /*tp_iter*/ + 0, /*tp_iternext*/ + __pyx_methods_7asyncpg_8protocol_8protocol_ReadBuffer, /*tp_methods*/ + 0, /*tp_members*/ + 0, /*tp_getset*/ + 0, /*tp_base*/ + 0, /*tp_dict*/ + 0, /*tp_descr_get*/ + 0, /*tp_descr_set*/ + 0, /*tp_dictoffset*/ + 0, /*tp_init*/ + 0, /*tp_alloc*/ + __pyx_tp_new_7asyncpg_8protocol_8protocol_ReadBuffer, /*tp_new*/ + 0, /*tp_free*/ + 0, /*tp_is_gc*/ + 0, /*tp_bases*/ + 0, /*tp_mro*/ + 0, /*tp_cache*/ + 0, /*tp_subclasses*/ + 0, /*tp_weaklist*/ + 0, /*tp_del*/ + 0, /*tp_version_tag*/ + #if PY_VERSION_HEX >= 0x030400a1 + 0, /*tp_finalize*/ + #endif +}; +static struct __pyx_vtabstruct_7asyncpg_8protocol_8protocol_FastReadBuffer __pyx_vtable_7asyncpg_8protocol_8protocol_FastReadBuffer; + +static struct __pyx_obj_7asyncpg_8protocol_8protocol_FastReadBuffer *__pyx_freelist_7asyncpg_8protocol_8protocol_FastReadBuffer[256]; +static int __pyx_freecount_7asyncpg_8protocol_8protocol_FastReadBuffer = 0; + +static PyObject *__pyx_tp_new_7asyncpg_8protocol_8protocol_FastReadBuffer(PyTypeObject *t, CYTHON_UNUSED PyObject *a, CYTHON_UNUSED PyObject *k) { + struct __pyx_obj_7asyncpg_8protocol_8protocol_FastReadBuffer *p; + PyObject *o; + if (CYTHON_COMPILING_IN_CPYTHON && likely((__pyx_freecount_7asyncpg_8protocol_8protocol_FastReadBuffer > 0) & (t->tp_basicsize == sizeof(struct __pyx_obj_7asyncpg_8protocol_8protocol_FastReadBuffer)))) { + o = (PyObject*)__pyx_freelist_7asyncpg_8protocol_8protocol_FastReadBuffer[--__pyx_freecount_7asyncpg_8protocol_8protocol_FastReadBuffer]; + memset(o, 0, sizeof(struct __pyx_obj_7asyncpg_8protocol_8protocol_FastReadBuffer)); + (void) PyObject_INIT(o, t); + } else { + o = (*t->tp_alloc)(t, 0); + if (unlikely(!o)) return 0; + } + p = ((struct __pyx_obj_7asyncpg_8protocol_8protocol_FastReadBuffer *)o); + p->__pyx_vtab = __pyx_vtabptr_7asyncpg_8protocol_8protocol_FastReadBuffer; + return o; +} + +static void __pyx_tp_dealloc_7asyncpg_8protocol_8protocol_FastReadBuffer(PyObject *o) { + if (CYTHON_COMPILING_IN_CPYTHON && ((__pyx_freecount_7asyncpg_8protocol_8protocol_FastReadBuffer < 256) & (Py_TYPE(o)->tp_basicsize == sizeof(struct __pyx_obj_7asyncpg_8protocol_8protocol_FastReadBuffer)))) { + __pyx_freelist_7asyncpg_8protocol_8protocol_FastReadBuffer[__pyx_freecount_7asyncpg_8protocol_8protocol_FastReadBuffer++] = ((struct __pyx_obj_7asyncpg_8protocol_8protocol_FastReadBuffer *)o); + } else { + (*Py_TYPE(o)->tp_free)(o); + } +} + +static PyTypeObject __pyx_type_7asyncpg_8protocol_8protocol_FastReadBuffer = { + PyVarObject_HEAD_INIT(0, 0) + "asyncpg.protocol.protocol.FastReadBuffer", /*tp_name*/ + sizeof(struct __pyx_obj_7asyncpg_8protocol_8protocol_FastReadBuffer), /*tp_basicsize*/ + 0, /*tp_itemsize*/ + __pyx_tp_dealloc_7asyncpg_8protocol_8protocol_FastReadBuffer, /*tp_dealloc*/ + 0, /*tp_print*/ + 0, /*tp_getattr*/ + 0, /*tp_setattr*/ + #if PY_MAJOR_VERSION < 3 + 0, /*tp_compare*/ + #endif + #if PY_MAJOR_VERSION >= 3 + 0, /*tp_as_async*/ + #endif + 0, /*tp_repr*/ + 0, /*tp_as_number*/ + 0, /*tp_as_sequence*/ + 0, /*tp_as_mapping*/ + 0, /*tp_hash*/ + 0, /*tp_call*/ + 0, /*tp_str*/ + 0, /*tp_getattro*/ + 0, /*tp_setattro*/ + 0, /*tp_as_buffer*/ + Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER, /*tp_flags*/ + 0, /*tp_doc*/ + 0, /*tp_traverse*/ + 0, /*tp_clear*/ + 0, /*tp_richcompare*/ + 0, /*tp_weaklistoffset*/ + 0, /*tp_iter*/ + 0, /*tp_iternext*/ + 0, /*tp_methods*/ + 0, /*tp_members*/ + 0, /*tp_getset*/ + 0, /*tp_base*/ + 0, /*tp_dict*/ + 0, /*tp_descr_get*/ + 0, /*tp_descr_set*/ + 0, /*tp_dictoffset*/ + 0, /*tp_init*/ + 0, /*tp_alloc*/ + __pyx_tp_new_7asyncpg_8protocol_8protocol_FastReadBuffer, /*tp_new*/ + 0, /*tp_free*/ + 0, /*tp_is_gc*/ + 0, /*tp_bases*/ + 0, /*tp_mro*/ + 0, /*tp_cache*/ + 0, /*tp_subclasses*/ + 0, /*tp_weaklist*/ + 0, /*tp_del*/ + 0, /*tp_version_tag*/ + #if PY_VERSION_HEX >= 0x030400a1 + 0, /*tp_finalize*/ + #endif +}; +static struct __pyx_vtabstruct_7asyncpg_8protocol_8protocol_Codec __pyx_vtable_7asyncpg_8protocol_8protocol_Codec; + +static PyObject *__pyx_tp_new_7asyncpg_8protocol_8protocol_Codec(PyTypeObject *t, PyObject *a, PyObject *k) { + struct __pyx_obj_7asyncpg_8protocol_8protocol_Codec *p; + PyObject *o; + o = (*t->tp_alloc)(t, 0); + if (unlikely(!o)) return 0; + p = ((struct __pyx_obj_7asyncpg_8protocol_8protocol_Codec *)o); + p->__pyx_vtab = __pyx_vtabptr_7asyncpg_8protocol_8protocol_Codec; + p->name = ((PyObject*)Py_None); Py_INCREF(Py_None); + p->schema = ((PyObject*)Py_None); Py_INCREF(Py_None); + p->kind = ((PyObject*)Py_None); Py_INCREF(Py_None); + p->py_encoder = Py_None; Py_INCREF(Py_None); + p->py_decoder = Py_None; Py_INCREF(Py_None); + p->element_codec = ((struct __pyx_obj_7asyncpg_8protocol_8protocol_Codec *)Py_None); Py_INCREF(Py_None); + p->element_type_oids = ((PyObject*)Py_None); Py_INCREF(Py_None); + p->element_names = Py_None; Py_INCREF(Py_None); + p->element_codecs = ((PyObject*)Py_None); Py_INCREF(Py_None); + if (unlikely(__pyx_pw_7asyncpg_8protocol_8protocol_5Codec_1__cinit__(o, a, k) < 0)) goto bad; + return o; + bad: + Py_DECREF(o); o = 0; + return NULL; +} + +static void __pyx_tp_dealloc_7asyncpg_8protocol_8protocol_Codec(PyObject *o) { + struct __pyx_obj_7asyncpg_8protocol_8protocol_Codec *p = (struct __pyx_obj_7asyncpg_8protocol_8protocol_Codec *)o; + PyObject_GC_UnTrack(o); + Py_CLEAR(p->name); + Py_CLEAR(p->schema); + Py_CLEAR(p->kind); + Py_CLEAR(p->py_encoder); + Py_CLEAR(p->py_decoder); + Py_CLEAR(p->element_codec); + Py_CLEAR(p->element_type_oids); + Py_CLEAR(p->element_names); + Py_CLEAR(p->element_codecs); + (*Py_TYPE(o)->tp_free)(o); +} + +static int __pyx_tp_traverse_7asyncpg_8protocol_8protocol_Codec(PyObject *o, visitproc v, void *a) { + int e; + struct __pyx_obj_7asyncpg_8protocol_8protocol_Codec *p = (struct __pyx_obj_7asyncpg_8protocol_8protocol_Codec *)o; + if (p->py_encoder) { + e = (*v)(p->py_encoder, a); if (e) return e; + } + if (p->py_decoder) { + e = (*v)(p->py_decoder, a); if (e) return e; + } + if (p->element_codec) { + e = (*v)(((PyObject*)p->element_codec), a); if (e) return e; + } + if (p->element_type_oids) { + e = (*v)(p->element_type_oids, a); if (e) return e; + } + if (p->element_names) { + e = (*v)(p->element_names, a); if (e) return e; + } + if (p->element_codecs) { + e = (*v)(p->element_codecs, a); if (e) return e; + } + return 0; +} + +static int __pyx_tp_clear_7asyncpg_8protocol_8protocol_Codec(PyObject *o) { + PyObject* tmp; + struct __pyx_obj_7asyncpg_8protocol_8protocol_Codec *p = (struct __pyx_obj_7asyncpg_8protocol_8protocol_Codec *)o; + tmp = ((PyObject*)p->py_encoder); + p->py_encoder = Py_None; Py_INCREF(Py_None); + Py_XDECREF(tmp); + tmp = ((PyObject*)p->py_decoder); + p->py_decoder = Py_None; Py_INCREF(Py_None); + Py_XDECREF(tmp); + tmp = ((PyObject*)p->element_codec); + p->element_codec = ((struct __pyx_obj_7asyncpg_8protocol_8protocol_Codec *)Py_None); Py_INCREF(Py_None); + Py_XDECREF(tmp); + tmp = ((PyObject*)p->element_type_oids); + p->element_type_oids = ((PyObject*)Py_None); Py_INCREF(Py_None); + Py_XDECREF(tmp); + tmp = ((PyObject*)p->element_names); + p->element_names = Py_None; Py_INCREF(Py_None); + Py_XDECREF(tmp); + tmp = ((PyObject*)p->element_codecs); + p->element_codecs = ((PyObject*)Py_None); Py_INCREF(Py_None); + Py_XDECREF(tmp); + return 0; +} + +static PyMethodDef __pyx_methods_7asyncpg_8protocol_8protocol_Codec[] = { + {0, 0, 0, 0} +}; + +static PyTypeObject __pyx_type_7asyncpg_8protocol_8protocol_Codec = { + PyVarObject_HEAD_INIT(0, 0) + "asyncpg.protocol.protocol.Codec", /*tp_name*/ + sizeof(struct __pyx_obj_7asyncpg_8protocol_8protocol_Codec), /*tp_basicsize*/ + 0, /*tp_itemsize*/ + __pyx_tp_dealloc_7asyncpg_8protocol_8protocol_Codec, /*tp_dealloc*/ + 0, /*tp_print*/ + 0, /*tp_getattr*/ + 0, /*tp_setattr*/ + #if PY_MAJOR_VERSION < 3 + 0, /*tp_compare*/ + #endif + #if PY_MAJOR_VERSION >= 3 + 0, /*tp_as_async*/ + #endif + __pyx_pw_7asyncpg_8protocol_8protocol_5Codec_3__repr__, /*tp_repr*/ + 0, /*tp_as_number*/ + 0, /*tp_as_sequence*/ + 0, /*tp_as_mapping*/ + 0, /*tp_hash*/ + 0, /*tp_call*/ + 0, /*tp_str*/ + 0, /*tp_getattro*/ + 0, /*tp_setattro*/ + 0, /*tp_as_buffer*/ + Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_HAVE_GC, /*tp_flags*/ + 0, /*tp_doc*/ + __pyx_tp_traverse_7asyncpg_8protocol_8protocol_Codec, /*tp_traverse*/ + __pyx_tp_clear_7asyncpg_8protocol_8protocol_Codec, /*tp_clear*/ + 0, /*tp_richcompare*/ + 0, /*tp_weaklistoffset*/ + 0, /*tp_iter*/ + 0, /*tp_iternext*/ + __pyx_methods_7asyncpg_8protocol_8protocol_Codec, /*tp_methods*/ + 0, /*tp_members*/ + 0, /*tp_getset*/ + 0, /*tp_base*/ + 0, /*tp_dict*/ + 0, /*tp_descr_get*/ + 0, /*tp_descr_set*/ + 0, /*tp_dictoffset*/ + 0, /*tp_init*/ + 0, /*tp_alloc*/ + __pyx_tp_new_7asyncpg_8protocol_8protocol_Codec, /*tp_new*/ + 0, /*tp_free*/ + 0, /*tp_is_gc*/ + 0, /*tp_bases*/ + 0, /*tp_mro*/ + 0, /*tp_cache*/ + 0, /*tp_subclasses*/ + 0, /*tp_weaklist*/ + 0, /*tp_del*/ + 0, /*tp_version_tag*/ + #if PY_VERSION_HEX >= 0x030400a1 + 0, /*tp_finalize*/ + #endif +}; +static struct __pyx_vtabstruct_7asyncpg_8protocol_8protocol_DataCodecConfig __pyx_vtable_7asyncpg_8protocol_8protocol_DataCodecConfig; + +static PyObject *__pyx_tp_new_7asyncpg_8protocol_8protocol_DataCodecConfig(PyTypeObject *t, CYTHON_UNUSED PyObject *a, CYTHON_UNUSED PyObject *k) { + struct __pyx_obj_7asyncpg_8protocol_8protocol_DataCodecConfig *p; + PyObject *o; + if (likely((t->tp_flags & Py_TPFLAGS_IS_ABSTRACT) == 0)) { + o = (*t->tp_alloc)(t, 0); + } else { + o = (PyObject *) PyBaseObject_Type.tp_new(t, __pyx_empty_tuple, 0); + } + if (unlikely(!o)) return 0; + p = ((struct __pyx_obj_7asyncpg_8protocol_8protocol_DataCodecConfig *)o); + p->__pyx_vtab = __pyx_vtabptr_7asyncpg_8protocol_8protocol_DataCodecConfig; + p->_type_codecs_cache = ((PyObject*)Py_None); Py_INCREF(Py_None); + p->_local_type_codecs = ((PyObject*)Py_None); Py_INCREF(Py_None); + return o; +} + +static void __pyx_tp_dealloc_7asyncpg_8protocol_8protocol_DataCodecConfig(PyObject *o) { + struct __pyx_obj_7asyncpg_8protocol_8protocol_DataCodecConfig *p = (struct __pyx_obj_7asyncpg_8protocol_8protocol_DataCodecConfig *)o; + #if PY_VERSION_HEX >= 0x030400a1 + if (unlikely(Py_TYPE(o)->tp_finalize) && !_PyGC_FINALIZED(o)) { + if (PyObject_CallFinalizerFromDealloc(o)) return; + } + #endif + PyObject_GC_UnTrack(o); + Py_CLEAR(p->_type_codecs_cache); + Py_CLEAR(p->_local_type_codecs); + (*Py_TYPE(o)->tp_free)(o); +} + +static int __pyx_tp_traverse_7asyncpg_8protocol_8protocol_DataCodecConfig(PyObject *o, visitproc v, void *a) { + int e; + struct __pyx_obj_7asyncpg_8protocol_8protocol_DataCodecConfig *p = (struct __pyx_obj_7asyncpg_8protocol_8protocol_DataCodecConfig *)o; + if (p->_type_codecs_cache) { + e = (*v)(p->_type_codecs_cache, a); if (e) return e; + } + if (p->_local_type_codecs) { + e = (*v)(p->_local_type_codecs, a); if (e) return e; + } + return 0; +} + +static int __pyx_tp_clear_7asyncpg_8protocol_8protocol_DataCodecConfig(PyObject *o) { + PyObject* tmp; + struct __pyx_obj_7asyncpg_8protocol_8protocol_DataCodecConfig *p = (struct __pyx_obj_7asyncpg_8protocol_8protocol_DataCodecConfig *)o; + tmp = ((PyObject*)p->_type_codecs_cache); + p->_type_codecs_cache = ((PyObject*)Py_None); Py_INCREF(Py_None); + Py_XDECREF(tmp); + tmp = ((PyObject*)p->_local_type_codecs); + p->_local_type_codecs = ((PyObject*)Py_None); Py_INCREF(Py_None); + Py_XDECREF(tmp); + return 0; +} + +static PyMethodDef __pyx_methods_7asyncpg_8protocol_8protocol_DataCodecConfig[] = { + {"add_types", (PyCFunction)__pyx_pw_7asyncpg_8protocol_8protocol_15DataCodecConfig_3add_types, METH_O, 0}, + {"add_python_codec", (PyCFunction)__pyx_pw_7asyncpg_8protocol_8protocol_15DataCodecConfig_5add_python_codec, METH_VARARGS|METH_KEYWORDS, 0}, + {"set_builtin_type_codec", (PyCFunction)__pyx_pw_7asyncpg_8protocol_8protocol_15DataCodecConfig_7set_builtin_type_codec, METH_VARARGS|METH_KEYWORDS, 0}, + {"clear_type_cache", (PyCFunction)__pyx_pw_7asyncpg_8protocol_8protocol_15DataCodecConfig_9clear_type_cache, METH_NOARGS, 0}, + {0, 0, 0, 0} +}; + +static PyTypeObject __pyx_type_7asyncpg_8protocol_8protocol_DataCodecConfig = { + PyVarObject_HEAD_INIT(0, 0) + "asyncpg.protocol.protocol.DataCodecConfig", /*tp_name*/ + sizeof(struct __pyx_obj_7asyncpg_8protocol_8protocol_DataCodecConfig), /*tp_basicsize*/ + 0, /*tp_itemsize*/ + __pyx_tp_dealloc_7asyncpg_8protocol_8protocol_DataCodecConfig, /*tp_dealloc*/ + 0, /*tp_print*/ + 0, /*tp_getattr*/ + 0, /*tp_setattr*/ + #if PY_MAJOR_VERSION < 3 + 0, /*tp_compare*/ + #endif + #if PY_MAJOR_VERSION >= 3 + 0, /*tp_as_async*/ + #endif + 0, /*tp_repr*/ + 0, /*tp_as_number*/ + 0, /*tp_as_sequence*/ + 0, /*tp_as_mapping*/ + 0, /*tp_hash*/ + 0, /*tp_call*/ + 0, /*tp_str*/ + 0, /*tp_getattro*/ + 0, /*tp_setattro*/ + 0, /*tp_as_buffer*/ + Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_HAVE_GC, /*tp_flags*/ + 0, /*tp_doc*/ + __pyx_tp_traverse_7asyncpg_8protocol_8protocol_DataCodecConfig, /*tp_traverse*/ + __pyx_tp_clear_7asyncpg_8protocol_8protocol_DataCodecConfig, /*tp_clear*/ + 0, /*tp_richcompare*/ + 0, /*tp_weaklistoffset*/ + 0, /*tp_iter*/ + 0, /*tp_iternext*/ + __pyx_methods_7asyncpg_8protocol_8protocol_DataCodecConfig, /*tp_methods*/ + 0, /*tp_members*/ + 0, /*tp_getset*/ + 0, /*tp_base*/ + 0, /*tp_dict*/ + 0, /*tp_descr_get*/ + 0, /*tp_descr_set*/ + 0, /*tp_dictoffset*/ + __pyx_pw_7asyncpg_8protocol_8protocol_15DataCodecConfig_1__init__, /*tp_init*/ + 0, /*tp_alloc*/ + __pyx_tp_new_7asyncpg_8protocol_8protocol_DataCodecConfig, /*tp_new*/ + 0, /*tp_free*/ + 0, /*tp_is_gc*/ + 0, /*tp_bases*/ + 0, /*tp_mro*/ + 0, /*tp_cache*/ + 0, /*tp_subclasses*/ + 0, /*tp_weaklist*/ + 0, /*tp_del*/ + 0, /*tp_version_tag*/ + #if PY_VERSION_HEX >= 0x030400a1 + 0, /*tp_finalize*/ + #endif +}; +static struct __pyx_vtabstruct_7asyncpg_8protocol_8protocol_ConnectionSettings __pyx_vtable_7asyncpg_8protocol_8protocol_ConnectionSettings; + +static PyObject *__pyx_tp_new_7asyncpg_8protocol_8protocol_ConnectionSettings(PyTypeObject *t, PyObject *a, PyObject *k) { + struct __pyx_obj_7asyncpg_8protocol_8protocol_ConnectionSettings *p; + PyObject *o; + o = (*t->tp_alloc)(t, 0); + if (unlikely(!o)) return 0; + p = ((struct __pyx_obj_7asyncpg_8protocol_8protocol_ConnectionSettings *)o); + p->__pyx_vtab = __pyx_vtabptr_7asyncpg_8protocol_8protocol_ConnectionSettings; + p->_encoding = ((PyObject*)Py_None); Py_INCREF(Py_None); + p->_codec = Py_None; Py_INCREF(Py_None); + p->_settings = ((PyObject*)Py_None); Py_INCREF(Py_None); + p->_data_codecs = ((struct __pyx_obj_7asyncpg_8protocol_8protocol_DataCodecConfig *)Py_None); Py_INCREF(Py_None); + if (unlikely(__pyx_pw_7asyncpg_8protocol_8protocol_18ConnectionSettings_1__cinit__(o, a, k) < 0)) goto bad; + return o; + bad: + Py_DECREF(o); o = 0; + return NULL; +} + +static void __pyx_tp_dealloc_7asyncpg_8protocol_8protocol_ConnectionSettings(PyObject *o) { + struct __pyx_obj_7asyncpg_8protocol_8protocol_ConnectionSettings *p = (struct __pyx_obj_7asyncpg_8protocol_8protocol_ConnectionSettings *)o; + PyObject_GC_UnTrack(o); + Py_CLEAR(p->_encoding); + Py_CLEAR(p->_codec); + Py_CLEAR(p->_settings); + Py_CLEAR(p->_data_codecs); + (*Py_TYPE(o)->tp_free)(o); +} + +static int __pyx_tp_traverse_7asyncpg_8protocol_8protocol_ConnectionSettings(PyObject *o, visitproc v, void *a) { + int e; + struct __pyx_obj_7asyncpg_8protocol_8protocol_ConnectionSettings *p = (struct __pyx_obj_7asyncpg_8protocol_8protocol_ConnectionSettings *)o; + if (p->_codec) { + e = (*v)(p->_codec, a); if (e) return e; + } + if (p->_settings) { + e = (*v)(p->_settings, a); if (e) return e; + } + if (p->_data_codecs) { + e = (*v)(((PyObject*)p->_data_codecs), a); if (e) return e; + } + return 0; +} + +static int __pyx_tp_clear_7asyncpg_8protocol_8protocol_ConnectionSettings(PyObject *o) { + PyObject* tmp; + struct __pyx_obj_7asyncpg_8protocol_8protocol_ConnectionSettings *p = (struct __pyx_obj_7asyncpg_8protocol_8protocol_ConnectionSettings *)o; + tmp = ((PyObject*)p->_codec); + p->_codec = Py_None; Py_INCREF(Py_None); + Py_XDECREF(tmp); + tmp = ((PyObject*)p->_settings); + p->_settings = ((PyObject*)Py_None); Py_INCREF(Py_None); + Py_XDECREF(tmp); + tmp = ((PyObject*)p->_data_codecs); + p->_data_codecs = ((struct __pyx_obj_7asyncpg_8protocol_8protocol_DataCodecConfig *)Py_None); Py_INCREF(Py_None); + Py_XDECREF(tmp); + return 0; +} + +static PyObject *__pyx_tp_getattro_7asyncpg_8protocol_8protocol_ConnectionSettings(PyObject *o, PyObject *n) { + PyObject *v = PyObject_GenericGetAttr(o, n); + if (!v && PyErr_ExceptionMatches(PyExc_AttributeError)) { + PyErr_Clear(); + v = __pyx_pw_7asyncpg_8protocol_8protocol_18ConnectionSettings_13__getattr__(o, n); + } + return v; +} + +static PyMethodDef __pyx_methods_7asyncpg_8protocol_8protocol_ConnectionSettings[] = { + {"get_text_codec", (PyCFunction)__pyx_pw_7asyncpg_8protocol_8protocol_18ConnectionSettings_3get_text_codec, METH_NOARGS, 0}, + {"register_data_types", (PyCFunction)__pyx_pw_7asyncpg_8protocol_8protocol_18ConnectionSettings_5register_data_types, METH_O, 0}, + {"add_python_codec", (PyCFunction)__pyx_pw_7asyncpg_8protocol_8protocol_18ConnectionSettings_7add_python_codec, METH_VARARGS|METH_KEYWORDS, 0}, + {"set_builtin_type_codec", (PyCFunction)__pyx_pw_7asyncpg_8protocol_8protocol_18ConnectionSettings_9set_builtin_type_codec, METH_VARARGS|METH_KEYWORDS, 0}, + {"get_data_codec", (PyCFunction)__pyx_pw_7asyncpg_8protocol_8protocol_18ConnectionSettings_11get_data_codec, METH_VARARGS|METH_KEYWORDS, 0}, + {"__getattr__", (PyCFunction)__pyx_pw_7asyncpg_8protocol_8protocol_18ConnectionSettings_13__getattr__, METH_O|METH_COEXIST, 0}, + {0, 0, 0, 0} +}; + +static PyTypeObject __pyx_type_7asyncpg_8protocol_8protocol_ConnectionSettings = { + PyVarObject_HEAD_INIT(0, 0) + "asyncpg.protocol.protocol.ConnectionSettings", /*tp_name*/ + sizeof(struct __pyx_obj_7asyncpg_8protocol_8protocol_ConnectionSettings), /*tp_basicsize*/ + 0, /*tp_itemsize*/ + __pyx_tp_dealloc_7asyncpg_8protocol_8protocol_ConnectionSettings, /*tp_dealloc*/ + 0, /*tp_print*/ + 0, /*tp_getattr*/ + 0, /*tp_setattr*/ + #if PY_MAJOR_VERSION < 3 + 0, /*tp_compare*/ + #endif + #if PY_MAJOR_VERSION >= 3 + 0, /*tp_as_async*/ + #endif + 0, /*tp_repr*/ + 0, /*tp_as_number*/ + 0, /*tp_as_sequence*/ + 0, /*tp_as_mapping*/ + 0, /*tp_hash*/ + 0, /*tp_call*/ + 0, /*tp_str*/ + __pyx_tp_getattro_7asyncpg_8protocol_8protocol_ConnectionSettings, /*tp_getattro*/ + 0, /*tp_setattro*/ + 0, /*tp_as_buffer*/ + Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_HAVE_GC, /*tp_flags*/ + 0, /*tp_doc*/ + __pyx_tp_traverse_7asyncpg_8protocol_8protocol_ConnectionSettings, /*tp_traverse*/ + __pyx_tp_clear_7asyncpg_8protocol_8protocol_ConnectionSettings, /*tp_clear*/ + 0, /*tp_richcompare*/ + 0, /*tp_weaklistoffset*/ + 0, /*tp_iter*/ + 0, /*tp_iternext*/ + __pyx_methods_7asyncpg_8protocol_8protocol_ConnectionSettings, /*tp_methods*/ + 0, /*tp_members*/ + 0, /*tp_getset*/ + 0, /*tp_base*/ + 0, /*tp_dict*/ + 0, /*tp_descr_get*/ + 0, /*tp_descr_set*/ + 0, /*tp_dictoffset*/ + 0, /*tp_init*/ + 0, /*tp_alloc*/ + __pyx_tp_new_7asyncpg_8protocol_8protocol_ConnectionSettings, /*tp_new*/ + 0, /*tp_free*/ + 0, /*tp_is_gc*/ + 0, /*tp_bases*/ + 0, /*tp_mro*/ + 0, /*tp_cache*/ + 0, /*tp_subclasses*/ + 0, /*tp_weaklist*/ + 0, /*tp_del*/ + 0, /*tp_version_tag*/ + #if PY_VERSION_HEX >= 0x030400a1 + 0, /*tp_finalize*/ + #endif +}; +static struct __pyx_vtabstruct_7asyncpg_8protocol_8protocol_CoreProtocol __pyx_vtable_7asyncpg_8protocol_8protocol_CoreProtocol; + +static PyObject *__pyx_tp_new_7asyncpg_8protocol_8protocol_CoreProtocol(PyTypeObject *t, CYTHON_UNUSED PyObject *a, CYTHON_UNUSED PyObject *k) { + struct __pyx_obj_7asyncpg_8protocol_8protocol_CoreProtocol *p; + PyObject *o; + if (likely((t->tp_flags & Py_TPFLAGS_IS_ABSTRACT) == 0)) { + o = (*t->tp_alloc)(t, 0); + } else { + o = (PyObject *) PyBaseObject_Type.tp_new(t, __pyx_empty_tuple, 0); + } + if (unlikely(!o)) return 0; + p = ((struct __pyx_obj_7asyncpg_8protocol_8protocol_CoreProtocol *)o); + p->__pyx_vtab = __pyx_vtabptr_7asyncpg_8protocol_8protocol_CoreProtocol; + p->buffer = ((struct __pyx_obj_7asyncpg_8protocol_8protocol_ReadBuffer *)Py_None); Py_INCREF(Py_None); + p->_execute_iter = Py_None; Py_INCREF(Py_None); + p->_execute_portal_name = ((PyObject*)Py_None); Py_INCREF(Py_None); + p->_execute_stmt_name = ((PyObject*)Py_None); Py_INCREF(Py_None); + p->encoding = ((PyObject*)Py_None); Py_INCREF(Py_None); + p->transport = Py_None; Py_INCREF(Py_None); + p->con_args = ((PyObject*)Py_None); Py_INCREF(Py_None); + p->result = Py_None; Py_INCREF(Py_None); + p->result_param_desc = ((PyObject*)Py_None); Py_INCREF(Py_None); + p->result_row_desc = ((PyObject*)Py_None); Py_INCREF(Py_None); + p->result_status_msg = ((PyObject*)Py_None); Py_INCREF(Py_None); + return o; +} + +static void __pyx_tp_dealloc_7asyncpg_8protocol_8protocol_CoreProtocol(PyObject *o) { + struct __pyx_obj_7asyncpg_8protocol_8protocol_CoreProtocol *p = (struct __pyx_obj_7asyncpg_8protocol_8protocol_CoreProtocol *)o; + #if PY_VERSION_HEX >= 0x030400a1 + if (unlikely(Py_TYPE(o)->tp_finalize) && !_PyGC_FINALIZED(o)) { + if (PyObject_CallFinalizerFromDealloc(o)) return; + } + #endif + PyObject_GC_UnTrack(o); + Py_CLEAR(p->buffer); + Py_CLEAR(p->_execute_iter); + Py_CLEAR(p->_execute_portal_name); + Py_CLEAR(p->_execute_stmt_name); + Py_CLEAR(p->encoding); + Py_CLEAR(p->transport); + Py_CLEAR(p->con_args); + Py_CLEAR(p->result); + Py_CLEAR(p->result_param_desc); + Py_CLEAR(p->result_row_desc); + Py_CLEAR(p->result_status_msg); + (*Py_TYPE(o)->tp_free)(o); +} + +static int __pyx_tp_traverse_7asyncpg_8protocol_8protocol_CoreProtocol(PyObject *o, visitproc v, void *a) { + int e; + struct __pyx_obj_7asyncpg_8protocol_8protocol_CoreProtocol *p = (struct __pyx_obj_7asyncpg_8protocol_8protocol_CoreProtocol *)o; + if (p->buffer) { + e = (*v)(((PyObject*)p->buffer), a); if (e) return e; + } + if (p->_execute_iter) { + e = (*v)(p->_execute_iter, a); if (e) return e; + } + if (p->transport) { + e = (*v)(p->transport, a); if (e) return e; + } + if (p->con_args) { + e = (*v)(p->con_args, a); if (e) return e; + } + if (p->result) { + e = (*v)(p->result, a); if (e) return e; + } + return 0; +} + +static int __pyx_tp_clear_7asyncpg_8protocol_8protocol_CoreProtocol(PyObject *o) { + PyObject* tmp; + struct __pyx_obj_7asyncpg_8protocol_8protocol_CoreProtocol *p = (struct __pyx_obj_7asyncpg_8protocol_8protocol_CoreProtocol *)o; + tmp = ((PyObject*)p->buffer); + p->buffer = ((struct __pyx_obj_7asyncpg_8protocol_8protocol_ReadBuffer *)Py_None); Py_INCREF(Py_None); + Py_XDECREF(tmp); + tmp = ((PyObject*)p->_execute_iter); + p->_execute_iter = Py_None; Py_INCREF(Py_None); + Py_XDECREF(tmp); + tmp = ((PyObject*)p->transport); + p->transport = Py_None; Py_INCREF(Py_None); + Py_XDECREF(tmp); + tmp = ((PyObject*)p->con_args); + p->con_args = ((PyObject*)Py_None); Py_INCREF(Py_None); + Py_XDECREF(tmp); + tmp = ((PyObject*)p->result); + p->result = Py_None; Py_INCREF(Py_None); + Py_XDECREF(tmp); + return 0; +} + +static PyObject *__pyx_getprop_7asyncpg_8protocol_8protocol_12CoreProtocol_backend_pid(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_7asyncpg_8protocol_8protocol_12CoreProtocol_11backend_pid_1__get__(o); +} + +static PyObject *__pyx_getprop_7asyncpg_8protocol_8protocol_12CoreProtocol_backend_secret(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_7asyncpg_8protocol_8protocol_12CoreProtocol_14backend_secret_1__get__(o); +} + +static PyMethodDef __pyx_methods_7asyncpg_8protocol_8protocol_CoreProtocol[] = { + {"data_received", (PyCFunction)__pyx_pw_7asyncpg_8protocol_8protocol_12CoreProtocol_3data_received, METH_O, 0}, + {"connection_made", (PyCFunction)__pyx_pw_7asyncpg_8protocol_8protocol_12CoreProtocol_5connection_made, METH_O, 0}, + {"connection_lost", (PyCFunction)__pyx_pw_7asyncpg_8protocol_8protocol_12CoreProtocol_7connection_lost, METH_O, 0}, + {0, 0, 0, 0} +}; + +static struct PyGetSetDef __pyx_getsets_7asyncpg_8protocol_8protocol_CoreProtocol[] = { + {(char *)"backend_pid", __pyx_getprop_7asyncpg_8protocol_8protocol_12CoreProtocol_backend_pid, 0, (char *)0, 0}, + {(char *)"backend_secret", __pyx_getprop_7asyncpg_8protocol_8protocol_12CoreProtocol_backend_secret, 0, (char *)0, 0}, + {0, 0, 0, 0, 0} +}; + +static PyTypeObject __pyx_type_7asyncpg_8protocol_8protocol_CoreProtocol = { + PyVarObject_HEAD_INIT(0, 0) + "asyncpg.protocol.protocol.CoreProtocol", /*tp_name*/ + sizeof(struct __pyx_obj_7asyncpg_8protocol_8protocol_CoreProtocol), /*tp_basicsize*/ + 0, /*tp_itemsize*/ + __pyx_tp_dealloc_7asyncpg_8protocol_8protocol_CoreProtocol, /*tp_dealloc*/ + 0, /*tp_print*/ + 0, /*tp_getattr*/ + 0, /*tp_setattr*/ + #if PY_MAJOR_VERSION < 3 + 0, /*tp_compare*/ + #endif + #if PY_MAJOR_VERSION >= 3 + 0, /*tp_as_async*/ + #endif + 0, /*tp_repr*/ + 0, /*tp_as_number*/ + 0, /*tp_as_sequence*/ + 0, /*tp_as_mapping*/ + 0, /*tp_hash*/ + 0, /*tp_call*/ + 0, /*tp_str*/ + 0, /*tp_getattro*/ + 0, /*tp_setattro*/ + 0, /*tp_as_buffer*/ + Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_HAVE_GC, /*tp_flags*/ + 0, /*tp_doc*/ + __pyx_tp_traverse_7asyncpg_8protocol_8protocol_CoreProtocol, /*tp_traverse*/ + __pyx_tp_clear_7asyncpg_8protocol_8protocol_CoreProtocol, /*tp_clear*/ + 0, /*tp_richcompare*/ + 0, /*tp_weaklistoffset*/ + 0, /*tp_iter*/ + 0, /*tp_iternext*/ + __pyx_methods_7asyncpg_8protocol_8protocol_CoreProtocol, /*tp_methods*/ + 0, /*tp_members*/ + __pyx_getsets_7asyncpg_8protocol_8protocol_CoreProtocol, /*tp_getset*/ + 0, /*tp_base*/ + 0, /*tp_dict*/ + 0, /*tp_descr_get*/ + 0, /*tp_descr_set*/ + 0, /*tp_dictoffset*/ + __pyx_pw_7asyncpg_8protocol_8protocol_12CoreProtocol_1__init__, /*tp_init*/ + 0, /*tp_alloc*/ + __pyx_tp_new_7asyncpg_8protocol_8protocol_CoreProtocol, /*tp_new*/ + 0, /*tp_free*/ + 0, /*tp_is_gc*/ + 0, /*tp_bases*/ + 0, /*tp_mro*/ + 0, /*tp_cache*/ + 0, /*tp_subclasses*/ + 0, /*tp_weaklist*/ + 0, /*tp_del*/ + 0, /*tp_version_tag*/ + #if PY_VERSION_HEX >= 0x030400a1 + 0, /*tp_finalize*/ + #endif +}; +static struct __pyx_vtabstruct_7asyncpg_8protocol_8protocol_PreparedStatementState __pyx_vtable_7asyncpg_8protocol_8protocol_PreparedStatementState; + +static PyObject *__pyx_tp_new_7asyncpg_8protocol_8protocol_PreparedStatementState(PyTypeObject *t, PyObject *a, PyObject *k) { + struct __pyx_obj_7asyncpg_8protocol_8protocol_PreparedStatementState *p; + PyObject *o; + o = (*t->tp_alloc)(t, 0); + if (unlikely(!o)) return 0; + p = ((struct __pyx_obj_7asyncpg_8protocol_8protocol_PreparedStatementState *)o); + p->__pyx_vtab = __pyx_vtabptr_7asyncpg_8protocol_8protocol_PreparedStatementState; + p->name = ((PyObject*)Py_None); Py_INCREF(Py_None); + p->query = ((PyObject*)Py_None); Py_INCREF(Py_None); + p->buffer = ((struct __pyx_obj_7asyncpg_8protocol_8protocol_FastReadBuffer *)Py_None); Py_INCREF(Py_None); + p->row_desc = ((PyObject*)Py_None); Py_INCREF(Py_None); + p->parameters_desc = ((PyObject*)Py_None); Py_INCREF(Py_None); + p->protocol = ((struct __pyx_obj_7asyncpg_8protocol_8protocol_BaseProtocol *)Py_None); Py_INCREF(Py_None); + p->settings = ((struct __pyx_obj_7asyncpg_8protocol_8protocol_ConnectionSettings *)Py_None); Py_INCREF(Py_None); + p->args_codecs = ((PyObject*)Py_None); Py_INCREF(Py_None); + p->cols_desc = Py_None; Py_INCREF(Py_None); + p->rows_codecs = ((PyObject*)Py_None); Py_INCREF(Py_None); + if (unlikely(__pyx_pw_7asyncpg_8protocol_8protocol_22PreparedStatementState_1__cinit__(o, a, k) < 0)) goto bad; + return o; + bad: + Py_DECREF(o); o = 0; + return NULL; +} + +static void __pyx_tp_dealloc_7asyncpg_8protocol_8protocol_PreparedStatementState(PyObject *o) { + struct __pyx_obj_7asyncpg_8protocol_8protocol_PreparedStatementState *p = (struct __pyx_obj_7asyncpg_8protocol_8protocol_PreparedStatementState *)o; + PyObject_GC_UnTrack(o); + Py_CLEAR(p->name); + Py_CLEAR(p->query); + Py_CLEAR(p->buffer); + Py_CLEAR(p->row_desc); + Py_CLEAR(p->parameters_desc); + Py_CLEAR(p->protocol); + Py_CLEAR(p->settings); + Py_CLEAR(p->args_codecs); + Py_CLEAR(p->cols_desc); + Py_CLEAR(p->rows_codecs); + (*Py_TYPE(o)->tp_free)(o); +} + +static int __pyx_tp_traverse_7asyncpg_8protocol_8protocol_PreparedStatementState(PyObject *o, visitproc v, void *a) { + int e; + struct __pyx_obj_7asyncpg_8protocol_8protocol_PreparedStatementState *p = (struct __pyx_obj_7asyncpg_8protocol_8protocol_PreparedStatementState *)o; + if (p->buffer) { + e = (*v)(((PyObject*)p->buffer), a); if (e) return e; + } + if (p->row_desc) { + e = (*v)(p->row_desc, a); if (e) return e; + } + if (p->parameters_desc) { + e = (*v)(p->parameters_desc, a); if (e) return e; + } + if (p->protocol) { + e = (*v)(((PyObject*)p->protocol), a); if (e) return e; + } + if (p->settings) { + e = (*v)(((PyObject*)p->settings), a); if (e) return e; + } + if (p->args_codecs) { + e = (*v)(p->args_codecs, a); if (e) return e; + } + if (p->cols_desc) { + e = (*v)(p->cols_desc, a); if (e) return e; + } + if (p->rows_codecs) { + e = (*v)(p->rows_codecs, a); if (e) return e; + } + return 0; +} + +static int __pyx_tp_clear_7asyncpg_8protocol_8protocol_PreparedStatementState(PyObject *o) { + PyObject* tmp; + struct __pyx_obj_7asyncpg_8protocol_8protocol_PreparedStatementState *p = (struct __pyx_obj_7asyncpg_8protocol_8protocol_PreparedStatementState *)o; + tmp = ((PyObject*)p->buffer); + p->buffer = ((struct __pyx_obj_7asyncpg_8protocol_8protocol_FastReadBuffer *)Py_None); Py_INCREF(Py_None); + Py_XDECREF(tmp); + tmp = ((PyObject*)p->row_desc); + p->row_desc = ((PyObject*)Py_None); Py_INCREF(Py_None); + Py_XDECREF(tmp); + tmp = ((PyObject*)p->parameters_desc); + p->parameters_desc = ((PyObject*)Py_None); Py_INCREF(Py_None); + Py_XDECREF(tmp); + tmp = ((PyObject*)p->protocol); + p->protocol = ((struct __pyx_obj_7asyncpg_8protocol_8protocol_BaseProtocol *)Py_None); Py_INCREF(Py_None); + Py_XDECREF(tmp); + tmp = ((PyObject*)p->settings); + p->settings = ((struct __pyx_obj_7asyncpg_8protocol_8protocol_ConnectionSettings *)Py_None); Py_INCREF(Py_None); + Py_XDECREF(tmp); + tmp = ((PyObject*)p->args_codecs); + p->args_codecs = ((PyObject*)Py_None); Py_INCREF(Py_None); + Py_XDECREF(tmp); + tmp = ((PyObject*)p->cols_desc); + p->cols_desc = Py_None; Py_INCREF(Py_None); + Py_XDECREF(tmp); + tmp = ((PyObject*)p->rows_codecs); + p->rows_codecs = ((PyObject*)Py_None); Py_INCREF(Py_None); + Py_XDECREF(tmp); + return 0; +} + +static PyObject *__pyx_getprop_7asyncpg_8protocol_8protocol_22PreparedStatementState_name(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_7asyncpg_8protocol_8protocol_22PreparedStatementState_4name_1__get__(o); +} + +static PyObject *__pyx_getprop_7asyncpg_8protocol_8protocol_22PreparedStatementState_query(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_7asyncpg_8protocol_8protocol_22PreparedStatementState_5query_1__get__(o); +} + +static PyObject *__pyx_getprop_7asyncpg_8protocol_8protocol_22PreparedStatementState_closed(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_7asyncpg_8protocol_8protocol_22PreparedStatementState_6closed_1__get__(o); +} + +static PyObject *__pyx_getprop_7asyncpg_8protocol_8protocol_22PreparedStatementState_refs(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_7asyncpg_8protocol_8protocol_22PreparedStatementState_4refs_1__get__(o); +} + +static PyMethodDef __pyx_methods_7asyncpg_8protocol_8protocol_PreparedStatementState[] = { + {"_get_parameters", (PyCFunction)__pyx_pw_7asyncpg_8protocol_8protocol_22PreparedStatementState_3_get_parameters, METH_NOARGS, 0}, + {"_get_attributes", (PyCFunction)__pyx_pw_7asyncpg_8protocol_8protocol_22PreparedStatementState_5_get_attributes, METH_NOARGS, 0}, + {"_init_types", (PyCFunction)__pyx_pw_7asyncpg_8protocol_8protocol_22PreparedStatementState_7_init_types, METH_NOARGS, 0}, + {"attach", (PyCFunction)__pyx_pw_7asyncpg_8protocol_8protocol_22PreparedStatementState_9attach, METH_NOARGS, 0}, + {"detach", (PyCFunction)__pyx_pw_7asyncpg_8protocol_8protocol_22PreparedStatementState_11detach, METH_NOARGS, 0}, + {"mark_closed", (PyCFunction)__pyx_pw_7asyncpg_8protocol_8protocol_22PreparedStatementState_13mark_closed, METH_NOARGS, 0}, + {0, 0, 0, 0} +}; + +static struct PyGetSetDef __pyx_getsets_7asyncpg_8protocol_8protocol_PreparedStatementState[] = { + {(char *)"name", __pyx_getprop_7asyncpg_8protocol_8protocol_22PreparedStatementState_name, 0, (char *)0, 0}, + {(char *)"query", __pyx_getprop_7asyncpg_8protocol_8protocol_22PreparedStatementState_query, 0, (char *)0, 0}, + {(char *)"closed", __pyx_getprop_7asyncpg_8protocol_8protocol_22PreparedStatementState_closed, 0, (char *)0, 0}, + {(char *)"refs", __pyx_getprop_7asyncpg_8protocol_8protocol_22PreparedStatementState_refs, 0, (char *)0, 0}, + {0, 0, 0, 0, 0} +}; + +static PyTypeObject __pyx_type_7asyncpg_8protocol_8protocol_PreparedStatementState = { + PyVarObject_HEAD_INIT(0, 0) + "asyncpg.protocol.protocol.PreparedStatementState", /*tp_name*/ + sizeof(struct __pyx_obj_7asyncpg_8protocol_8protocol_PreparedStatementState), /*tp_basicsize*/ + 0, /*tp_itemsize*/ + __pyx_tp_dealloc_7asyncpg_8protocol_8protocol_PreparedStatementState, /*tp_dealloc*/ + 0, /*tp_print*/ + 0, /*tp_getattr*/ + 0, /*tp_setattr*/ + #if PY_MAJOR_VERSION < 3 + 0, /*tp_compare*/ + #endif + #if PY_MAJOR_VERSION >= 3 + 0, /*tp_as_async*/ + #endif + 0, /*tp_repr*/ + 0, /*tp_as_number*/ + 0, /*tp_as_sequence*/ + 0, /*tp_as_mapping*/ + 0, /*tp_hash*/ + 0, /*tp_call*/ + 0, /*tp_str*/ + 0, /*tp_getattro*/ + 0, /*tp_setattro*/ + 0, /*tp_as_buffer*/ + Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_HAVE_GC, /*tp_flags*/ + 0, /*tp_doc*/ + __pyx_tp_traverse_7asyncpg_8protocol_8protocol_PreparedStatementState, /*tp_traverse*/ + __pyx_tp_clear_7asyncpg_8protocol_8protocol_PreparedStatementState, /*tp_clear*/ + 0, /*tp_richcompare*/ + 0, /*tp_weaklistoffset*/ + 0, /*tp_iter*/ + 0, /*tp_iternext*/ + __pyx_methods_7asyncpg_8protocol_8protocol_PreparedStatementState, /*tp_methods*/ + 0, /*tp_members*/ + __pyx_getsets_7asyncpg_8protocol_8protocol_PreparedStatementState, /*tp_getset*/ + 0, /*tp_base*/ + 0, /*tp_dict*/ + 0, /*tp_descr_get*/ + 0, /*tp_descr_set*/ + 0, /*tp_dictoffset*/ + 0, /*tp_init*/ + 0, /*tp_alloc*/ + __pyx_tp_new_7asyncpg_8protocol_8protocol_PreparedStatementState, /*tp_new*/ + 0, /*tp_free*/ + 0, /*tp_is_gc*/ + 0, /*tp_bases*/ + 0, /*tp_mro*/ + 0, /*tp_cache*/ + 0, /*tp_subclasses*/ + 0, /*tp_weaklist*/ + 0, /*tp_del*/ + 0, /*tp_version_tag*/ + #if PY_VERSION_HEX >= 0x030400a1 + 0, /*tp_finalize*/ + #endif +}; +static struct __pyx_vtabstruct_7asyncpg_8protocol_8protocol_BaseProtocol __pyx_vtable_7asyncpg_8protocol_8protocol_BaseProtocol; + +static PyObject *__pyx_tp_new_7asyncpg_8protocol_8protocol_BaseProtocol(PyTypeObject *t, PyObject *a, PyObject *k) { + struct __pyx_obj_7asyncpg_8protocol_8protocol_BaseProtocol *p; + PyObject *o = __pyx_tp_new_7asyncpg_8protocol_8protocol_CoreProtocol(t, a, k); + if (unlikely(!o)) return 0; + p = ((struct __pyx_obj_7asyncpg_8protocol_8protocol_BaseProtocol *)o); + p->__pyx_base.__pyx_vtab = (struct __pyx_vtabstruct_7asyncpg_8protocol_8protocol_CoreProtocol*)__pyx_vtabptr_7asyncpg_8protocol_8protocol_BaseProtocol; + p->loop = Py_None; Py_INCREF(Py_None); + p->address = Py_None; Py_INCREF(Py_None); + p->settings = ((struct __pyx_obj_7asyncpg_8protocol_8protocol_ConnectionSettings *)Py_None); Py_INCREF(Py_None); + p->cancel_sent_waiter = Py_None; Py_INCREF(Py_None); + p->cancel_waiter = Py_None; Py_INCREF(Py_None); + p->waiter = Py_None; Py_INCREF(Py_None); + p->create_future = Py_None; Py_INCREF(Py_None); + p->timeout_handle = Py_None; Py_INCREF(Py_None); + p->timeout_callback = Py_None; Py_INCREF(Py_None); + p->completed_callback = Py_None; Py_INCREF(Py_None); + p->connection = Py_None; Py_INCREF(Py_None); + p->last_query = ((PyObject*)Py_None); Py_INCREF(Py_None); + p->statement = ((struct __pyx_obj_7asyncpg_8protocol_8protocol_PreparedStatementState *)Py_None); Py_INCREF(Py_None); + return o; +} + +static void __pyx_tp_dealloc_7asyncpg_8protocol_8protocol_BaseProtocol(PyObject *o) { + struct __pyx_obj_7asyncpg_8protocol_8protocol_BaseProtocol *p = (struct __pyx_obj_7asyncpg_8protocol_8protocol_BaseProtocol *)o; + #if PY_VERSION_HEX >= 0x030400a1 + if (unlikely(Py_TYPE(o)->tp_finalize) && !_PyGC_FINALIZED(o)) { + if (PyObject_CallFinalizerFromDealloc(o)) return; + } + #endif + PyObject_GC_UnTrack(o); + Py_CLEAR(p->loop); + Py_CLEAR(p->address); + Py_CLEAR(p->settings); + Py_CLEAR(p->cancel_sent_waiter); + Py_CLEAR(p->cancel_waiter); + Py_CLEAR(p->waiter); + Py_CLEAR(p->create_future); + Py_CLEAR(p->timeout_handle); + Py_CLEAR(p->timeout_callback); + Py_CLEAR(p->completed_callback); + Py_CLEAR(p->connection); + Py_CLEAR(p->last_query); + Py_CLEAR(p->statement); + PyObject_GC_Track(o); + __pyx_tp_dealloc_7asyncpg_8protocol_8protocol_CoreProtocol(o); +} + +static int __pyx_tp_traverse_7asyncpg_8protocol_8protocol_BaseProtocol(PyObject *o, visitproc v, void *a) { + int e; + struct __pyx_obj_7asyncpg_8protocol_8protocol_BaseProtocol *p = (struct __pyx_obj_7asyncpg_8protocol_8protocol_BaseProtocol *)o; + e = __pyx_tp_traverse_7asyncpg_8protocol_8protocol_CoreProtocol(o, v, a); if (e) return e; + if (p->loop) { + e = (*v)(p->loop, a); if (e) return e; + } + if (p->address) { + e = (*v)(p->address, a); if (e) return e; + } + if (p->settings) { + e = (*v)(((PyObject*)p->settings), a); if (e) return e; + } + if (p->cancel_sent_waiter) { + e = (*v)(p->cancel_sent_waiter, a); if (e) return e; + } + if (p->cancel_waiter) { + e = (*v)(p->cancel_waiter, a); if (e) return e; + } + if (p->waiter) { + e = (*v)(p->waiter, a); if (e) return e; + } + if (p->create_future) { + e = (*v)(p->create_future, a); if (e) return e; + } + if (p->timeout_handle) { + e = (*v)(p->timeout_handle, a); if (e) return e; + } + if (p->timeout_callback) { + e = (*v)(p->timeout_callback, a); if (e) return e; + } + if (p->completed_callback) { + e = (*v)(p->completed_callback, a); if (e) return e; + } + if (p->connection) { + e = (*v)(p->connection, a); if (e) return e; + } + if (p->statement) { + e = (*v)(((PyObject*)p->statement), a); if (e) return e; + } + return 0; +} + +static int __pyx_tp_clear_7asyncpg_8protocol_8protocol_BaseProtocol(PyObject *o) { + PyObject* tmp; + struct __pyx_obj_7asyncpg_8protocol_8protocol_BaseProtocol *p = (struct __pyx_obj_7asyncpg_8protocol_8protocol_BaseProtocol *)o; + __pyx_tp_clear_7asyncpg_8protocol_8protocol_CoreProtocol(o); + tmp = ((PyObject*)p->loop); + p->loop = Py_None; Py_INCREF(Py_None); + Py_XDECREF(tmp); + tmp = ((PyObject*)p->address); + p->address = Py_None; Py_INCREF(Py_None); + Py_XDECREF(tmp); + tmp = ((PyObject*)p->settings); + p->settings = ((struct __pyx_obj_7asyncpg_8protocol_8protocol_ConnectionSettings *)Py_None); Py_INCREF(Py_None); + Py_XDECREF(tmp); + tmp = ((PyObject*)p->cancel_sent_waiter); + p->cancel_sent_waiter = Py_None; Py_INCREF(Py_None); + Py_XDECREF(tmp); + tmp = ((PyObject*)p->cancel_waiter); + p->cancel_waiter = Py_None; Py_INCREF(Py_None); + Py_XDECREF(tmp); + tmp = ((PyObject*)p->waiter); + p->waiter = Py_None; Py_INCREF(Py_None); + Py_XDECREF(tmp); + tmp = ((PyObject*)p->create_future); + p->create_future = Py_None; Py_INCREF(Py_None); + Py_XDECREF(tmp); + tmp = ((PyObject*)p->timeout_handle); + p->timeout_handle = Py_None; Py_INCREF(Py_None); + Py_XDECREF(tmp); + tmp = ((PyObject*)p->timeout_callback); + p->timeout_callback = Py_None; Py_INCREF(Py_None); + Py_XDECREF(tmp); + tmp = ((PyObject*)p->completed_callback); + p->completed_callback = Py_None; Py_INCREF(Py_None); + Py_XDECREF(tmp); + tmp = ((PyObject*)p->connection); + p->connection = Py_None; Py_INCREF(Py_None); + Py_XDECREF(tmp); + tmp = ((PyObject*)p->statement); + p->statement = ((struct __pyx_obj_7asyncpg_8protocol_8protocol_PreparedStatementState *)Py_None); Py_INCREF(Py_None); + Py_XDECREF(tmp); + return 0; +} + +static PyObject *__pyx_getprop_7asyncpg_8protocol_8protocol_12BaseProtocol_queries_count(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_7asyncpg_8protocol_8protocol_12BaseProtocol_13queries_count_1__get__(o); +} + +static PyMethodDef __pyx_methods_7asyncpg_8protocol_8protocol_BaseProtocol[] = { + {"set_connection", (PyCFunction)__pyx_pw_7asyncpg_8protocol_8protocol_12BaseProtocol_3set_connection, METH_O, 0}, + {"get_server_pid", (PyCFunction)__pyx_pw_7asyncpg_8protocol_8protocol_12BaseProtocol_5get_server_pid, METH_NOARGS, 0}, + {"get_settings", (PyCFunction)__pyx_pw_7asyncpg_8protocol_8protocol_12BaseProtocol_7get_settings, METH_NOARGS, 0}, + {"prepare", (PyCFunction)__pyx_pw_7asyncpg_8protocol_8protocol_12BaseProtocol_9prepare, METH_VARARGS|METH_KEYWORDS, 0}, + {"bind_execute", (PyCFunction)__pyx_pw_7asyncpg_8protocol_8protocol_12BaseProtocol_12bind_execute, METH_VARARGS|METH_KEYWORDS, 0}, + {"bind_execute_many", (PyCFunction)__pyx_pw_7asyncpg_8protocol_8protocol_12BaseProtocol_15bind_execute_many, METH_VARARGS|METH_KEYWORDS, 0}, + {"bind", (PyCFunction)__pyx_pw_7asyncpg_8protocol_8protocol_12BaseProtocol_18bind, METH_VARARGS|METH_KEYWORDS, 0}, + {"execute", (PyCFunction)__pyx_pw_7asyncpg_8protocol_8protocol_12BaseProtocol_21execute, METH_VARARGS|METH_KEYWORDS, 0}, + {"query", (PyCFunction)__pyx_pw_7asyncpg_8protocol_8protocol_12BaseProtocol_24query, METH_VARARGS|METH_KEYWORDS, 0}, + {"close_statement", (PyCFunction)__pyx_pw_7asyncpg_8protocol_8protocol_12BaseProtocol_27close_statement, METH_VARARGS|METH_KEYWORDS, 0}, + {"is_closed", (PyCFunction)__pyx_pw_7asyncpg_8protocol_8protocol_12BaseProtocol_30is_closed, METH_NOARGS, 0}, + {"is_connected", (PyCFunction)__pyx_pw_7asyncpg_8protocol_8protocol_12BaseProtocol_32is_connected, METH_NOARGS, 0}, + {"abort", (PyCFunction)__pyx_pw_7asyncpg_8protocol_8protocol_12BaseProtocol_34abort, METH_NOARGS, 0}, + {"close", (PyCFunction)__pyx_pw_7asyncpg_8protocol_8protocol_12BaseProtocol_36close, METH_NOARGS, 0}, + {"_request_cancel", (PyCFunction)__pyx_pw_7asyncpg_8protocol_8protocol_12BaseProtocol_39_request_cancel, METH_NOARGS, 0}, + {"_on_timeout", (PyCFunction)__pyx_pw_7asyncpg_8protocol_8protocol_12BaseProtocol_41_on_timeout, METH_O, 0}, + {"_on_waiter_completed", (PyCFunction)__pyx_pw_7asyncpg_8protocol_8protocol_12BaseProtocol_43_on_waiter_completed, METH_O, 0}, + {"_create_future_fallback", (PyCFunction)__pyx_pw_7asyncpg_8protocol_8protocol_12BaseProtocol_45_create_future_fallback, METH_NOARGS, 0}, + {0, 0, 0, 0} +}; + +static struct PyGetSetDef __pyx_getsets_7asyncpg_8protocol_8protocol_BaseProtocol[] = { + {(char *)"queries_count", __pyx_getprop_7asyncpg_8protocol_8protocol_12BaseProtocol_queries_count, 0, (char *)0, 0}, + {0, 0, 0, 0, 0} +}; + +static PyTypeObject __pyx_type_7asyncpg_8protocol_8protocol_BaseProtocol = { + PyVarObject_HEAD_INIT(0, 0) + "asyncpg.protocol.protocol.BaseProtocol", /*tp_name*/ + sizeof(struct __pyx_obj_7asyncpg_8protocol_8protocol_BaseProtocol), /*tp_basicsize*/ + 0, /*tp_itemsize*/ + __pyx_tp_dealloc_7asyncpg_8protocol_8protocol_BaseProtocol, /*tp_dealloc*/ + 0, /*tp_print*/ + 0, /*tp_getattr*/ + 0, /*tp_setattr*/ + #if PY_MAJOR_VERSION < 3 + 0, /*tp_compare*/ + #endif + #if PY_MAJOR_VERSION >= 3 + 0, /*tp_as_async*/ + #endif + 0, /*tp_repr*/ + 0, /*tp_as_number*/ + 0, /*tp_as_sequence*/ + 0, /*tp_as_mapping*/ + 0, /*tp_hash*/ + 0, /*tp_call*/ + 0, /*tp_str*/ + 0, /*tp_getattro*/ + 0, /*tp_setattro*/ + 0, /*tp_as_buffer*/ + Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_HAVE_GC, /*tp_flags*/ + 0, /*tp_doc*/ + __pyx_tp_traverse_7asyncpg_8protocol_8protocol_BaseProtocol, /*tp_traverse*/ + __pyx_tp_clear_7asyncpg_8protocol_8protocol_BaseProtocol, /*tp_clear*/ + 0, /*tp_richcompare*/ + 0, /*tp_weaklistoffset*/ + 0, /*tp_iter*/ + 0, /*tp_iternext*/ + __pyx_methods_7asyncpg_8protocol_8protocol_BaseProtocol, /*tp_methods*/ + 0, /*tp_members*/ + __pyx_getsets_7asyncpg_8protocol_8protocol_BaseProtocol, /*tp_getset*/ + 0, /*tp_base*/ + 0, /*tp_dict*/ + 0, /*tp_descr_get*/ + 0, /*tp_descr_set*/ + 0, /*tp_dictoffset*/ + __pyx_pw_7asyncpg_8protocol_8protocol_12BaseProtocol_1__init__, /*tp_init*/ + 0, /*tp_alloc*/ + __pyx_tp_new_7asyncpg_8protocol_8protocol_BaseProtocol, /*tp_new*/ + 0, /*tp_free*/ + 0, /*tp_is_gc*/ + 0, /*tp_bases*/ + 0, /*tp_mro*/ + 0, /*tp_cache*/ + 0, /*tp_subclasses*/ + 0, /*tp_weaklist*/ + 0, /*tp_del*/ + 0, /*tp_version_tag*/ + #if PY_VERSION_HEX >= 0x030400a1 + 0, /*tp_finalize*/ + #endif +}; + +static struct __pyx_obj_7asyncpg_8protocol_8protocol___pyx_scope_struct__prepare *__pyx_freelist_7asyncpg_8protocol_8protocol___pyx_scope_struct__prepare[8]; +static int __pyx_freecount_7asyncpg_8protocol_8protocol___pyx_scope_struct__prepare = 0; + +static PyObject *__pyx_tp_new_7asyncpg_8protocol_8protocol___pyx_scope_struct__prepare(PyTypeObject *t, CYTHON_UNUSED PyObject *a, CYTHON_UNUSED PyObject *k) { + PyObject *o; + if (CYTHON_COMPILING_IN_CPYTHON && likely((__pyx_freecount_7asyncpg_8protocol_8protocol___pyx_scope_struct__prepare > 0) & (t->tp_basicsize == sizeof(struct __pyx_obj_7asyncpg_8protocol_8protocol___pyx_scope_struct__prepare)))) { + o = (PyObject*)__pyx_freelist_7asyncpg_8protocol_8protocol___pyx_scope_struct__prepare[--__pyx_freecount_7asyncpg_8protocol_8protocol___pyx_scope_struct__prepare]; + memset(o, 0, sizeof(struct __pyx_obj_7asyncpg_8protocol_8protocol___pyx_scope_struct__prepare)); + (void) PyObject_INIT(o, t); + PyObject_GC_Track(o); + } else { + o = (*t->tp_alloc)(t, 0); + if (unlikely(!o)) return 0; + } + return o; +} + +static void __pyx_tp_dealloc_7asyncpg_8protocol_8protocol___pyx_scope_struct__prepare(PyObject *o) { + struct __pyx_obj_7asyncpg_8protocol_8protocol___pyx_scope_struct__prepare *p = (struct __pyx_obj_7asyncpg_8protocol_8protocol___pyx_scope_struct__prepare *)o; + PyObject_GC_UnTrack(o); + Py_CLEAR(p->__pyx_v_query); + Py_CLEAR(p->__pyx_v_self); + Py_CLEAR(p->__pyx_v_stmt_name); + Py_CLEAR(p->__pyx_v_timeout); + if (CYTHON_COMPILING_IN_CPYTHON && ((__pyx_freecount_7asyncpg_8protocol_8protocol___pyx_scope_struct__prepare < 8) & (Py_TYPE(o)->tp_basicsize == sizeof(struct __pyx_obj_7asyncpg_8protocol_8protocol___pyx_scope_struct__prepare)))) { + __pyx_freelist_7asyncpg_8protocol_8protocol___pyx_scope_struct__prepare[__pyx_freecount_7asyncpg_8protocol_8protocol___pyx_scope_struct__prepare++] = ((struct __pyx_obj_7asyncpg_8protocol_8protocol___pyx_scope_struct__prepare *)o); + } else { + (*Py_TYPE(o)->tp_free)(o); + } +} + +static int __pyx_tp_traverse_7asyncpg_8protocol_8protocol___pyx_scope_struct__prepare(PyObject *o, visitproc v, void *a) { + int e; + struct __pyx_obj_7asyncpg_8protocol_8protocol___pyx_scope_struct__prepare *p = (struct __pyx_obj_7asyncpg_8protocol_8protocol___pyx_scope_struct__prepare *)o; + if (p->__pyx_v_query) { + e = (*v)(p->__pyx_v_query, a); if (e) return e; + } + if (p->__pyx_v_self) { + e = (*v)(((PyObject*)p->__pyx_v_self), a); if (e) return e; + } + if (p->__pyx_v_stmt_name) { + e = (*v)(p->__pyx_v_stmt_name, a); if (e) return e; + } + if (p->__pyx_v_timeout) { + e = (*v)(p->__pyx_v_timeout, a); if (e) return e; + } + return 0; +} + +static int __pyx_tp_clear_7asyncpg_8protocol_8protocol___pyx_scope_struct__prepare(PyObject *o) { + PyObject* tmp; + struct __pyx_obj_7asyncpg_8protocol_8protocol___pyx_scope_struct__prepare *p = (struct __pyx_obj_7asyncpg_8protocol_8protocol___pyx_scope_struct__prepare *)o; + tmp = ((PyObject*)p->__pyx_v_query); + p->__pyx_v_query = Py_None; Py_INCREF(Py_None); + Py_XDECREF(tmp); + tmp = ((PyObject*)p->__pyx_v_self); + p->__pyx_v_self = ((struct __pyx_obj_7asyncpg_8protocol_8protocol_BaseProtocol *)Py_None); Py_INCREF(Py_None); + Py_XDECREF(tmp); + tmp = ((PyObject*)p->__pyx_v_stmt_name); + p->__pyx_v_stmt_name = Py_None; Py_INCREF(Py_None); + Py_XDECREF(tmp); + tmp = ((PyObject*)p->__pyx_v_timeout); + p->__pyx_v_timeout = Py_None; Py_INCREF(Py_None); + Py_XDECREF(tmp); + return 0; +} + +static PyTypeObject __pyx_type_7asyncpg_8protocol_8protocol___pyx_scope_struct__prepare = { + PyVarObject_HEAD_INIT(0, 0) + "asyncpg.protocol.protocol.__pyx_scope_struct__prepare", /*tp_name*/ + sizeof(struct __pyx_obj_7asyncpg_8protocol_8protocol___pyx_scope_struct__prepare), /*tp_basicsize*/ + 0, /*tp_itemsize*/ + __pyx_tp_dealloc_7asyncpg_8protocol_8protocol___pyx_scope_struct__prepare, /*tp_dealloc*/ + 0, /*tp_print*/ + 0, /*tp_getattr*/ + 0, /*tp_setattr*/ + #if PY_MAJOR_VERSION < 3 + 0, /*tp_compare*/ + #endif + #if PY_MAJOR_VERSION >= 3 + 0, /*tp_as_async*/ + #endif + 0, /*tp_repr*/ + 0, /*tp_as_number*/ + 0, /*tp_as_sequence*/ + 0, /*tp_as_mapping*/ + 0, /*tp_hash*/ + 0, /*tp_call*/ + 0, /*tp_str*/ + 0, /*tp_getattro*/ + 0, /*tp_setattro*/ + 0, /*tp_as_buffer*/ + Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_HAVE_GC, /*tp_flags*/ + 0, /*tp_doc*/ + __pyx_tp_traverse_7asyncpg_8protocol_8protocol___pyx_scope_struct__prepare, /*tp_traverse*/ + __pyx_tp_clear_7asyncpg_8protocol_8protocol___pyx_scope_struct__prepare, /*tp_clear*/ + 0, /*tp_richcompare*/ + 0, /*tp_weaklistoffset*/ + 0, /*tp_iter*/ + 0, /*tp_iternext*/ + 0, /*tp_methods*/ + 0, /*tp_members*/ + 0, /*tp_getset*/ + 0, /*tp_base*/ + 0, /*tp_dict*/ + 0, /*tp_descr_get*/ + 0, /*tp_descr_set*/ + 0, /*tp_dictoffset*/ + 0, /*tp_init*/ + 0, /*tp_alloc*/ + __pyx_tp_new_7asyncpg_8protocol_8protocol___pyx_scope_struct__prepare, /*tp_new*/ + 0, /*tp_free*/ + 0, /*tp_is_gc*/ + 0, /*tp_bases*/ + 0, /*tp_mro*/ + 0, /*tp_cache*/ + 0, /*tp_subclasses*/ + 0, /*tp_weaklist*/ + 0, /*tp_del*/ + 0, /*tp_version_tag*/ + #if PY_VERSION_HEX >= 0x030400a1 + 0, /*tp_finalize*/ + #endif +}; + +static struct __pyx_obj_7asyncpg_8protocol_8protocol___pyx_scope_struct_1_bind_execute *__pyx_freelist_7asyncpg_8protocol_8protocol___pyx_scope_struct_1_bind_execute[8]; +static int __pyx_freecount_7asyncpg_8protocol_8protocol___pyx_scope_struct_1_bind_execute = 0; + +static PyObject *__pyx_tp_new_7asyncpg_8protocol_8protocol___pyx_scope_struct_1_bind_execute(PyTypeObject *t, CYTHON_UNUSED PyObject *a, CYTHON_UNUSED PyObject *k) { + PyObject *o; + if (CYTHON_COMPILING_IN_CPYTHON && likely((__pyx_freecount_7asyncpg_8protocol_8protocol___pyx_scope_struct_1_bind_execute > 0) & (t->tp_basicsize == sizeof(struct __pyx_obj_7asyncpg_8protocol_8protocol___pyx_scope_struct_1_bind_execute)))) { + o = (PyObject*)__pyx_freelist_7asyncpg_8protocol_8protocol___pyx_scope_struct_1_bind_execute[--__pyx_freecount_7asyncpg_8protocol_8protocol___pyx_scope_struct_1_bind_execute]; + memset(o, 0, sizeof(struct __pyx_obj_7asyncpg_8protocol_8protocol___pyx_scope_struct_1_bind_execute)); + (void) PyObject_INIT(o, t); + PyObject_GC_Track(o); + } else { + o = (*t->tp_alloc)(t, 0); + if (unlikely(!o)) return 0; + } + return o; +} + +static void __pyx_tp_dealloc_7asyncpg_8protocol_8protocol___pyx_scope_struct_1_bind_execute(PyObject *o) { + struct __pyx_obj_7asyncpg_8protocol_8protocol___pyx_scope_struct_1_bind_execute *p = (struct __pyx_obj_7asyncpg_8protocol_8protocol___pyx_scope_struct_1_bind_execute *)o; + PyObject_GC_UnTrack(o); + Py_CLEAR(p->__pyx_v_args); + Py_CLEAR(p->__pyx_v_portal_name); + Py_CLEAR(p->__pyx_v_return_extra); + Py_CLEAR(p->__pyx_v_self); + Py_CLEAR(p->__pyx_v_state); + Py_CLEAR(p->__pyx_v_timeout); + if (CYTHON_COMPILING_IN_CPYTHON && ((__pyx_freecount_7asyncpg_8protocol_8protocol___pyx_scope_struct_1_bind_execute < 8) & (Py_TYPE(o)->tp_basicsize == sizeof(struct __pyx_obj_7asyncpg_8protocol_8protocol___pyx_scope_struct_1_bind_execute)))) { + __pyx_freelist_7asyncpg_8protocol_8protocol___pyx_scope_struct_1_bind_execute[__pyx_freecount_7asyncpg_8protocol_8protocol___pyx_scope_struct_1_bind_execute++] = ((struct __pyx_obj_7asyncpg_8protocol_8protocol___pyx_scope_struct_1_bind_execute *)o); + } else { + (*Py_TYPE(o)->tp_free)(o); + } +} + +static int __pyx_tp_traverse_7asyncpg_8protocol_8protocol___pyx_scope_struct_1_bind_execute(PyObject *o, visitproc v, void *a) { + int e; + struct __pyx_obj_7asyncpg_8protocol_8protocol___pyx_scope_struct_1_bind_execute *p = (struct __pyx_obj_7asyncpg_8protocol_8protocol___pyx_scope_struct_1_bind_execute *)o; + if (p->__pyx_v_args) { + e = (*v)(p->__pyx_v_args, a); if (e) return e; + } + if (p->__pyx_v_return_extra) { + e = (*v)(p->__pyx_v_return_extra, a); if (e) return e; + } + if (p->__pyx_v_self) { + e = (*v)(((PyObject*)p->__pyx_v_self), a); if (e) return e; + } + if (p->__pyx_v_state) { + e = (*v)(((PyObject*)p->__pyx_v_state), a); if (e) return e; + } + if (p->__pyx_v_timeout) { + e = (*v)(p->__pyx_v_timeout, a); if (e) return e; + } + return 0; +} + +static int __pyx_tp_clear_7asyncpg_8protocol_8protocol___pyx_scope_struct_1_bind_execute(PyObject *o) { + PyObject* tmp; + struct __pyx_obj_7asyncpg_8protocol_8protocol___pyx_scope_struct_1_bind_execute *p = (struct __pyx_obj_7asyncpg_8protocol_8protocol___pyx_scope_struct_1_bind_execute *)o; + tmp = ((PyObject*)p->__pyx_v_args); + p->__pyx_v_args = Py_None; Py_INCREF(Py_None); + Py_XDECREF(tmp); + tmp = ((PyObject*)p->__pyx_v_return_extra); + p->__pyx_v_return_extra = Py_None; Py_INCREF(Py_None); + Py_XDECREF(tmp); + tmp = ((PyObject*)p->__pyx_v_self); + p->__pyx_v_self = ((struct __pyx_obj_7asyncpg_8protocol_8protocol_BaseProtocol *)Py_None); Py_INCREF(Py_None); + Py_XDECREF(tmp); + tmp = ((PyObject*)p->__pyx_v_state); + p->__pyx_v_state = ((struct __pyx_obj_7asyncpg_8protocol_8protocol_PreparedStatementState *)Py_None); Py_INCREF(Py_None); + Py_XDECREF(tmp); + tmp = ((PyObject*)p->__pyx_v_timeout); + p->__pyx_v_timeout = Py_None; Py_INCREF(Py_None); + Py_XDECREF(tmp); + return 0; +} + +static PyTypeObject __pyx_type_7asyncpg_8protocol_8protocol___pyx_scope_struct_1_bind_execute = { + PyVarObject_HEAD_INIT(0, 0) + "asyncpg.protocol.protocol.__pyx_scope_struct_1_bind_execute", /*tp_name*/ + sizeof(struct __pyx_obj_7asyncpg_8protocol_8protocol___pyx_scope_struct_1_bind_execute), /*tp_basicsize*/ + 0, /*tp_itemsize*/ + __pyx_tp_dealloc_7asyncpg_8protocol_8protocol___pyx_scope_struct_1_bind_execute, /*tp_dealloc*/ + 0, /*tp_print*/ + 0, /*tp_getattr*/ + 0, /*tp_setattr*/ + #if PY_MAJOR_VERSION < 3 + 0, /*tp_compare*/ + #endif + #if PY_MAJOR_VERSION >= 3 + 0, /*tp_as_async*/ + #endif + 0, /*tp_repr*/ + 0, /*tp_as_number*/ + 0, /*tp_as_sequence*/ + 0, /*tp_as_mapping*/ + 0, /*tp_hash*/ + 0, /*tp_call*/ + 0, /*tp_str*/ + 0, /*tp_getattro*/ + 0, /*tp_setattro*/ + 0, /*tp_as_buffer*/ + Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_HAVE_GC, /*tp_flags*/ + 0, /*tp_doc*/ + __pyx_tp_traverse_7asyncpg_8protocol_8protocol___pyx_scope_struct_1_bind_execute, /*tp_traverse*/ + __pyx_tp_clear_7asyncpg_8protocol_8protocol___pyx_scope_struct_1_bind_execute, /*tp_clear*/ + 0, /*tp_richcompare*/ + 0, /*tp_weaklistoffset*/ + 0, /*tp_iter*/ + 0, /*tp_iternext*/ + 0, /*tp_methods*/ + 0, /*tp_members*/ + 0, /*tp_getset*/ + 0, /*tp_base*/ + 0, /*tp_dict*/ + 0, /*tp_descr_get*/ + 0, /*tp_descr_set*/ + 0, /*tp_dictoffset*/ + 0, /*tp_init*/ + 0, /*tp_alloc*/ + __pyx_tp_new_7asyncpg_8protocol_8protocol___pyx_scope_struct_1_bind_execute, /*tp_new*/ + 0, /*tp_free*/ + 0, /*tp_is_gc*/ + 0, /*tp_bases*/ + 0, /*tp_mro*/ + 0, /*tp_cache*/ + 0, /*tp_subclasses*/ + 0, /*tp_weaklist*/ + 0, /*tp_del*/ + 0, /*tp_version_tag*/ + #if PY_VERSION_HEX >= 0x030400a1 + 0, /*tp_finalize*/ + #endif +}; + +static struct __pyx_obj_7asyncpg_8protocol_8protocol___pyx_scope_struct_2_bind_execute_many *__pyx_freelist_7asyncpg_8protocol_8protocol___pyx_scope_struct_2_bind_execute_many[8]; +static int __pyx_freecount_7asyncpg_8protocol_8protocol___pyx_scope_struct_2_bind_execute_many = 0; + +static PyObject *__pyx_tp_new_7asyncpg_8protocol_8protocol___pyx_scope_struct_2_bind_execute_many(PyTypeObject *t, CYTHON_UNUSED PyObject *a, CYTHON_UNUSED PyObject *k) { + PyObject *o; + if (CYTHON_COMPILING_IN_CPYTHON && likely((__pyx_freecount_7asyncpg_8protocol_8protocol___pyx_scope_struct_2_bind_execute_many > 0) & (t->tp_basicsize == sizeof(struct __pyx_obj_7asyncpg_8protocol_8protocol___pyx_scope_struct_2_bind_execute_many)))) { + o = (PyObject*)__pyx_freelist_7asyncpg_8protocol_8protocol___pyx_scope_struct_2_bind_execute_many[--__pyx_freecount_7asyncpg_8protocol_8protocol___pyx_scope_struct_2_bind_execute_many]; + memset(o, 0, sizeof(struct __pyx_obj_7asyncpg_8protocol_8protocol___pyx_scope_struct_2_bind_execute_many)); + (void) PyObject_INIT(o, t); + PyObject_GC_Track(o); + } else { + o = (*t->tp_alloc)(t, 0); + if (unlikely(!o)) return 0; + } + return o; +} + +static void __pyx_tp_dealloc_7asyncpg_8protocol_8protocol___pyx_scope_struct_2_bind_execute_many(PyObject *o) { + struct __pyx_obj_7asyncpg_8protocol_8protocol___pyx_scope_struct_2_bind_execute_many *p = (struct __pyx_obj_7asyncpg_8protocol_8protocol___pyx_scope_struct_2_bind_execute_many *)o; + PyObject_GC_UnTrack(o); + Py_CLEAR(p->__pyx_v_arg_bufs); + Py_CLEAR(p->__pyx_v_args); + Py_CLEAR(p->__pyx_v_data_gen); + Py_CLEAR(p->__pyx_v_genexpr); + Py_CLEAR(p->__pyx_v_portal_name); + Py_CLEAR(p->__pyx_v_self); + Py_CLEAR(p->__pyx_v_state); + Py_CLEAR(p->__pyx_v_timeout); + Py_CLEAR(p->__pyx_v_waiter); + if (CYTHON_COMPILING_IN_CPYTHON && ((__pyx_freecount_7asyncpg_8protocol_8protocol___pyx_scope_struct_2_bind_execute_many < 8) & (Py_TYPE(o)->tp_basicsize == sizeof(struct __pyx_obj_7asyncpg_8protocol_8protocol___pyx_scope_struct_2_bind_execute_many)))) { + __pyx_freelist_7asyncpg_8protocol_8protocol___pyx_scope_struct_2_bind_execute_many[__pyx_freecount_7asyncpg_8protocol_8protocol___pyx_scope_struct_2_bind_execute_many++] = ((struct __pyx_obj_7asyncpg_8protocol_8protocol___pyx_scope_struct_2_bind_execute_many *)o); + } else { + (*Py_TYPE(o)->tp_free)(o); + } +} + +static int __pyx_tp_traverse_7asyncpg_8protocol_8protocol___pyx_scope_struct_2_bind_execute_many(PyObject *o, visitproc v, void *a) { + int e; + struct __pyx_obj_7asyncpg_8protocol_8protocol___pyx_scope_struct_2_bind_execute_many *p = (struct __pyx_obj_7asyncpg_8protocol_8protocol___pyx_scope_struct_2_bind_execute_many *)o; + if (p->__pyx_v_arg_bufs) { + e = (*v)(p->__pyx_v_arg_bufs, a); if (e) return e; + } + if (p->__pyx_v_args) { + e = (*v)(p->__pyx_v_args, a); if (e) return e; + } + if (p->__pyx_v_data_gen) { + e = (*v)(p->__pyx_v_data_gen, a); if (e) return e; + } + if (p->__pyx_v_genexpr) { + e = (*v)(p->__pyx_v_genexpr, a); if (e) return e; + } + if (p->__pyx_v_self) { + e = (*v)(((PyObject*)p->__pyx_v_self), a); if (e) return e; + } + if (p->__pyx_v_state) { + e = (*v)(((PyObject*)p->__pyx_v_state), a); if (e) return e; + } + if (p->__pyx_v_timeout) { + e = (*v)(p->__pyx_v_timeout, a); if (e) return e; + } + if (p->__pyx_v_waiter) { + e = (*v)(p->__pyx_v_waiter, a); if (e) return e; + } + return 0; +} + +static int __pyx_tp_clear_7asyncpg_8protocol_8protocol___pyx_scope_struct_2_bind_execute_many(PyObject *o) { + PyObject* tmp; + struct __pyx_obj_7asyncpg_8protocol_8protocol___pyx_scope_struct_2_bind_execute_many *p = (struct __pyx_obj_7asyncpg_8protocol_8protocol___pyx_scope_struct_2_bind_execute_many *)o; + tmp = ((PyObject*)p->__pyx_v_arg_bufs); + p->__pyx_v_arg_bufs = Py_None; Py_INCREF(Py_None); + Py_XDECREF(tmp); + tmp = ((PyObject*)p->__pyx_v_args); + p->__pyx_v_args = Py_None; Py_INCREF(Py_None); + Py_XDECREF(tmp); + tmp = ((PyObject*)p->__pyx_v_data_gen); + p->__pyx_v_data_gen = Py_None; Py_INCREF(Py_None); + Py_XDECREF(tmp); + tmp = ((PyObject*)p->__pyx_v_genexpr); + p->__pyx_v_genexpr = Py_None; Py_INCREF(Py_None); + Py_XDECREF(tmp); + tmp = ((PyObject*)p->__pyx_v_self); + p->__pyx_v_self = ((struct __pyx_obj_7asyncpg_8protocol_8protocol_BaseProtocol *)Py_None); Py_INCREF(Py_None); + Py_XDECREF(tmp); + tmp = ((PyObject*)p->__pyx_v_state); + p->__pyx_v_state = ((struct __pyx_obj_7asyncpg_8protocol_8protocol_PreparedStatementState *)Py_None); Py_INCREF(Py_None); + Py_XDECREF(tmp); + tmp = ((PyObject*)p->__pyx_v_timeout); + p->__pyx_v_timeout = Py_None; Py_INCREF(Py_None); + Py_XDECREF(tmp); + tmp = ((PyObject*)p->__pyx_v_waiter); + p->__pyx_v_waiter = Py_None; Py_INCREF(Py_None); + Py_XDECREF(tmp); + return 0; +} + +static PyTypeObject __pyx_type_7asyncpg_8protocol_8protocol___pyx_scope_struct_2_bind_execute_many = { + PyVarObject_HEAD_INIT(0, 0) + "asyncpg.protocol.protocol.__pyx_scope_struct_2_bind_execute_many", /*tp_name*/ + sizeof(struct __pyx_obj_7asyncpg_8protocol_8protocol___pyx_scope_struct_2_bind_execute_many), /*tp_basicsize*/ + 0, /*tp_itemsize*/ + __pyx_tp_dealloc_7asyncpg_8protocol_8protocol___pyx_scope_struct_2_bind_execute_many, /*tp_dealloc*/ + 0, /*tp_print*/ + 0, /*tp_getattr*/ + 0, /*tp_setattr*/ + #if PY_MAJOR_VERSION < 3 + 0, /*tp_compare*/ + #endif + #if PY_MAJOR_VERSION >= 3 + 0, /*tp_as_async*/ + #endif + 0, /*tp_repr*/ + 0, /*tp_as_number*/ + 0, /*tp_as_sequence*/ + 0, /*tp_as_mapping*/ + 0, /*tp_hash*/ + 0, /*tp_call*/ + 0, /*tp_str*/ + 0, /*tp_getattro*/ + 0, /*tp_setattro*/ + 0, /*tp_as_buffer*/ + Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_HAVE_GC, /*tp_flags*/ + 0, /*tp_doc*/ + __pyx_tp_traverse_7asyncpg_8protocol_8protocol___pyx_scope_struct_2_bind_execute_many, /*tp_traverse*/ + __pyx_tp_clear_7asyncpg_8protocol_8protocol___pyx_scope_struct_2_bind_execute_many, /*tp_clear*/ + 0, /*tp_richcompare*/ + 0, /*tp_weaklistoffset*/ + 0, /*tp_iter*/ + 0, /*tp_iternext*/ + 0, /*tp_methods*/ + 0, /*tp_members*/ + 0, /*tp_getset*/ + 0, /*tp_base*/ + 0, /*tp_dict*/ + 0, /*tp_descr_get*/ + 0, /*tp_descr_set*/ + 0, /*tp_dictoffset*/ + 0, /*tp_init*/ + 0, /*tp_alloc*/ + __pyx_tp_new_7asyncpg_8protocol_8protocol___pyx_scope_struct_2_bind_execute_many, /*tp_new*/ + 0, /*tp_free*/ + 0, /*tp_is_gc*/ + 0, /*tp_bases*/ + 0, /*tp_mro*/ + 0, /*tp_cache*/ + 0, /*tp_subclasses*/ + 0, /*tp_weaklist*/ + 0, /*tp_del*/ + 0, /*tp_version_tag*/ + #if PY_VERSION_HEX >= 0x030400a1 + 0, /*tp_finalize*/ + #endif +}; + +static struct __pyx_obj_7asyncpg_8protocol_8protocol___pyx_scope_struct_3_genexpr *__pyx_freelist_7asyncpg_8protocol_8protocol___pyx_scope_struct_3_genexpr[8]; +static int __pyx_freecount_7asyncpg_8protocol_8protocol___pyx_scope_struct_3_genexpr = 0; + +static PyObject *__pyx_tp_new_7asyncpg_8protocol_8protocol___pyx_scope_struct_3_genexpr(PyTypeObject *t, CYTHON_UNUSED PyObject *a, CYTHON_UNUSED PyObject *k) { + PyObject *o; + if (CYTHON_COMPILING_IN_CPYTHON && likely((__pyx_freecount_7asyncpg_8protocol_8protocol___pyx_scope_struct_3_genexpr > 0) & (t->tp_basicsize == sizeof(struct __pyx_obj_7asyncpg_8protocol_8protocol___pyx_scope_struct_3_genexpr)))) { + o = (PyObject*)__pyx_freelist_7asyncpg_8protocol_8protocol___pyx_scope_struct_3_genexpr[--__pyx_freecount_7asyncpg_8protocol_8protocol___pyx_scope_struct_3_genexpr]; + memset(o, 0, sizeof(struct __pyx_obj_7asyncpg_8protocol_8protocol___pyx_scope_struct_3_genexpr)); + (void) PyObject_INIT(o, t); + PyObject_GC_Track(o); + } else { + o = (*t->tp_alloc)(t, 0); + if (unlikely(!o)) return 0; + } + return o; +} + +static void __pyx_tp_dealloc_7asyncpg_8protocol_8protocol___pyx_scope_struct_3_genexpr(PyObject *o) { + struct __pyx_obj_7asyncpg_8protocol_8protocol___pyx_scope_struct_3_genexpr *p = (struct __pyx_obj_7asyncpg_8protocol_8protocol___pyx_scope_struct_3_genexpr *)o; + PyObject_GC_UnTrack(o); + Py_CLEAR(p->__pyx_outer_scope); + Py_CLEAR(p->__pyx_v_b); + Py_CLEAR(p->__pyx_t_0); + if (CYTHON_COMPILING_IN_CPYTHON && ((__pyx_freecount_7asyncpg_8protocol_8protocol___pyx_scope_struct_3_genexpr < 8) & (Py_TYPE(o)->tp_basicsize == sizeof(struct __pyx_obj_7asyncpg_8protocol_8protocol___pyx_scope_struct_3_genexpr)))) { + __pyx_freelist_7asyncpg_8protocol_8protocol___pyx_scope_struct_3_genexpr[__pyx_freecount_7asyncpg_8protocol_8protocol___pyx_scope_struct_3_genexpr++] = ((struct __pyx_obj_7asyncpg_8protocol_8protocol___pyx_scope_struct_3_genexpr *)o); + } else { + (*Py_TYPE(o)->tp_free)(o); + } +} + +static int __pyx_tp_traverse_7asyncpg_8protocol_8protocol___pyx_scope_struct_3_genexpr(PyObject *o, visitproc v, void *a) { + int e; + struct __pyx_obj_7asyncpg_8protocol_8protocol___pyx_scope_struct_3_genexpr *p = (struct __pyx_obj_7asyncpg_8protocol_8protocol___pyx_scope_struct_3_genexpr *)o; + if (p->__pyx_outer_scope) { + e = (*v)(((PyObject*)p->__pyx_outer_scope), a); if (e) return e; + } + if (p->__pyx_v_b) { + e = (*v)(p->__pyx_v_b, a); if (e) return e; + } + if (p->__pyx_t_0) { + e = (*v)(p->__pyx_t_0, a); if (e) return e; + } + return 0; +} + +static int __pyx_tp_clear_7asyncpg_8protocol_8protocol___pyx_scope_struct_3_genexpr(PyObject *o) { + PyObject* tmp; + struct __pyx_obj_7asyncpg_8protocol_8protocol___pyx_scope_struct_3_genexpr *p = (struct __pyx_obj_7asyncpg_8protocol_8protocol___pyx_scope_struct_3_genexpr *)o; + tmp = ((PyObject*)p->__pyx_outer_scope); + p->__pyx_outer_scope = ((struct __pyx_obj_7asyncpg_8protocol_8protocol___pyx_scope_struct_2_bind_execute_many *)Py_None); Py_INCREF(Py_None); + Py_XDECREF(tmp); + tmp = ((PyObject*)p->__pyx_v_b); + p->__pyx_v_b = Py_None; Py_INCREF(Py_None); + Py_XDECREF(tmp); + tmp = ((PyObject*)p->__pyx_t_0); + p->__pyx_t_0 = Py_None; Py_INCREF(Py_None); + Py_XDECREF(tmp); + return 0; +} + +static PyTypeObject __pyx_type_7asyncpg_8protocol_8protocol___pyx_scope_struct_3_genexpr = { + PyVarObject_HEAD_INIT(0, 0) + "asyncpg.protocol.protocol.__pyx_scope_struct_3_genexpr", /*tp_name*/ + sizeof(struct __pyx_obj_7asyncpg_8protocol_8protocol___pyx_scope_struct_3_genexpr), /*tp_basicsize*/ + 0, /*tp_itemsize*/ + __pyx_tp_dealloc_7asyncpg_8protocol_8protocol___pyx_scope_struct_3_genexpr, /*tp_dealloc*/ + 0, /*tp_print*/ + 0, /*tp_getattr*/ + 0, /*tp_setattr*/ + #if PY_MAJOR_VERSION < 3 + 0, /*tp_compare*/ + #endif + #if PY_MAJOR_VERSION >= 3 + 0, /*tp_as_async*/ + #endif + 0, /*tp_repr*/ + 0, /*tp_as_number*/ + 0, /*tp_as_sequence*/ + 0, /*tp_as_mapping*/ + 0, /*tp_hash*/ + 0, /*tp_call*/ + 0, /*tp_str*/ + 0, /*tp_getattro*/ + 0, /*tp_setattro*/ + 0, /*tp_as_buffer*/ + Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_HAVE_GC, /*tp_flags*/ + 0, /*tp_doc*/ + __pyx_tp_traverse_7asyncpg_8protocol_8protocol___pyx_scope_struct_3_genexpr, /*tp_traverse*/ + __pyx_tp_clear_7asyncpg_8protocol_8protocol___pyx_scope_struct_3_genexpr, /*tp_clear*/ + 0, /*tp_richcompare*/ + 0, /*tp_weaklistoffset*/ + 0, /*tp_iter*/ + 0, /*tp_iternext*/ + 0, /*tp_methods*/ + 0, /*tp_members*/ + 0, /*tp_getset*/ + 0, /*tp_base*/ + 0, /*tp_dict*/ + 0, /*tp_descr_get*/ + 0, /*tp_descr_set*/ + 0, /*tp_dictoffset*/ + 0, /*tp_init*/ + 0, /*tp_alloc*/ + __pyx_tp_new_7asyncpg_8protocol_8protocol___pyx_scope_struct_3_genexpr, /*tp_new*/ + 0, /*tp_free*/ + 0, /*tp_is_gc*/ + 0, /*tp_bases*/ + 0, /*tp_mro*/ + 0, /*tp_cache*/ + 0, /*tp_subclasses*/ + 0, /*tp_weaklist*/ + 0, /*tp_del*/ + 0, /*tp_version_tag*/ + #if PY_VERSION_HEX >= 0x030400a1 + 0, /*tp_finalize*/ + #endif +}; + +static struct __pyx_obj_7asyncpg_8protocol_8protocol___pyx_scope_struct_4_bind *__pyx_freelist_7asyncpg_8protocol_8protocol___pyx_scope_struct_4_bind[8]; +static int __pyx_freecount_7asyncpg_8protocol_8protocol___pyx_scope_struct_4_bind = 0; + +static PyObject *__pyx_tp_new_7asyncpg_8protocol_8protocol___pyx_scope_struct_4_bind(PyTypeObject *t, CYTHON_UNUSED PyObject *a, CYTHON_UNUSED PyObject *k) { + PyObject *o; + if (CYTHON_COMPILING_IN_CPYTHON && likely((__pyx_freecount_7asyncpg_8protocol_8protocol___pyx_scope_struct_4_bind > 0) & (t->tp_basicsize == sizeof(struct __pyx_obj_7asyncpg_8protocol_8protocol___pyx_scope_struct_4_bind)))) { + o = (PyObject*)__pyx_freelist_7asyncpg_8protocol_8protocol___pyx_scope_struct_4_bind[--__pyx_freecount_7asyncpg_8protocol_8protocol___pyx_scope_struct_4_bind]; + memset(o, 0, sizeof(struct __pyx_obj_7asyncpg_8protocol_8protocol___pyx_scope_struct_4_bind)); + (void) PyObject_INIT(o, t); + PyObject_GC_Track(o); + } else { + o = (*t->tp_alloc)(t, 0); + if (unlikely(!o)) return 0; + } + return o; +} + +static void __pyx_tp_dealloc_7asyncpg_8protocol_8protocol___pyx_scope_struct_4_bind(PyObject *o) { + struct __pyx_obj_7asyncpg_8protocol_8protocol___pyx_scope_struct_4_bind *p = (struct __pyx_obj_7asyncpg_8protocol_8protocol___pyx_scope_struct_4_bind *)o; + PyObject_GC_UnTrack(o); + Py_CLEAR(p->__pyx_v_args); + Py_CLEAR(p->__pyx_v_portal_name); + Py_CLEAR(p->__pyx_v_self); + Py_CLEAR(p->__pyx_v_state); + Py_CLEAR(p->__pyx_v_timeout); + if (CYTHON_COMPILING_IN_CPYTHON && ((__pyx_freecount_7asyncpg_8protocol_8protocol___pyx_scope_struct_4_bind < 8) & (Py_TYPE(o)->tp_basicsize == sizeof(struct __pyx_obj_7asyncpg_8protocol_8protocol___pyx_scope_struct_4_bind)))) { + __pyx_freelist_7asyncpg_8protocol_8protocol___pyx_scope_struct_4_bind[__pyx_freecount_7asyncpg_8protocol_8protocol___pyx_scope_struct_4_bind++] = ((struct __pyx_obj_7asyncpg_8protocol_8protocol___pyx_scope_struct_4_bind *)o); + } else { + (*Py_TYPE(o)->tp_free)(o); + } +} + +static int __pyx_tp_traverse_7asyncpg_8protocol_8protocol___pyx_scope_struct_4_bind(PyObject *o, visitproc v, void *a) { + int e; + struct __pyx_obj_7asyncpg_8protocol_8protocol___pyx_scope_struct_4_bind *p = (struct __pyx_obj_7asyncpg_8protocol_8protocol___pyx_scope_struct_4_bind *)o; + if (p->__pyx_v_args) { + e = (*v)(p->__pyx_v_args, a); if (e) return e; + } + if (p->__pyx_v_self) { + e = (*v)(((PyObject*)p->__pyx_v_self), a); if (e) return e; + } + if (p->__pyx_v_state) { + e = (*v)(((PyObject*)p->__pyx_v_state), a); if (e) return e; + } + if (p->__pyx_v_timeout) { + e = (*v)(p->__pyx_v_timeout, a); if (e) return e; + } + return 0; +} + +static int __pyx_tp_clear_7asyncpg_8protocol_8protocol___pyx_scope_struct_4_bind(PyObject *o) { + PyObject* tmp; + struct __pyx_obj_7asyncpg_8protocol_8protocol___pyx_scope_struct_4_bind *p = (struct __pyx_obj_7asyncpg_8protocol_8protocol___pyx_scope_struct_4_bind *)o; + tmp = ((PyObject*)p->__pyx_v_args); + p->__pyx_v_args = Py_None; Py_INCREF(Py_None); + Py_XDECREF(tmp); + tmp = ((PyObject*)p->__pyx_v_self); + p->__pyx_v_self = ((struct __pyx_obj_7asyncpg_8protocol_8protocol_BaseProtocol *)Py_None); Py_INCREF(Py_None); + Py_XDECREF(tmp); + tmp = ((PyObject*)p->__pyx_v_state); + p->__pyx_v_state = ((struct __pyx_obj_7asyncpg_8protocol_8protocol_PreparedStatementState *)Py_None); Py_INCREF(Py_None); + Py_XDECREF(tmp); + tmp = ((PyObject*)p->__pyx_v_timeout); + p->__pyx_v_timeout = Py_None; Py_INCREF(Py_None); + Py_XDECREF(tmp); + return 0; +} + +static PyTypeObject __pyx_type_7asyncpg_8protocol_8protocol___pyx_scope_struct_4_bind = { + PyVarObject_HEAD_INIT(0, 0) + "asyncpg.protocol.protocol.__pyx_scope_struct_4_bind", /*tp_name*/ + sizeof(struct __pyx_obj_7asyncpg_8protocol_8protocol___pyx_scope_struct_4_bind), /*tp_basicsize*/ + 0, /*tp_itemsize*/ + __pyx_tp_dealloc_7asyncpg_8protocol_8protocol___pyx_scope_struct_4_bind, /*tp_dealloc*/ + 0, /*tp_print*/ + 0, /*tp_getattr*/ + 0, /*tp_setattr*/ + #if PY_MAJOR_VERSION < 3 + 0, /*tp_compare*/ + #endif + #if PY_MAJOR_VERSION >= 3 + 0, /*tp_as_async*/ + #endif + 0, /*tp_repr*/ + 0, /*tp_as_number*/ + 0, /*tp_as_sequence*/ + 0, /*tp_as_mapping*/ + 0, /*tp_hash*/ + 0, /*tp_call*/ + 0, /*tp_str*/ + 0, /*tp_getattro*/ + 0, /*tp_setattro*/ + 0, /*tp_as_buffer*/ + Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_HAVE_GC, /*tp_flags*/ + 0, /*tp_doc*/ + __pyx_tp_traverse_7asyncpg_8protocol_8protocol___pyx_scope_struct_4_bind, /*tp_traverse*/ + __pyx_tp_clear_7asyncpg_8protocol_8protocol___pyx_scope_struct_4_bind, /*tp_clear*/ + 0, /*tp_richcompare*/ + 0, /*tp_weaklistoffset*/ + 0, /*tp_iter*/ + 0, /*tp_iternext*/ + 0, /*tp_methods*/ + 0, /*tp_members*/ + 0, /*tp_getset*/ + 0, /*tp_base*/ + 0, /*tp_dict*/ + 0, /*tp_descr_get*/ + 0, /*tp_descr_set*/ + 0, /*tp_dictoffset*/ + 0, /*tp_init*/ + 0, /*tp_alloc*/ + __pyx_tp_new_7asyncpg_8protocol_8protocol___pyx_scope_struct_4_bind, /*tp_new*/ + 0, /*tp_free*/ + 0, /*tp_is_gc*/ + 0, /*tp_bases*/ + 0, /*tp_mro*/ + 0, /*tp_cache*/ + 0, /*tp_subclasses*/ + 0, /*tp_weaklist*/ + 0, /*tp_del*/ + 0, /*tp_version_tag*/ + #if PY_VERSION_HEX >= 0x030400a1 + 0, /*tp_finalize*/ + #endif +}; + +static struct __pyx_obj_7asyncpg_8protocol_8protocol___pyx_scope_struct_5_execute *__pyx_freelist_7asyncpg_8protocol_8protocol___pyx_scope_struct_5_execute[8]; +static int __pyx_freecount_7asyncpg_8protocol_8protocol___pyx_scope_struct_5_execute = 0; + +static PyObject *__pyx_tp_new_7asyncpg_8protocol_8protocol___pyx_scope_struct_5_execute(PyTypeObject *t, CYTHON_UNUSED PyObject *a, CYTHON_UNUSED PyObject *k) { + PyObject *o; + if (CYTHON_COMPILING_IN_CPYTHON && likely((__pyx_freecount_7asyncpg_8protocol_8protocol___pyx_scope_struct_5_execute > 0) & (t->tp_basicsize == sizeof(struct __pyx_obj_7asyncpg_8protocol_8protocol___pyx_scope_struct_5_execute)))) { + o = (PyObject*)__pyx_freelist_7asyncpg_8protocol_8protocol___pyx_scope_struct_5_execute[--__pyx_freecount_7asyncpg_8protocol_8protocol___pyx_scope_struct_5_execute]; + memset(o, 0, sizeof(struct __pyx_obj_7asyncpg_8protocol_8protocol___pyx_scope_struct_5_execute)); + (void) PyObject_INIT(o, t); + PyObject_GC_Track(o); + } else { + o = (*t->tp_alloc)(t, 0); + if (unlikely(!o)) return 0; + } + return o; +} + +static void __pyx_tp_dealloc_7asyncpg_8protocol_8protocol___pyx_scope_struct_5_execute(PyObject *o) { + struct __pyx_obj_7asyncpg_8protocol_8protocol___pyx_scope_struct_5_execute *p = (struct __pyx_obj_7asyncpg_8protocol_8protocol___pyx_scope_struct_5_execute *)o; + PyObject_GC_UnTrack(o); + Py_CLEAR(p->__pyx_v_portal_name); + Py_CLEAR(p->__pyx_v_return_extra); + Py_CLEAR(p->__pyx_v_self); + Py_CLEAR(p->__pyx_v_state); + Py_CLEAR(p->__pyx_v_timeout); + if (CYTHON_COMPILING_IN_CPYTHON && ((__pyx_freecount_7asyncpg_8protocol_8protocol___pyx_scope_struct_5_execute < 8) & (Py_TYPE(o)->tp_basicsize == sizeof(struct __pyx_obj_7asyncpg_8protocol_8protocol___pyx_scope_struct_5_execute)))) { + __pyx_freelist_7asyncpg_8protocol_8protocol___pyx_scope_struct_5_execute[__pyx_freecount_7asyncpg_8protocol_8protocol___pyx_scope_struct_5_execute++] = ((struct __pyx_obj_7asyncpg_8protocol_8protocol___pyx_scope_struct_5_execute *)o); + } else { + (*Py_TYPE(o)->tp_free)(o); + } +} + +static int __pyx_tp_traverse_7asyncpg_8protocol_8protocol___pyx_scope_struct_5_execute(PyObject *o, visitproc v, void *a) { + int e; + struct __pyx_obj_7asyncpg_8protocol_8protocol___pyx_scope_struct_5_execute *p = (struct __pyx_obj_7asyncpg_8protocol_8protocol___pyx_scope_struct_5_execute *)o; + if (p->__pyx_v_return_extra) { + e = (*v)(p->__pyx_v_return_extra, a); if (e) return e; + } + if (p->__pyx_v_self) { + e = (*v)(((PyObject*)p->__pyx_v_self), a); if (e) return e; + } + if (p->__pyx_v_state) { + e = (*v)(((PyObject*)p->__pyx_v_state), a); if (e) return e; + } + if (p->__pyx_v_timeout) { + e = (*v)(p->__pyx_v_timeout, a); if (e) return e; + } + return 0; +} + +static int __pyx_tp_clear_7asyncpg_8protocol_8protocol___pyx_scope_struct_5_execute(PyObject *o) { + PyObject* tmp; + struct __pyx_obj_7asyncpg_8protocol_8protocol___pyx_scope_struct_5_execute *p = (struct __pyx_obj_7asyncpg_8protocol_8protocol___pyx_scope_struct_5_execute *)o; + tmp = ((PyObject*)p->__pyx_v_return_extra); + p->__pyx_v_return_extra = Py_None; Py_INCREF(Py_None); + Py_XDECREF(tmp); + tmp = ((PyObject*)p->__pyx_v_self); + p->__pyx_v_self = ((struct __pyx_obj_7asyncpg_8protocol_8protocol_BaseProtocol *)Py_None); Py_INCREF(Py_None); + Py_XDECREF(tmp); + tmp = ((PyObject*)p->__pyx_v_state); + p->__pyx_v_state = ((struct __pyx_obj_7asyncpg_8protocol_8protocol_PreparedStatementState *)Py_None); Py_INCREF(Py_None); + Py_XDECREF(tmp); + tmp = ((PyObject*)p->__pyx_v_timeout); + p->__pyx_v_timeout = Py_None; Py_INCREF(Py_None); + Py_XDECREF(tmp); + return 0; +} + +static PyTypeObject __pyx_type_7asyncpg_8protocol_8protocol___pyx_scope_struct_5_execute = { + PyVarObject_HEAD_INIT(0, 0) + "asyncpg.protocol.protocol.__pyx_scope_struct_5_execute", /*tp_name*/ + sizeof(struct __pyx_obj_7asyncpg_8protocol_8protocol___pyx_scope_struct_5_execute), /*tp_basicsize*/ + 0, /*tp_itemsize*/ + __pyx_tp_dealloc_7asyncpg_8protocol_8protocol___pyx_scope_struct_5_execute, /*tp_dealloc*/ + 0, /*tp_print*/ + 0, /*tp_getattr*/ + 0, /*tp_setattr*/ + #if PY_MAJOR_VERSION < 3 + 0, /*tp_compare*/ + #endif + #if PY_MAJOR_VERSION >= 3 + 0, /*tp_as_async*/ + #endif + 0, /*tp_repr*/ + 0, /*tp_as_number*/ + 0, /*tp_as_sequence*/ + 0, /*tp_as_mapping*/ + 0, /*tp_hash*/ + 0, /*tp_call*/ + 0, /*tp_str*/ + 0, /*tp_getattro*/ + 0, /*tp_setattro*/ + 0, /*tp_as_buffer*/ + Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_HAVE_GC, /*tp_flags*/ + 0, /*tp_doc*/ + __pyx_tp_traverse_7asyncpg_8protocol_8protocol___pyx_scope_struct_5_execute, /*tp_traverse*/ + __pyx_tp_clear_7asyncpg_8protocol_8protocol___pyx_scope_struct_5_execute, /*tp_clear*/ + 0, /*tp_richcompare*/ + 0, /*tp_weaklistoffset*/ + 0, /*tp_iter*/ + 0, /*tp_iternext*/ + 0, /*tp_methods*/ + 0, /*tp_members*/ + 0, /*tp_getset*/ + 0, /*tp_base*/ + 0, /*tp_dict*/ + 0, /*tp_descr_get*/ + 0, /*tp_descr_set*/ + 0, /*tp_dictoffset*/ + 0, /*tp_init*/ + 0, /*tp_alloc*/ + __pyx_tp_new_7asyncpg_8protocol_8protocol___pyx_scope_struct_5_execute, /*tp_new*/ + 0, /*tp_free*/ + 0, /*tp_is_gc*/ + 0, /*tp_bases*/ + 0, /*tp_mro*/ + 0, /*tp_cache*/ + 0, /*tp_subclasses*/ + 0, /*tp_weaklist*/ + 0, /*tp_del*/ + 0, /*tp_version_tag*/ + #if PY_VERSION_HEX >= 0x030400a1 + 0, /*tp_finalize*/ + #endif +}; + +static struct __pyx_obj_7asyncpg_8protocol_8protocol___pyx_scope_struct_6_query *__pyx_freelist_7asyncpg_8protocol_8protocol___pyx_scope_struct_6_query[8]; +static int __pyx_freecount_7asyncpg_8protocol_8protocol___pyx_scope_struct_6_query = 0; + +static PyObject *__pyx_tp_new_7asyncpg_8protocol_8protocol___pyx_scope_struct_6_query(PyTypeObject *t, CYTHON_UNUSED PyObject *a, CYTHON_UNUSED PyObject *k) { + PyObject *o; + if (CYTHON_COMPILING_IN_CPYTHON && likely((__pyx_freecount_7asyncpg_8protocol_8protocol___pyx_scope_struct_6_query > 0) & (t->tp_basicsize == sizeof(struct __pyx_obj_7asyncpg_8protocol_8protocol___pyx_scope_struct_6_query)))) { + o = (PyObject*)__pyx_freelist_7asyncpg_8protocol_8protocol___pyx_scope_struct_6_query[--__pyx_freecount_7asyncpg_8protocol_8protocol___pyx_scope_struct_6_query]; + memset(o, 0, sizeof(struct __pyx_obj_7asyncpg_8protocol_8protocol___pyx_scope_struct_6_query)); + (void) PyObject_INIT(o, t); + PyObject_GC_Track(o); + } else { + o = (*t->tp_alloc)(t, 0); + if (unlikely(!o)) return 0; + } + return o; +} + +static void __pyx_tp_dealloc_7asyncpg_8protocol_8protocol___pyx_scope_struct_6_query(PyObject *o) { + struct __pyx_obj_7asyncpg_8protocol_8protocol___pyx_scope_struct_6_query *p = (struct __pyx_obj_7asyncpg_8protocol_8protocol___pyx_scope_struct_6_query *)o; + PyObject_GC_UnTrack(o); + Py_CLEAR(p->__pyx_v_query); + Py_CLEAR(p->__pyx_v_self); + Py_CLEAR(p->__pyx_v_timeout); + if (CYTHON_COMPILING_IN_CPYTHON && ((__pyx_freecount_7asyncpg_8protocol_8protocol___pyx_scope_struct_6_query < 8) & (Py_TYPE(o)->tp_basicsize == sizeof(struct __pyx_obj_7asyncpg_8protocol_8protocol___pyx_scope_struct_6_query)))) { + __pyx_freelist_7asyncpg_8protocol_8protocol___pyx_scope_struct_6_query[__pyx_freecount_7asyncpg_8protocol_8protocol___pyx_scope_struct_6_query++] = ((struct __pyx_obj_7asyncpg_8protocol_8protocol___pyx_scope_struct_6_query *)o); + } else { + (*Py_TYPE(o)->tp_free)(o); + } +} + +static int __pyx_tp_traverse_7asyncpg_8protocol_8protocol___pyx_scope_struct_6_query(PyObject *o, visitproc v, void *a) { + int e; + struct __pyx_obj_7asyncpg_8protocol_8protocol___pyx_scope_struct_6_query *p = (struct __pyx_obj_7asyncpg_8protocol_8protocol___pyx_scope_struct_6_query *)o; + if (p->__pyx_v_query) { + e = (*v)(p->__pyx_v_query, a); if (e) return e; + } + if (p->__pyx_v_self) { + e = (*v)(((PyObject*)p->__pyx_v_self), a); if (e) return e; + } + if (p->__pyx_v_timeout) { + e = (*v)(p->__pyx_v_timeout, a); if (e) return e; + } + return 0; +} + +static int __pyx_tp_clear_7asyncpg_8protocol_8protocol___pyx_scope_struct_6_query(PyObject *o) { + PyObject* tmp; + struct __pyx_obj_7asyncpg_8protocol_8protocol___pyx_scope_struct_6_query *p = (struct __pyx_obj_7asyncpg_8protocol_8protocol___pyx_scope_struct_6_query *)o; + tmp = ((PyObject*)p->__pyx_v_query); + p->__pyx_v_query = Py_None; Py_INCREF(Py_None); + Py_XDECREF(tmp); + tmp = ((PyObject*)p->__pyx_v_self); + p->__pyx_v_self = ((struct __pyx_obj_7asyncpg_8protocol_8protocol_BaseProtocol *)Py_None); Py_INCREF(Py_None); + Py_XDECREF(tmp); + tmp = ((PyObject*)p->__pyx_v_timeout); + p->__pyx_v_timeout = Py_None; Py_INCREF(Py_None); + Py_XDECREF(tmp); + return 0; +} + +static PyTypeObject __pyx_type_7asyncpg_8protocol_8protocol___pyx_scope_struct_6_query = { + PyVarObject_HEAD_INIT(0, 0) + "asyncpg.protocol.protocol.__pyx_scope_struct_6_query", /*tp_name*/ + sizeof(struct __pyx_obj_7asyncpg_8protocol_8protocol___pyx_scope_struct_6_query), /*tp_basicsize*/ + 0, /*tp_itemsize*/ + __pyx_tp_dealloc_7asyncpg_8protocol_8protocol___pyx_scope_struct_6_query, /*tp_dealloc*/ + 0, /*tp_print*/ + 0, /*tp_getattr*/ + 0, /*tp_setattr*/ + #if PY_MAJOR_VERSION < 3 + 0, /*tp_compare*/ + #endif + #if PY_MAJOR_VERSION >= 3 + 0, /*tp_as_async*/ + #endif + 0, /*tp_repr*/ + 0, /*tp_as_number*/ + 0, /*tp_as_sequence*/ + 0, /*tp_as_mapping*/ + 0, /*tp_hash*/ + 0, /*tp_call*/ + 0, /*tp_str*/ + 0, /*tp_getattro*/ + 0, /*tp_setattro*/ + 0, /*tp_as_buffer*/ + Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_HAVE_GC, /*tp_flags*/ + 0, /*tp_doc*/ + __pyx_tp_traverse_7asyncpg_8protocol_8protocol___pyx_scope_struct_6_query, /*tp_traverse*/ + __pyx_tp_clear_7asyncpg_8protocol_8protocol___pyx_scope_struct_6_query, /*tp_clear*/ + 0, /*tp_richcompare*/ + 0, /*tp_weaklistoffset*/ + 0, /*tp_iter*/ + 0, /*tp_iternext*/ + 0, /*tp_methods*/ + 0, /*tp_members*/ + 0, /*tp_getset*/ + 0, /*tp_base*/ + 0, /*tp_dict*/ + 0, /*tp_descr_get*/ + 0, /*tp_descr_set*/ + 0, /*tp_dictoffset*/ + 0, /*tp_init*/ + 0, /*tp_alloc*/ + __pyx_tp_new_7asyncpg_8protocol_8protocol___pyx_scope_struct_6_query, /*tp_new*/ + 0, /*tp_free*/ + 0, /*tp_is_gc*/ + 0, /*tp_bases*/ + 0, /*tp_mro*/ + 0, /*tp_cache*/ + 0, /*tp_subclasses*/ + 0, /*tp_weaklist*/ + 0, /*tp_del*/ + 0, /*tp_version_tag*/ + #if PY_VERSION_HEX >= 0x030400a1 + 0, /*tp_finalize*/ + #endif +}; + +static struct __pyx_obj_7asyncpg_8protocol_8protocol___pyx_scope_struct_7_close_statement *__pyx_freelist_7asyncpg_8protocol_8protocol___pyx_scope_struct_7_close_statement[8]; +static int __pyx_freecount_7asyncpg_8protocol_8protocol___pyx_scope_struct_7_close_statement = 0; + +static PyObject *__pyx_tp_new_7asyncpg_8protocol_8protocol___pyx_scope_struct_7_close_statement(PyTypeObject *t, CYTHON_UNUSED PyObject *a, CYTHON_UNUSED PyObject *k) { + PyObject *o; + if (CYTHON_COMPILING_IN_CPYTHON && likely((__pyx_freecount_7asyncpg_8protocol_8protocol___pyx_scope_struct_7_close_statement > 0) & (t->tp_basicsize == sizeof(struct __pyx_obj_7asyncpg_8protocol_8protocol___pyx_scope_struct_7_close_statement)))) { + o = (PyObject*)__pyx_freelist_7asyncpg_8protocol_8protocol___pyx_scope_struct_7_close_statement[--__pyx_freecount_7asyncpg_8protocol_8protocol___pyx_scope_struct_7_close_statement]; + memset(o, 0, sizeof(struct __pyx_obj_7asyncpg_8protocol_8protocol___pyx_scope_struct_7_close_statement)); + (void) PyObject_INIT(o, t); + PyObject_GC_Track(o); + } else { + o = (*t->tp_alloc)(t, 0); + if (unlikely(!o)) return 0; + } + return o; +} + +static void __pyx_tp_dealloc_7asyncpg_8protocol_8protocol___pyx_scope_struct_7_close_statement(PyObject *o) { + struct __pyx_obj_7asyncpg_8protocol_8protocol___pyx_scope_struct_7_close_statement *p = (struct __pyx_obj_7asyncpg_8protocol_8protocol___pyx_scope_struct_7_close_statement *)o; + PyObject_GC_UnTrack(o); + Py_CLEAR(p->__pyx_v_self); + Py_CLEAR(p->__pyx_v_state); + Py_CLEAR(p->__pyx_v_timeout); + if (CYTHON_COMPILING_IN_CPYTHON && ((__pyx_freecount_7asyncpg_8protocol_8protocol___pyx_scope_struct_7_close_statement < 8) & (Py_TYPE(o)->tp_basicsize == sizeof(struct __pyx_obj_7asyncpg_8protocol_8protocol___pyx_scope_struct_7_close_statement)))) { + __pyx_freelist_7asyncpg_8protocol_8protocol___pyx_scope_struct_7_close_statement[__pyx_freecount_7asyncpg_8protocol_8protocol___pyx_scope_struct_7_close_statement++] = ((struct __pyx_obj_7asyncpg_8protocol_8protocol___pyx_scope_struct_7_close_statement *)o); + } else { + (*Py_TYPE(o)->tp_free)(o); + } +} + +static int __pyx_tp_traverse_7asyncpg_8protocol_8protocol___pyx_scope_struct_7_close_statement(PyObject *o, visitproc v, void *a) { + int e; + struct __pyx_obj_7asyncpg_8protocol_8protocol___pyx_scope_struct_7_close_statement *p = (struct __pyx_obj_7asyncpg_8protocol_8protocol___pyx_scope_struct_7_close_statement *)o; + if (p->__pyx_v_self) { + e = (*v)(((PyObject*)p->__pyx_v_self), a); if (e) return e; + } + if (p->__pyx_v_state) { + e = (*v)(((PyObject*)p->__pyx_v_state), a); if (e) return e; + } + if (p->__pyx_v_timeout) { + e = (*v)(p->__pyx_v_timeout, a); if (e) return e; + } + return 0; +} + +static int __pyx_tp_clear_7asyncpg_8protocol_8protocol___pyx_scope_struct_7_close_statement(PyObject *o) { + PyObject* tmp; + struct __pyx_obj_7asyncpg_8protocol_8protocol___pyx_scope_struct_7_close_statement *p = (struct __pyx_obj_7asyncpg_8protocol_8protocol___pyx_scope_struct_7_close_statement *)o; + tmp = ((PyObject*)p->__pyx_v_self); + p->__pyx_v_self = ((struct __pyx_obj_7asyncpg_8protocol_8protocol_BaseProtocol *)Py_None); Py_INCREF(Py_None); + Py_XDECREF(tmp); + tmp = ((PyObject*)p->__pyx_v_state); + p->__pyx_v_state = ((struct __pyx_obj_7asyncpg_8protocol_8protocol_PreparedStatementState *)Py_None); Py_INCREF(Py_None); + Py_XDECREF(tmp); + tmp = ((PyObject*)p->__pyx_v_timeout); + p->__pyx_v_timeout = Py_None; Py_INCREF(Py_None); + Py_XDECREF(tmp); + return 0; +} + +static PyTypeObject __pyx_type_7asyncpg_8protocol_8protocol___pyx_scope_struct_7_close_statement = { + PyVarObject_HEAD_INIT(0, 0) + "asyncpg.protocol.protocol.__pyx_scope_struct_7_close_statement", /*tp_name*/ + sizeof(struct __pyx_obj_7asyncpg_8protocol_8protocol___pyx_scope_struct_7_close_statement), /*tp_basicsize*/ + 0, /*tp_itemsize*/ + __pyx_tp_dealloc_7asyncpg_8protocol_8protocol___pyx_scope_struct_7_close_statement, /*tp_dealloc*/ + 0, /*tp_print*/ + 0, /*tp_getattr*/ + 0, /*tp_setattr*/ + #if PY_MAJOR_VERSION < 3 + 0, /*tp_compare*/ + #endif + #if PY_MAJOR_VERSION >= 3 + 0, /*tp_as_async*/ + #endif + 0, /*tp_repr*/ + 0, /*tp_as_number*/ + 0, /*tp_as_sequence*/ + 0, /*tp_as_mapping*/ + 0, /*tp_hash*/ + 0, /*tp_call*/ + 0, /*tp_str*/ + 0, /*tp_getattro*/ + 0, /*tp_setattro*/ + 0, /*tp_as_buffer*/ + Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_HAVE_GC, /*tp_flags*/ + 0, /*tp_doc*/ + __pyx_tp_traverse_7asyncpg_8protocol_8protocol___pyx_scope_struct_7_close_statement, /*tp_traverse*/ + __pyx_tp_clear_7asyncpg_8protocol_8protocol___pyx_scope_struct_7_close_statement, /*tp_clear*/ + 0, /*tp_richcompare*/ + 0, /*tp_weaklistoffset*/ + 0, /*tp_iter*/ + 0, /*tp_iternext*/ + 0, /*tp_methods*/ + 0, /*tp_members*/ + 0, /*tp_getset*/ + 0, /*tp_base*/ + 0, /*tp_dict*/ + 0, /*tp_descr_get*/ + 0, /*tp_descr_set*/ + 0, /*tp_dictoffset*/ + 0, /*tp_init*/ + 0, /*tp_alloc*/ + __pyx_tp_new_7asyncpg_8protocol_8protocol___pyx_scope_struct_7_close_statement, /*tp_new*/ + 0, /*tp_free*/ + 0, /*tp_is_gc*/ + 0, /*tp_bases*/ + 0, /*tp_mro*/ + 0, /*tp_cache*/ + 0, /*tp_subclasses*/ + 0, /*tp_weaklist*/ + 0, /*tp_del*/ + 0, /*tp_version_tag*/ + #if PY_VERSION_HEX >= 0x030400a1 + 0, /*tp_finalize*/ + #endif +}; + +static struct __pyx_obj_7asyncpg_8protocol_8protocol___pyx_scope_struct_8_close *__pyx_freelist_7asyncpg_8protocol_8protocol___pyx_scope_struct_8_close[8]; +static int __pyx_freecount_7asyncpg_8protocol_8protocol___pyx_scope_struct_8_close = 0; + +static PyObject *__pyx_tp_new_7asyncpg_8protocol_8protocol___pyx_scope_struct_8_close(PyTypeObject *t, CYTHON_UNUSED PyObject *a, CYTHON_UNUSED PyObject *k) { + PyObject *o; + if (CYTHON_COMPILING_IN_CPYTHON && likely((__pyx_freecount_7asyncpg_8protocol_8protocol___pyx_scope_struct_8_close > 0) & (t->tp_basicsize == sizeof(struct __pyx_obj_7asyncpg_8protocol_8protocol___pyx_scope_struct_8_close)))) { + o = (PyObject*)__pyx_freelist_7asyncpg_8protocol_8protocol___pyx_scope_struct_8_close[--__pyx_freecount_7asyncpg_8protocol_8protocol___pyx_scope_struct_8_close]; + memset(o, 0, sizeof(struct __pyx_obj_7asyncpg_8protocol_8protocol___pyx_scope_struct_8_close)); + (void) PyObject_INIT(o, t); + PyObject_GC_Track(o); + } else { + o = (*t->tp_alloc)(t, 0); + if (unlikely(!o)) return 0; + } + return o; +} + +static void __pyx_tp_dealloc_7asyncpg_8protocol_8protocol___pyx_scope_struct_8_close(PyObject *o) { + struct __pyx_obj_7asyncpg_8protocol_8protocol___pyx_scope_struct_8_close *p = (struct __pyx_obj_7asyncpg_8protocol_8protocol___pyx_scope_struct_8_close *)o; + PyObject_GC_UnTrack(o); + Py_CLEAR(p->__pyx_v_self); + if (CYTHON_COMPILING_IN_CPYTHON && ((__pyx_freecount_7asyncpg_8protocol_8protocol___pyx_scope_struct_8_close < 8) & (Py_TYPE(o)->tp_basicsize == sizeof(struct __pyx_obj_7asyncpg_8protocol_8protocol___pyx_scope_struct_8_close)))) { + __pyx_freelist_7asyncpg_8protocol_8protocol___pyx_scope_struct_8_close[__pyx_freecount_7asyncpg_8protocol_8protocol___pyx_scope_struct_8_close++] = ((struct __pyx_obj_7asyncpg_8protocol_8protocol___pyx_scope_struct_8_close *)o); + } else { + (*Py_TYPE(o)->tp_free)(o); + } +} + +static int __pyx_tp_traverse_7asyncpg_8protocol_8protocol___pyx_scope_struct_8_close(PyObject *o, visitproc v, void *a) { + int e; + struct __pyx_obj_7asyncpg_8protocol_8protocol___pyx_scope_struct_8_close *p = (struct __pyx_obj_7asyncpg_8protocol_8protocol___pyx_scope_struct_8_close *)o; + if (p->__pyx_v_self) { + e = (*v)(((PyObject*)p->__pyx_v_self), a); if (e) return e; + } + return 0; +} + +static int __pyx_tp_clear_7asyncpg_8protocol_8protocol___pyx_scope_struct_8_close(PyObject *o) { + PyObject* tmp; + struct __pyx_obj_7asyncpg_8protocol_8protocol___pyx_scope_struct_8_close *p = (struct __pyx_obj_7asyncpg_8protocol_8protocol___pyx_scope_struct_8_close *)o; + tmp = ((PyObject*)p->__pyx_v_self); + p->__pyx_v_self = ((struct __pyx_obj_7asyncpg_8protocol_8protocol_BaseProtocol *)Py_None); Py_INCREF(Py_None); + Py_XDECREF(tmp); + return 0; +} + +static PyTypeObject __pyx_type_7asyncpg_8protocol_8protocol___pyx_scope_struct_8_close = { + PyVarObject_HEAD_INIT(0, 0) + "asyncpg.protocol.protocol.__pyx_scope_struct_8_close", /*tp_name*/ + sizeof(struct __pyx_obj_7asyncpg_8protocol_8protocol___pyx_scope_struct_8_close), /*tp_basicsize*/ + 0, /*tp_itemsize*/ + __pyx_tp_dealloc_7asyncpg_8protocol_8protocol___pyx_scope_struct_8_close, /*tp_dealloc*/ + 0, /*tp_print*/ + 0, /*tp_getattr*/ + 0, /*tp_setattr*/ + #if PY_MAJOR_VERSION < 3 + 0, /*tp_compare*/ + #endif + #if PY_MAJOR_VERSION >= 3 + 0, /*tp_as_async*/ + #endif + 0, /*tp_repr*/ + 0, /*tp_as_number*/ + 0, /*tp_as_sequence*/ + 0, /*tp_as_mapping*/ + 0, /*tp_hash*/ + 0, /*tp_call*/ + 0, /*tp_str*/ + 0, /*tp_getattro*/ + 0, /*tp_setattro*/ + 0, /*tp_as_buffer*/ + Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_HAVE_GC, /*tp_flags*/ + 0, /*tp_doc*/ + __pyx_tp_traverse_7asyncpg_8protocol_8protocol___pyx_scope_struct_8_close, /*tp_traverse*/ + __pyx_tp_clear_7asyncpg_8protocol_8protocol___pyx_scope_struct_8_close, /*tp_clear*/ + 0, /*tp_richcompare*/ + 0, /*tp_weaklistoffset*/ + 0, /*tp_iter*/ + 0, /*tp_iternext*/ + 0, /*tp_methods*/ + 0, /*tp_members*/ + 0, /*tp_getset*/ + 0, /*tp_base*/ + 0, /*tp_dict*/ + 0, /*tp_descr_get*/ + 0, /*tp_descr_set*/ + 0, /*tp_dictoffset*/ + 0, /*tp_init*/ + 0, /*tp_alloc*/ + __pyx_tp_new_7asyncpg_8protocol_8protocol___pyx_scope_struct_8_close, /*tp_new*/ + 0, /*tp_free*/ + 0, /*tp_is_gc*/ + 0, /*tp_bases*/ + 0, /*tp_mro*/ + 0, /*tp_cache*/ + 0, /*tp_subclasses*/ + 0, /*tp_weaklist*/ + 0, /*tp_del*/ + 0, /*tp_version_tag*/ + #if PY_VERSION_HEX >= 0x030400a1 + 0, /*tp_finalize*/ + #endif +}; + +static PyMethodDef __pyx_methods[] = { + {0, 0, 0, 0} +}; + +#if PY_MAJOR_VERSION >= 3 +static struct PyModuleDef __pyx_moduledef = { + #if PY_VERSION_HEX < 0x03020000 + { PyObject_HEAD_INIT(NULL) NULL, 0, NULL }, + #else + PyModuleDef_HEAD_INIT, + #endif + "protocol", + 0, /* m_doc */ + -1, /* m_size */ + __pyx_methods /* m_methods */, + NULL, /* m_reload */ + NULL, /* m_traverse */ + NULL, /* m_clear */ + NULL /* m_free */ +}; +#endif + +static __Pyx_StringTabEntry __pyx_string_tab[] = { + {&__pyx_n_s_AF_UNIX, __pyx_k_AF_UNIX, sizeof(__pyx_k_AF_UNIX), 0, 0, 1, 1}, + {&__pyx_n_u_AF_UNIX, __pyx_k_AF_UNIX, sizeof(__pyx_k_AF_UNIX), 0, 1, 0, 1}, + {&__pyx_n_s_ARRAY_TYPES, __pyx_k_ARRAY_TYPES, sizeof(__pyx_k_ARRAY_TYPES), 0, 0, 1, 1}, + {&__pyx_n_s_AUTH_METHOD_NAME, __pyx_k_AUTH_METHOD_NAME, sizeof(__pyx_k_AUTH_METHOD_NAME), 0, 0, 1, 1}, + {&__pyx_n_s_Attribute, __pyx_k_Attribute, sizeof(__pyx_k_Attribute), 0, 0, 1, 1}, + {&__pyx_n_s_AttributeError, __pyx_k_AttributeError, sizeof(__pyx_k_AttributeError), 0, 0, 1, 1}, + {&__pyx_n_s_BaseProtocol_bind, __pyx_k_BaseProtocol_bind, sizeof(__pyx_k_BaseProtocol_bind), 0, 0, 1, 1}, + {&__pyx_n_s_BaseProtocol_bind_execute, __pyx_k_BaseProtocol_bind_execute, sizeof(__pyx_k_BaseProtocol_bind_execute), 0, 0, 1, 1}, + {&__pyx_n_s_BaseProtocol_bind_execute_many, __pyx_k_BaseProtocol_bind_execute_many, sizeof(__pyx_k_BaseProtocol_bind_execute_many), 0, 0, 1, 1}, + {&__pyx_n_s_BaseProtocol_close, __pyx_k_BaseProtocol_close, sizeof(__pyx_k_BaseProtocol_close), 0, 0, 1, 1}, + {&__pyx_n_s_BaseProtocol_close_statement, __pyx_k_BaseProtocol_close_statement, sizeof(__pyx_k_BaseProtocol_close_statement), 0, 0, 1, 1}, + {&__pyx_n_s_BaseProtocol_execute, __pyx_k_BaseProtocol_execute, sizeof(__pyx_k_BaseProtocol_execute), 0, 0, 1, 1}, + {&__pyx_n_s_BaseProtocol_prepare, __pyx_k_BaseProtocol_prepare, sizeof(__pyx_k_BaseProtocol_prepare), 0, 0, 1, 1}, + {&__pyx_n_s_BaseProtocol_query, __pyx_k_BaseProtocol_query, sizeof(__pyx_k_BaseProtocol_query), 0, 0, 1, 1}, + {&__pyx_n_s_BitString, __pyx_k_BitString, sizeof(__pyx_k_BitString), 0, 0, 1, 1}, + {&__pyx_n_s_Box, __pyx_k_Box, sizeof(__pyx_k_Box), 0, 0, 1, 1}, + {&__pyx_n_s_BufferError, __pyx_k_BufferError, sizeof(__pyx_k_BufferError), 0, 0, 1, 1}, + {&__pyx_n_s_Circle, __pyx_k_Circle, sizeof(__pyx_k_Circle), 0, 0, 1, 1}, + {&__pyx_kp_u_Codec_oid_elem_oid_core, __pyx_k_Codec_oid_elem_oid_core, sizeof(__pyx_k_Codec_oid_elem_oid_core), 0, 1, 0, 0}, + {&__pyx_n_s_ConnectionDoesNotExistError, __pyx_k_ConnectionDoesNotExistError, sizeof(__pyx_k_ConnectionDoesNotExistError), 0, 0, 1, 1}, + {&__pyx_n_s_Container, __pyx_k_Container, sizeof(__pyx_k_Container), 0, 0, 1, 1}, + {&__pyx_n_s_ContainerABC, __pyx_k_ContainerABC, sizeof(__pyx_k_ContainerABC), 0, 0, 1, 1}, + {&__pyx_kp_u_Deallocating_buffer_with_attache, __pyx_k_Deallocating_buffer_with_attache, sizeof(__pyx_k_Deallocating_buffer_with_attache), 0, 1, 0, 0}, + {&__pyx_n_s_Dec, __pyx_k_Dec, sizeof(__pyx_k_Dec), 0, 0, 1, 1}, + {&__pyx_n_s_Decimal, __pyx_k_Decimal, sizeof(__pyx_k_Decimal), 0, 0, 1, 1}, + {&__pyx_n_s_Future, __pyx_k_Future, sizeof(__pyx_k_Future), 0, 0, 1, 1}, + {&__pyx_n_s_IPPROTO_TCP, __pyx_k_IPPROTO_TCP, sizeof(__pyx_k_IPPROTO_TCP), 0, 0, 1, 1}, + {&__pyx_n_s_InterfaceError, __pyx_k_InterfaceError, sizeof(__pyx_k_InterfaceError), 0, 0, 1, 1}, + {&__pyx_n_s_KeyError, __pyx_k_KeyError, sizeof(__pyx_k_KeyError), 0, 0, 1, 1}, + {&__pyx_n_s_Line, __pyx_k_Line, sizeof(__pyx_k_Line), 0, 0, 1, 1}, + {&__pyx_n_s_LineSegment, __pyx_k_LineSegment, sizeof(__pyx_k_LineSegment), 0, 0, 1, 1}, + {&__pyx_n_s_MAXYEAR, __pyx_k_MAXYEAR, sizeof(__pyx_k_MAXYEAR), 0, 0, 1, 1}, + {&__pyx_n_s_MINYEAR, __pyx_k_MINYEAR, sizeof(__pyx_k_MINYEAR), 0, 0, 1, 1}, + {&__pyx_n_s_MemoryError, __pyx_k_MemoryError, sizeof(__pyx_k_MemoryError), 0, 0, 1, 1}, + {&__pyx_n_u_NA, __pyx_k_NA, sizeof(__pyx_k_NA), 0, 1, 0, 1}, + {&__pyx_n_s_NotImplementedError, __pyx_k_NotImplementedError, sizeof(__pyx_k_NotImplementedError), 0, 0, 1, 1}, + {&__pyx_n_s_OrderedDict, __pyx_k_OrderedDict, sizeof(__pyx_k_OrderedDict), 0, 0, 1, 1}, + {&__pyx_n_s_Path, __pyx_k_Path, sizeof(__pyx_k_Path), 0, 0, 1, 1}, + {&__pyx_n_s_Point, __pyx_k_Point, sizeof(__pyx_k_Point), 0, 0, 1, 1}, + {&__pyx_n_s_Polygon, __pyx_k_Polygon, sizeof(__pyx_k_Polygon), 0, 0, 1, 1}, + {&__pyx_n_s_PostgresMessage, __pyx_k_PostgresMessage, sizeof(__pyx_k_PostgresMessage), 0, 0, 1, 1}, + {&__pyx_n_s_Protocol, __pyx_k_Protocol, sizeof(__pyx_k_Protocol), 0, 0, 1, 1}, + {&__pyx_n_s_Range, __pyx_k_Range, sizeof(__pyx_k_Range), 0, 0, 1, 1}, + {&__pyx_n_s_RuntimeError, __pyx_k_RuntimeError, sizeof(__pyx_k_RuntimeError), 0, 0, 1, 1}, + {&__pyx_n_s_StopIteration, __pyx_k_StopIteration, sizeof(__pyx_k_StopIteration), 0, 0, 1, 1}, + {&__pyx_n_s_TCP_NODELAY, __pyx_k_TCP_NODELAY, sizeof(__pyx_k_TCP_NODELAY), 0, 0, 1, 1}, + {&__pyx_n_s_TYPEMAP, __pyx_k_TYPEMAP, sizeof(__pyx_k_TYPEMAP), 0, 0, 1, 1}, + {&__pyx_n_s_TimeoutError, __pyx_k_TimeoutError, sizeof(__pyx_k_TimeoutError), 0, 0, 1, 1}, + {&__pyx_n_s_Type, __pyx_k_Type, sizeof(__pyx_k_Type), 0, 0, 1, 1}, + {&__pyx_n_s_TypeError, __pyx_k_TypeError, sizeof(__pyx_k_TypeError), 0, 0, 1, 1}, + {&__pyx_n_s_UUID, __pyx_k_UUID, sizeof(__pyx_k_UUID), 0, 0, 1, 1}, + {&__pyx_n_s_UUID_2, __pyx_k_UUID_2, sizeof(__pyx_k_UUID_2), 0, 0, 1, 1}, + {&__pyx_n_s_ValueError, __pyx_k_ValueError, sizeof(__pyx_k_ValueError), 0, 0, 1, 1}, + {&__pyx_kp_b__18, __pyx_k__18, sizeof(__pyx_k__18), 0, 0, 0, 0}, + {&__pyx_kp_u__18, __pyx_k__18, sizeof(__pyx_k__18), 0, 1, 0, 0}, + {&__pyx_kp_b__19, __pyx_k__19, sizeof(__pyx_k__19), 0, 0, 0, 0}, + {&__pyx_kp_u__28, __pyx_k__28, sizeof(__pyx_k__28), 0, 1, 0, 0}, + {&__pyx_n_u__3, __pyx_k__3, sizeof(__pyx_k__3), 0, 1, 0, 1}, + {&__pyx_kp_u__66, __pyx_k__66, sizeof(__pyx_k__66), 0, 1, 0, 0}, + {&__pyx_kp_u_a_boolean_is_required_got_type, __pyx_k_a_boolean_is_required_got_type, sizeof(__pyx_k_a_boolean_is_required_got_type), 0, 1, 0, 0}, + {&__pyx_kp_u_a_non_trivial_iterable_expected, __pyx_k_a_non_trivial_iterable_expected, sizeof(__pyx_k_a_non_trivial_iterable_expected), 0, 1, 0, 0}, + {&__pyx_n_u_abc, __pyx_k_abc, sizeof(__pyx_k_abc), 0, 1, 0, 1}, + {&__pyx_n_s_abort, __pyx_k_abort, sizeof(__pyx_k_abort), 0, 0, 1, 1}, + {&__pyx_n_u_abstime, __pyx_k_abstime, sizeof(__pyx_k_abstime), 0, 1, 0, 1}, + {&__pyx_n_u_aclitem, __pyx_k_aclitem, sizeof(__pyx_k_aclitem), 0, 1, 0, 1}, + {&__pyx_n_s_add, __pyx_k_add, sizeof(__pyx_k_add), 0, 0, 1, 1}, + {&__pyx_n_s_add_done_callback, __pyx_k_add_done_callback, sizeof(__pyx_k_add_done_callback), 0, 0, 1, 1}, + {&__pyx_n_s_add_python_codec, __pyx_k_add_python_codec, sizeof(__pyx_k_add_python_codec), 0, 0, 1, 1}, + {&__pyx_n_s_add_types, __pyx_k_add_types, sizeof(__pyx_k_add_types), 0, 0, 1, 1}, + {&__pyx_n_s_addr, __pyx_k_addr, sizeof(__pyx_k_addr), 0, 0, 1, 1}, + {&__pyx_n_s_alias_to, __pyx_k_alias_to, sizeof(__pyx_k_alias_to), 0, 0, 1, 1}, + {&__pyx_kp_u_already_connected, __pyx_k_already_connected, sizeof(__pyx_k_already_connected), 0, 1, 0, 0}, + {&__pyx_n_u_alt, __pyx_k_alt, sizeof(__pyx_k_alt), 0, 1, 0, 1}, + {&__pyx_n_u_any, __pyx_k_any, sizeof(__pyx_k_any), 0, 1, 0, 1}, + {&__pyx_n_u_anyarray, __pyx_k_anyarray, sizeof(__pyx_k_anyarray), 0, 1, 0, 1}, + {&__pyx_n_u_anyelement, __pyx_k_anyelement, sizeof(__pyx_k_anyelement), 0, 1, 0, 1}, + {&__pyx_n_u_anyenum, __pyx_k_anyenum, sizeof(__pyx_k_anyenum), 0, 1, 0, 1}, + {&__pyx_n_u_anynonarray, __pyx_k_anynonarray, sizeof(__pyx_k_anynonarray), 0, 1, 0, 1}, + {&__pyx_n_u_anyrange, __pyx_k_anyrange, sizeof(__pyx_k_anyrange), 0, 1, 0, 1}, + {&__pyx_n_s_apg_exc, __pyx_k_apg_exc, sizeof(__pyx_k_apg_exc), 0, 0, 1, 1}, + {&__pyx_n_s_apg_exc_base, __pyx_k_apg_exc_base, sizeof(__pyx_k_apg_exc_base), 0, 0, 1, 1}, + {&__pyx_n_s_apg_types, __pyx_k_apg_types, sizeof(__pyx_k_apg_types), 0, 0, 1, 1}, + {&__pyx_n_s_append, __pyx_k_append, sizeof(__pyx_k_append), 0, 0, 1, 1}, + {&__pyx_n_s_args, __pyx_k_args, sizeof(__pyx_k_args), 0, 0, 1, 1}, + {&__pyx_n_u_array, __pyx_k_array, sizeof(__pyx_k_array), 0, 1, 0, 1}, + {&__pyx_n_u_ascii, __pyx_k_ascii, sizeof(__pyx_k_ascii), 0, 1, 0, 1}, + {&__pyx_n_s_astimezone, __pyx_k_astimezone, sizeof(__pyx_k_astimezone), 0, 0, 1, 1}, + {&__pyx_n_s_asyncio, __pyx_k_asyncio, sizeof(__pyx_k_asyncio), 0, 0, 1, 1}, + {&__pyx_n_s_asyncio_coroutines, __pyx_k_asyncio_coroutines, sizeof(__pyx_k_asyncio_coroutines), 0, 0, 1, 1}, + {&__pyx_n_s_asyncio_tasks, __pyx_k_asyncio_tasks, sizeof(__pyx_k_asyncio_tasks), 0, 0, 1, 1}, + {&__pyx_n_s_asyncpg, __pyx_k_asyncpg, sizeof(__pyx_k_asyncpg), 0, 0, 1, 1}, + {&__pyx_n_s_asyncpg_exceptions, __pyx_k_asyncpg_exceptions, sizeof(__pyx_k_asyncpg_exceptions), 0, 0, 1, 1}, + {&__pyx_n_s_asyncpg_protocol_protocol, __pyx_k_asyncpg_protocol_protocol, sizeof(__pyx_k_asyncpg_protocol_protocol), 0, 0, 1, 1}, + {&__pyx_n_s_asyncpg_types, __pyx_k_asyncpg_types, sizeof(__pyx_k_asyncpg_types), 0, 0, 1, 1}, + {&__pyx_n_u_attrnames, __pyx_k_attrnames, sizeof(__pyx_k_attrnames), 0, 1, 0, 1}, + {&__pyx_n_u_attrtypoids, __pyx_k_attrtypoids, sizeof(__pyx_k_attrtypoids), 0, 1, 0, 1}, + {&__pyx_n_s_auth_msg, __pyx_k_auth_msg, sizeof(__pyx_k_auth_msg), 0, 0, 1, 1}, + {&__pyx_n_s_await, __pyx_k_await, sizeof(__pyx_k_await), 0, 0, 1, 1}, + {&__pyx_n_s_base, __pyx_k_base, sizeof(__pyx_k_base), 0, 0, 1, 1}, + {&__pyx_n_u_basetype, __pyx_k_basetype, sizeof(__pyx_k_basetype), 0, 1, 0, 1}, + {&__pyx_n_s_binary, __pyx_k_binary, sizeof(__pyx_k_binary), 0, 0, 1, 1}, + {&__pyx_n_s_bind, __pyx_k_bind, sizeof(__pyx_k_bind), 0, 0, 1, 1}, + {&__pyx_n_s_bind_execute, __pyx_k_bind_execute, sizeof(__pyx_k_bind_execute), 0, 0, 1, 1}, + {&__pyx_n_s_bind_execute_many, __pyx_k_bind_execute_many, sizeof(__pyx_k_bind_execute_many), 0, 0, 1, 1}, + {&__pyx_n_s_bind_execute_many_locals_genexpr, __pyx_k_bind_execute_many_locals_genexpr, sizeof(__pyx_k_bind_execute_many_locals_genexpr), 0, 0, 1, 1}, + {&__pyx_n_u_bit, __pyx_k_bit, sizeof(__pyx_k_bit), 0, 1, 0, 1}, + {&__pyx_kp_u_bit_value_too_long, __pyx_k_bit_value_too_long, sizeof(__pyx_k_bit_value_too_long), 0, 1, 0, 0}, + {&__pyx_n_u_bool, __pyx_k_bool, sizeof(__pyx_k_bool), 0, 1, 0, 1}, + {&__pyx_n_u_box, __pyx_k_box, sizeof(__pyx_k_box), 0, 1, 0, 1}, + {&__pyx_n_u_bpchar, __pyx_k_bpchar, sizeof(__pyx_k_bpchar), 0, 1, 0, 1}, + {&__pyx_kp_u_buffer_overread, __pyx_k_buffer_overread, sizeof(__pyx_k_buffer_overread), 0, 1, 0, 0}, + {&__pyx_n_u_bytea, __pyx_k_bytea, sizeof(__pyx_k_bytea), 0, 1, 0, 1}, + {&__pyx_n_s_bytes, __pyx_k_bytes, sizeof(__pyx_k_bytes), 0, 0, 1, 1}, + {&__pyx_n_b_c, __pyx_k_c, sizeof(__pyx_k_c), 0, 0, 0, 1}, + {&__pyx_n_s_cache_key, __pyx_k_cache_key, sizeof(__pyx_k_cache_key), 0, 0, 1, 1}, + {&__pyx_n_s_call_later, __pyx_k_call_later, sizeof(__pyx_k_call_later), 0, 0, 1, 1}, + {&__pyx_n_s_cancel, __pyx_k_cancel, sizeof(__pyx_k_cancel), 0, 0, 1, 1}, + {&__pyx_n_s_cancel_current_command, __pyx_k_cancel_current_command, sizeof(__pyx_k_cancel_current_command), 0, 0, 1, 1}, + {&__pyx_n_s_cancelled, __pyx_k_cancelled, sizeof(__pyx_k_cancelled), 0, 0, 1, 1}, + {&__pyx_kp_u_cannot_close_prepared_statement, __pyx_k_cannot_close_prepared_statement, sizeof(__pyx_k_cannot_close_prepared_statement), 0, 1, 0, 0}, + {&__pyx_kp_u_cannot_override_codec_for_type, __pyx_k_cannot_override_codec_for_type, sizeof(__pyx_k_cannot_override_codec_for_type), 0, 1, 0, 0}, + {&__pyx_kp_u_cannot_perform_operation_another, __pyx_k_cannot_perform_operation_another, sizeof(__pyx_k_cannot_perform_operation_another), 0, 1, 0, 0}, + {&__pyx_kp_u_cannot_perform_operation_another_2, __pyx_k_cannot_perform_operation_another_2, sizeof(__pyx_k_cannot_perform_operation_another_2), 0, 1, 0, 0}, + {&__pyx_kp_u_cannot_perform_operation_connect, __pyx_k_cannot_perform_operation_connect, sizeof(__pyx_k_cannot_perform_operation_connect), 0, 1, 0, 0}, + {&__pyx_kp_u_cannot_register_core_codec_for_O, __pyx_k_cannot_register_core_codec_for_O, sizeof(__pyx_k_cannot_register_core_codec_for_O), 0, 1, 0, 0}, + {&__pyx_kp_u_cannot_start_message_for_a_non_e, __pyx_k_cannot_start_message_for_a_non_e, sizeof(__pyx_k_cannot_start_message_for_a_non_e), 0, 1, 0, 0}, + {&__pyx_kp_u_cannot_switch_to_idle_state_prot, __pyx_k_cannot_switch_to_idle_state_prot, sizeof(__pyx_k_cannot_switch_to_idle_state_prot), 0, 1, 0, 0}, + {&__pyx_kp_u_cannot_switch_to_state_another_o, __pyx_k_cannot_switch_to_state_another_o, sizeof(__pyx_k_cannot_switch_to_state_another_o), 0, 1, 0, 0}, + {&__pyx_kp_u_cannot_switch_to_state_protocol, __pyx_k_cannot_switch_to_state_protocol, sizeof(__pyx_k_cannot_switch_to_state_protocol), 0, 1, 0, 0}, + {&__pyx_n_s_cause, __pyx_k_cause, sizeof(__pyx_k_cause), 0, 0, 1, 1}, + {&__pyx_n_u_char, __pyx_k_char, sizeof(__pyx_k_char), 0, 1, 0, 1}, + {&__pyx_n_s_chr, __pyx_k_chr, sizeof(__pyx_k_chr), 0, 0, 1, 1}, + {&__pyx_n_u_cid, __pyx_k_cid, sizeof(__pyx_k_cid), 0, 1, 0, 1}, + {&__pyx_n_u_cidr, __pyx_k_cidr, sizeof(__pyx_k_cidr), 0, 1, 0, 1}, + {&__pyx_n_u_circle, __pyx_k_circle, sizeof(__pyx_k_circle), 0, 1, 0, 1}, + {&__pyx_n_b_client_encoding, __pyx_k_client_encoding, sizeof(__pyx_k_client_encoding), 0, 0, 0, 1}, + {&__pyx_n_u_client_encoding, __pyx_k_client_encoding, sizeof(__pyx_k_client_encoding), 0, 1, 0, 1}, + {&__pyx_n_s_close, __pyx_k_close, sizeof(__pyx_k_close), 0, 0, 1, 1}, + {&__pyx_n_s_close_statement, __pyx_k_close_statement, sizeof(__pyx_k_close_statement), 0, 0, 1, 1}, + {&__pyx_n_s_codecs, __pyx_k_codecs, sizeof(__pyx_k_codecs), 0, 0, 1, 1}, + {&__pyx_n_s_collections, __pyx_k_collections, sizeof(__pyx_k_collections), 0, 0, 1, 1}, + {&__pyx_n_s_collections_abc, __pyx_k_collections_abc, sizeof(__pyx_k_collections_abc), 0, 0, 1, 1}, + {&__pyx_n_s_command_timeout, __pyx_k_command_timeout, sizeof(__pyx_k_command_timeout), 0, 0, 1, 1}, + {&__pyx_n_u_composite, __pyx_k_composite, sizeof(__pyx_k_composite), 0, 1, 0, 1}, + {&__pyx_n_s_con_args, __pyx_k_con_args, sizeof(__pyx_k_con_args), 0, 0, 1, 1}, + {&__pyx_n_s_conn_key, __pyx_k_conn_key, sizeof(__pyx_k_conn_key), 0, 0, 1, 1}, + {&__pyx_n_s_connected_fut, __pyx_k_connected_fut, sizeof(__pyx_k_connected_fut), 0, 0, 1, 1}, + {&__pyx_kp_u_connection_was_closed_in_the_mid, __pyx_k_connection_was_closed_in_the_mid, sizeof(__pyx_k_connection_was_closed_in_the_mid), 0, 1, 0, 0}, + {&__pyx_n_u_cp1250, __pyx_k_cp1250, sizeof(__pyx_k_cp1250), 0, 1, 0, 1}, + {&__pyx_n_u_cp1251, __pyx_k_cp1251, sizeof(__pyx_k_cp1251), 0, 1, 0, 1}, + {&__pyx_n_u_cp1252, __pyx_k_cp1252, sizeof(__pyx_k_cp1252), 0, 1, 0, 1}, + {&__pyx_n_u_cp1253, __pyx_k_cp1253, sizeof(__pyx_k_cp1253), 0, 1, 0, 1}, + {&__pyx_n_u_cp1254, __pyx_k_cp1254, sizeof(__pyx_k_cp1254), 0, 1, 0, 1}, + {&__pyx_n_u_cp1255, __pyx_k_cp1255, sizeof(__pyx_k_cp1255), 0, 1, 0, 1}, + {&__pyx_n_u_cp1256, __pyx_k_cp1256, sizeof(__pyx_k_cp1256), 0, 1, 0, 1}, + {&__pyx_n_u_cp1257, __pyx_k_cp1257, sizeof(__pyx_k_cp1257), 0, 1, 0, 1}, + {&__pyx_n_u_cp1258, __pyx_k_cp1258, sizeof(__pyx_k_cp1258), 0, 1, 0, 1}, + {&__pyx_n_u_cp1521, __pyx_k_cp1521, sizeof(__pyx_k_cp1521), 0, 1, 0, 1}, + {&__pyx_n_u_cp866, __pyx_k_cp866, sizeof(__pyx_k_cp866), 0, 1, 0, 1}, + {&__pyx_n_u_cp874, __pyx_k_cp874, sizeof(__pyx_k_cp874), 0, 1, 0, 1}, + {&__pyx_n_u_cp932, __pyx_k_cp932, sizeof(__pyx_k_cp932), 0, 1, 0, 1}, + {&__pyx_n_u_cp936, __pyx_k_cp936, sizeof(__pyx_k_cp936), 0, 1, 0, 1}, + {&__pyx_n_u_cp949, __pyx_k_cp949, sizeof(__pyx_k_cp949), 0, 1, 0, 1}, + {&__pyx_n_u_cp950, __pyx_k_cp950, sizeof(__pyx_k_cp950), 0, 1, 0, 1}, + {&__pyx_n_s_create_future, __pyx_k_create_future, sizeof(__pyx_k_create_future), 0, 0, 1, 1}, + {&__pyx_n_s_create_future_fallback, __pyx_k_create_future_fallback, sizeof(__pyx_k_create_future_fallback), 0, 0, 1, 1}, + {&__pyx_n_s_create_record, __pyx_k_create_record, sizeof(__pyx_k_create_record), 0, 0, 1, 1}, + {&__pyx_n_u_cstring, __pyx_k_cstring, sizeof(__pyx_k_cstring), 0, 1, 0, 1}, + {&__pyx_n_b_d, __pyx_k_d, sizeof(__pyx_k_d), 0, 0, 0, 1}, + {&__pyx_n_u_database, __pyx_k_database, sizeof(__pyx_k_database), 0, 1, 0, 1}, + {&__pyx_n_s_date, __pyx_k_date, sizeof(__pyx_k_date), 0, 0, 1, 1}, + {&__pyx_n_u_date, __pyx_k_date, sizeof(__pyx_k_date), 0, 1, 0, 1}, + {&__pyx_n_s_date_from_ordinal, __pyx_k_date_from_ordinal, sizeof(__pyx_k_date_from_ordinal), 0, 0, 1, 1}, + {&__pyx_n_s_datetime, __pyx_k_datetime, sizeof(__pyx_k_datetime), 0, 0, 1, 1}, + {&__pyx_n_s_days, __pyx_k_days, sizeof(__pyx_k_days), 0, 0, 1, 1}, + {&__pyx_kp_u_debug_first_buffer_of_ReadBuffer, __pyx_k_debug_first_buffer_of_ReadBuffer, sizeof(__pyx_k_debug_first_buffer_of_ReadBuffer), 0, 1, 0, 0}, + {&__pyx_kp_u_debug_second_buffer_of_ReadBuffe, __pyx_k_debug_second_buffer_of_ReadBuffe, sizeof(__pyx_k_debug_second_buffer_of_ReadBuffe), 0, 1, 0, 0}, + {&__pyx_n_s_decimal, __pyx_k_decimal, sizeof(__pyx_k_decimal), 0, 0, 1, 1}, + {&__pyx_n_s_decode, __pyx_k_decode, sizeof(__pyx_k_decode), 0, 0, 1, 1}, + {&__pyx_kp_u_decode_row_statement_is_None, __pyx_k_decode_row_statement_is_None, sizeof(__pyx_k_decode_row_statement_is_None), 0, 1, 0, 0}, + {&__pyx_n_s_decoder, __pyx_k_decoder, sizeof(__pyx_k_decoder), 0, 0, 1, 1}, + {&__pyx_n_s_deque, __pyx_k_deque, sizeof(__pyx_k_deque), 0, 0, 1, 1}, + {&__pyx_n_s_desc, __pyx_k_desc, sizeof(__pyx_k_desc), 0, 0, 1, 1}, + {&__pyx_kp_u_discarding_message_r_unread_dat, __pyx_k_discarding_message_r_unread_dat, sizeof(__pyx_k_discarding_message_r_unread_dat), 0, 1, 0, 0}, + {&__pyx_n_s_doc, __pyx_k_doc, sizeof(__pyx_k_doc), 0, 0, 1, 1}, + {&__pyx_n_s_done, __pyx_k_done, sizeof(__pyx_k_done), 0, 0, 1, 1}, + {&__pyx_n_s_elem, __pyx_k_elem, sizeof(__pyx_k_elem), 0, 0, 1, 1}, + {&__pyx_n_u_elem_has_bin_io, __pyx_k_elem_has_bin_io, sizeof(__pyx_k_elem_has_bin_io), 0, 1, 0, 1}, + {&__pyx_n_u_elemdelim, __pyx_k_elemdelim, sizeof(__pyx_k_elemdelim), 0, 1, 0, 1}, + {&__pyx_n_s_elems, __pyx_k_elems, sizeof(__pyx_k_elems), 0, 0, 1, 1}, + {&__pyx_n_u_elemtype, __pyx_k_elemtype, sizeof(__pyx_k_elemtype), 0, 1, 0, 1}, + {&__pyx_n_s_empty, __pyx_k_empty, sizeof(__pyx_k_empty), 0, 0, 1, 1}, + {&__pyx_kp_u_empty_first_buffer, __pyx_k_empty_first_buffer, sizeof(__pyx_k_empty_first_buffer), 0, 1, 0, 0}, + {&__pyx_n_s_encode, __pyx_k_encode, sizeof(__pyx_k_encode), 0, 0, 1, 1}, + {&__pyx_n_s_encoder, __pyx_k_encoder, sizeof(__pyx_k_encoder), 0, 0, 1, 1}, + {&__pyx_kp_u_end_message_buffer_is_too_small, __pyx_k_end_message_buffer_is_too_small, sizeof(__pyx_k_end_message_buffer_is_too_small), 0, 1, 0, 0}, + {&__pyx_kp_u_end_message_can_only_be_called_w, __pyx_k_end_message_can_only_be_called_w, sizeof(__pyx_k_end_message_can_only_be_called_w), 0, 1, 0, 0}, + {&__pyx_kp_u_end_message_message_is_too_large, __pyx_k_end_message_message_is_too_large, sizeof(__pyx_k_end_message_message_is_too_large), 0, 1, 0, 0}, + {&__pyx_n_s_enumerate, __pyx_k_enumerate, sizeof(__pyx_k_enumerate), 0, 0, 1, 1}, + {&__pyx_n_u_euc_cn, __pyx_k_euc_cn, sizeof(__pyx_k_euc_cn), 0, 1, 0, 1}, + {&__pyx_n_u_euc_jis_2004, __pyx_k_euc_jis_2004, sizeof(__pyx_k_euc_jis_2004), 0, 1, 0, 1}, + {&__pyx_n_u_euc_jp, __pyx_k_euc_jp, sizeof(__pyx_k_euc_jp), 0, 1, 0, 1}, + {&__pyx_n_u_euc_kr, __pyx_k_euc_kr, sizeof(__pyx_k_euc_kr), 0, 1, 0, 1}, + {&__pyx_n_u_euccn, __pyx_k_euccn, sizeof(__pyx_k_euccn), 0, 1, 0, 1}, + {&__pyx_n_u_eucjp, __pyx_k_eucjp, sizeof(__pyx_k_eucjp), 0, 1, 0, 1}, + {&__pyx_n_u_euckr, __pyx_k_euckr, sizeof(__pyx_k_euckr), 0, 1, 0, 1}, + {&__pyx_n_u_event_trigger, __pyx_k_event_trigger, sizeof(__pyx_k_event_trigger), 0, 1, 0, 1}, + {&__pyx_n_s_exceptions, __pyx_k_exceptions, sizeof(__pyx_k_exceptions), 0, 0, 1, 1}, + {&__pyx_n_s_execute, __pyx_k_execute, sizeof(__pyx_k_execute), 0, 0, 1, 1}, + {&__pyx_kp_u_expected_0_1_or_2_elements_in_ra, __pyx_k_expected_0_1_or_2_elements_in_ra, sizeof(__pyx_k_expected_0_1_or_2_elements_in_ra), 0, 1, 0, 0}, + {&__pyx_n_s_extend, __pyx_k_extend, sizeof(__pyx_k_extend), 0, 0, 1, 1}, + {&__pyx_kp_u_failed_to_read_one_byte_on_a_non, __pyx_k_failed_to_read_one_byte_on_a_non, sizeof(__pyx_k_failed_to_read_one_byte_on_a_non), 0, 1, 0, 0}, + {&__pyx_n_s_family, __pyx_k_family, sizeof(__pyx_k_family), 0, 0, 1, 1}, + {&__pyx_n_u_fdw_handler, __pyx_k_fdw_handler, sizeof(__pyx_k_fdw_handler), 0, 1, 0, 1}, + {&__pyx_kp_u_feed_data_bytes_object_expected, __pyx_k_feed_data_bytes_object_expected, sizeof(__pyx_k_feed_data_bytes_object_expected), 0, 1, 0, 0}, + {&__pyx_n_s_find, __pyx_k_find, sizeof(__pyx_k_find), 0, 0, 1, 1}, + {&__pyx_n_u_float4, __pyx_k_float4, sizeof(__pyx_k_float4), 0, 1, 0, 1}, + {&__pyx_n_u_float8, __pyx_k_float8, sizeof(__pyx_k_float8), 0, 1, 0, 1}, + {&__pyx_kp_u_float_value_too_large_to_be_enco, __pyx_k_float_value_too_large_to_be_enco, sizeof(__pyx_k_float_value_too_large_to_be_enco), 0, 1, 0, 0}, + {&__pyx_n_s_format, __pyx_k_format, sizeof(__pyx_k_format), 0, 0, 1, 1}, + {&__pyx_n_s_frombytes, __pyx_k_frombytes, sizeof(__pyx_k_frombytes), 0, 0, 1, 1}, + {&__pyx_n_s_fromordinal, __pyx_k_fromordinal, sizeof(__pyx_k_fromordinal), 0, 0, 1, 1}, + {&__pyx_n_s_genexpr, __pyx_k_genexpr, sizeof(__pyx_k_genexpr), 0, 0, 1, 1}, + {&__pyx_n_s_get, __pyx_k_get, sizeof(__pyx_k_get), 0, 0, 1, 1}, + {&__pyx_n_s_get_extra_info, __pyx_k_get_extra_info, sizeof(__pyx_k_get_extra_info), 0, 0, 1, 1}, + {&__pyx_n_s_getattr, __pyx_k_getattr, sizeof(__pyx_k_getattr), 0, 0, 1, 1}, + {&__pyx_kp_u_got_result_for_unknown_protocol, __pyx_k_got_result_for_unknown_protocol, sizeof(__pyx_k_got_result_for_unknown_protocol), 0, 1, 0, 0}, + {&__pyx_n_u_gtsvector, __pyx_k_gtsvector, sizeof(__pyx_k_gtsvector), 0, 1, 0, 1}, + {&__pyx_n_u_has_bin_io, __pyx_k_has_bin_io, sizeof(__pyx_k_has_bin_io), 0, 1, 0, 1}, + {&__pyx_n_s_hashlib, __pyx_k_hashlib, sizeof(__pyx_k_hashlib), 0, 0, 1, 1}, + {&__pyx_n_s_hashlib_md5, __pyx_k_hashlib_md5, sizeof(__pyx_k_hashlib_md5), 0, 0, 1, 1}, + {&__pyx_n_s_hexdigest, __pyx_k_hexdigest, sizeof(__pyx_k_hexdigest), 0, 0, 1, 1}, + {&__pyx_kp_s_home_travis_build_MagicStack_as, __pyx_k_home_travis_build_MagicStack_as, sizeof(__pyx_k_home_travis_build_MagicStack_as), 0, 0, 1, 0}, + {&__pyx_n_s_hour, __pyx_k_hour, sizeof(__pyx_k_hour), 0, 0, 1, 1}, + {&__pyx_kp_u_hstore_value_is_too_large, __pyx_k_hstore_value_is_too_large, sizeof(__pyx_k_hstore_value_is_too_large), 0, 1, 0, 0}, + {&__pyx_n_s_i, __pyx_k_i, sizeof(__pyx_k_i), 0, 0, 1, 1}, + {&__pyx_n_s_import, __pyx_k_import, sizeof(__pyx_k_import), 0, 0, 1, 1}, + {&__pyx_kp_u_inconsistent_sub_array_dimension, __pyx_k_inconsistent_sub_array_dimension, sizeof(__pyx_k_inconsistent_sub_array_dimension), 0, 1, 0, 0}, + {&__pyx_n_u_inet, __pyx_k_inet, sizeof(__pyx_k_inet), 0, 1, 0, 1}, + {&__pyx_n_s_infinity_date, __pyx_k_infinity_date, sizeof(__pyx_k_infinity_date), 0, 0, 1, 1}, + {&__pyx_n_s_infinity_datetime, __pyx_k_infinity_datetime, sizeof(__pyx_k_infinity_datetime), 0, 0, 1, 1}, + {&__pyx_n_s_init, __pyx_k_init, sizeof(__pyx_k_init), 0, 0, 1, 1}, + {&__pyx_n_s_inspect, __pyx_k_inspect, sizeof(__pyx_k_inspect), 0, 0, 1, 1}, + {&__pyx_kp_u_insufficient_data_in_buffer_requ, __pyx_k_insufficient_data_in_buffer_requ, sizeof(__pyx_k_insufficient_data_in_buffer_requ), 0, 1, 0, 0}, + {&__pyx_n_u_int2, __pyx_k_int2, sizeof(__pyx_k_int2), 0, 1, 0, 1}, + {&__pyx_n_u_int4, __pyx_k_int4, sizeof(__pyx_k_int4), 0, 1, 0, 1}, + {&__pyx_n_u_int8, __pyx_k_int8, sizeof(__pyx_k_int8), 0, 1, 0, 1}, + {&__pyx_kp_u_integer_too_large_to_be_encoded, __pyx_k_integer_too_large_to_be_encoded, sizeof(__pyx_k_integer_too_large_to_be_encoded), 0, 1, 0, 0}, + {&__pyx_n_u_internal, __pyx_k_internal, sizeof(__pyx_k_internal), 0, 1, 0, 1}, + {&__pyx_n_u_interval, __pyx_k_interval, sizeof(__pyx_k_interval), 0, 1, 0, 1}, + {&__pyx_kp_u_invalid_address_family_in_value, __pyx_k_invalid_address_family_in_value, sizeof(__pyx_k_invalid_address_family_in_value), 0, 1, 0, 0}, + {&__pyx_kp_u_invalid_array_element, __pyx_k_invalid_array_element, sizeof(__pyx_k_invalid_array_element), 0, 1, 0, 0}, + {&__pyx_kp_u_invalid_array_element_at_index, __pyx_k_invalid_array_element_at_index, sizeof(__pyx_k_invalid_array_element_at_index), 0, 1, 0, 0}, + {&__pyx_kp_u_invalid_bits_in_value, __pyx_k_invalid_bits_in_value, sizeof(__pyx_k_invalid_bits_in_value), 0, 1, 0, 0}, + {&__pyx_kp_u_invalid_length_in_value, __pyx_k_invalid_length_in_value, sizeof(__pyx_k_invalid_length_in_value), 0, 1, 0, 0}, + {&__pyx_kp_u_invalid_number_of_elements_in_tx, __pyx_k_invalid_number_of_elements_in_tx, sizeof(__pyx_k_invalid_number_of_elements_in_tx), 0, 1, 0, 0}, + {&__pyx_kp_u_invalid_rows_codecs, __pyx_k_invalid_rows_codecs, sizeof(__pyx_k_invalid_rows_codecs), 0, 1, 0, 0}, + {&__pyx_kp_u_invalid_state_after_cancellation, __pyx_k_invalid_state_after_cancellation, sizeof(__pyx_k_invalid_state_after_cancellation), 0, 1, 0, 0}, + {&__pyx_n_s_ip_address, __pyx_k_ip_address, sizeof(__pyx_k_ip_address), 0, 0, 1, 1}, + {&__pyx_n_s_ip_network, __pyx_k_ip_network, sizeof(__pyx_k_ip_network), 0, 0, 1, 1}, + {&__pyx_n_s_ipaddr, __pyx_k_ipaddr, sizeof(__pyx_k_ipaddr), 0, 0, 1, 1}, + {&__pyx_n_s_ipaddress, __pyx_k_ipaddress, sizeof(__pyx_k_ipaddress), 0, 0, 1, 1}, + {&__pyx_n_s_ipnet, __pyx_k_ipnet, sizeof(__pyx_k_ipnet), 0, 0, 1, 1}, + {&__pyx_n_s_is_closed, __pyx_k_is_closed, sizeof(__pyx_k_is_closed), 0, 0, 1, 1}, + {&__pyx_n_s_isempty, __pyx_k_isempty, sizeof(__pyx_k_isempty), 0, 0, 1, 1}, + {&__pyx_n_s_items, __pyx_k_items, sizeof(__pyx_k_items), 0, 0, 1, 1}, + {&__pyx_n_u_items, __pyx_k_items, sizeof(__pyx_k_items), 0, 1, 0, 1}, + {&__pyx_n_u_json, __pyx_k_json, sizeof(__pyx_k_json), 0, 1, 0, 1}, + {&__pyx_n_u_jsonb, __pyx_k_jsonb, sizeof(__pyx_k_jsonb), 0, 1, 0, 1}, + {&__pyx_n_u_kind, __pyx_k_kind, sizeof(__pyx_k_kind), 0, 1, 0, 1}, + {&__pyx_n_u_koi8_r, __pyx_k_koi8_r, sizeof(__pyx_k_koi8_r), 0, 1, 0, 1}, + {&__pyx_n_u_koi8_u, __pyx_k_koi8_u, sizeof(__pyx_k_koi8_u), 0, 1, 0, 1}, + {&__pyx_n_u_koi8r, __pyx_k_koi8r, sizeof(__pyx_k_koi8r), 0, 1, 0, 1}, + {&__pyx_n_u_koi8u, __pyx_k_koi8u, sizeof(__pyx_k_koi8u), 0, 1, 0, 1}, + {&__pyx_n_u_language_handler, __pyx_k_language_handler, sizeof(__pyx_k_language_handler), 0, 1, 0, 1}, + {&__pyx_n_s_len, __pyx_k_len, sizeof(__pyx_k_len), 0, 0, 1, 1}, + {&__pyx_n_s_limit, __pyx_k_limit, sizeof(__pyx_k_limit), 0, 0, 1, 1}, + {&__pyx_n_u_line, __pyx_k_line, sizeof(__pyx_k_line), 0, 1, 0, 1}, + {&__pyx_kp_u_list_or_tuple_expected_got_type, __pyx_k_list_or_tuple_expected_got_type, sizeof(__pyx_k_list_or_tuple_expected_got_type), 0, 1, 0, 0}, + {&__pyx_kp_u_list_tuple_or_Range_object_expec, __pyx_k_list_tuple_or_Range_object_expec, sizeof(__pyx_k_list_tuple_or_Range_object_expec), 0, 1, 0, 0}, + {&__pyx_n_s_lookup, __pyx_k_lookup, sizeof(__pyx_k_lookup), 0, 0, 1, 1}, + {&__pyx_n_s_loop, __pyx_k_loop, sizeof(__pyx_k_loop), 0, 0, 1, 1}, + {&__pyx_n_s_loop_2, __pyx_k_loop_2, sizeof(__pyx_k_loop_2), 0, 0, 1, 1}, + {&__pyx_n_s_lower, __pyx_k_lower, sizeof(__pyx_k_lower), 0, 0, 1, 1}, + {&__pyx_n_s_lower_inc, __pyx_k_lower_inc, sizeof(__pyx_k_lower_inc), 0, 0, 1, 1}, + {&__pyx_n_u_lseg, __pyx_k_lseg, sizeof(__pyx_k_lseg), 0, 1, 0, 1}, + {&__pyx_n_u_macaddr, __pyx_k_macaddr, sizeof(__pyx_k_macaddr), 0, 1, 0, 1}, + {&__pyx_n_s_main, __pyx_k_main, sizeof(__pyx_k_main), 0, 0, 1, 1}, + {&__pyx_kp_u_malformed_array_literal_r, __pyx_k_malformed_array_literal_r, sizeof(__pyx_k_malformed_array_literal_r), 0, 1, 0, 0}, + {&__pyx_n_s_mapping, __pyx_k_mapping, sizeof(__pyx_k_mapping), 0, 0, 1, 1}, + {&__pyx_n_b_md5, __pyx_k_md5, sizeof(__pyx_k_md5), 0, 0, 0, 1}, + {&__pyx_n_s_md5, __pyx_k_md5, sizeof(__pyx_k_md5), 0, 0, 1, 1}, + {&__pyx_n_s_memoryview, __pyx_k_memoryview, sizeof(__pyx_k_memoryview), 0, 0, 1, 1}, + {&__pyx_n_s_metaclass, __pyx_k_metaclass, sizeof(__pyx_k_metaclass), 0, 0, 1, 1}, + {&__pyx_n_s_microsecond, __pyx_k_microsecond, sizeof(__pyx_k_microsecond), 0, 0, 1, 1}, + {&__pyx_n_s_microseconds, __pyx_k_microseconds, sizeof(__pyx_k_microseconds), 0, 0, 1, 1}, + {&__pyx_n_s_minute, __pyx_k_minute, sizeof(__pyx_k_minute), 0, 0, 1, 1}, + {&__pyx_n_s_minutes, __pyx_k_minutes, sizeof(__pyx_k_minutes), 0, 0, 1, 1}, + {&__pyx_kp_u_missing_after_array_dimensions, __pyx_k_missing_after_array_dimensions, sizeof(__pyx_k_missing_after_array_dimensions), 0, 1, 0, 0}, + {&__pyx_kp_u_missing_after_array_dimensions_2, __pyx_k_missing_after_array_dimensions_2, sizeof(__pyx_k_missing_after_array_dimensions_2), 0, 1, 0, 0}, + {&__pyx_kp_u_missing_array_dimension_value, __pyx_k_missing_array_dimension_value, sizeof(__pyx_k_missing_array_dimension_value), 0, 1, 0, 0}, + {&__pyx_n_s_module, __pyx_k_module, sizeof(__pyx_k_module), 0, 0, 1, 1}, + {&__pyx_n_u_money, __pyx_k_money, sizeof(__pyx_k_money), 0, 1, 0, 1}, + {&__pyx_n_s_name, __pyx_k_name, sizeof(__pyx_k_name), 0, 0, 1, 1}, + {&__pyx_n_u_name, __pyx_k_name, sizeof(__pyx_k_name), 0, 1, 0, 1}, + {&__pyx_n_s_name_2, __pyx_k_name_2, sizeof(__pyx_k_name_2), 0, 0, 1, 1}, + {&__pyx_n_s_negative_infinity_date, __pyx_k_negative_infinity_date, sizeof(__pyx_k_negative_infinity_date), 0, 0, 1, 1}, + {&__pyx_n_s_negative_infinity_datetime, __pyx_k_negative_infinity_datetime, sizeof(__pyx_k_negative_infinity_datetime), 0, 0, 1, 1}, + {&__pyx_n_s_network_address, __pyx_k_network_address, sizeof(__pyx_k_network_address), 0, 0, 1, 1}, + {&__pyx_n_s_new, __pyx_k_new, sizeof(__pyx_k_new), 0, 0, 1, 1}, + {&__pyx_n_s_new_prefix, __pyx_k_new_prefix, sizeof(__pyx_k_new_prefix), 0, 0, 1, 1}, + {&__pyx_kp_u_no_codec_for_array_element_type, __pyx_k_no_codec_for_array_element_type, sizeof(__pyx_k_no_codec_for_array_element_type), 0, 1, 0, 0}, + {&__pyx_kp_u_no_codec_for_composite_attribute, __pyx_k_no_codec_for_composite_attribute, sizeof(__pyx_k_no_codec_for_composite_attribute), 0, 1, 0, 0}, + {&__pyx_kp_u_no_codec_for_domain_base_type, __pyx_k_no_codec_for_domain_base_type, sizeof(__pyx_k_no_codec_for_domain_base_type), 0, 1, 0, 0}, + {&__pyx_kp_u_no_codec_for_range_element_type, __pyx_k_no_codec_for_range_element_type, sizeof(__pyx_k_no_codec_for_range_element_type), 0, 1, 0, 0}, + {&__pyx_kp_u_no_decoder_for_OID, __pyx_k_no_decoder_for_OID, sizeof(__pyx_k_no_decoder_for_OID), 0, 1, 0, 0}, + {&__pyx_kp_u_no_decoder_for_composite_type_el, __pyx_k_no_decoder_for_composite_type_el, sizeof(__pyx_k_no_decoder_for_composite_type_el), 0, 1, 0, 0}, + {&__pyx_kp_u_no_decoder_for_type_OID, __pyx_k_no_decoder_for_type_OID, sizeof(__pyx_k_no_decoder_for_type_OID), 0, 1, 0, 0}, + {&__pyx_kp_u_no_encoder_for_OID, __pyx_k_no_encoder_for_OID, sizeof(__pyx_k_no_encoder_for_OID), 0, 1, 0, 0}, + {&__pyx_kp_u_no_message_to_consume, __pyx_k_no_message_to_consume, sizeof(__pyx_k_no_message_to_consume), 0, 1, 0, 0}, + {&__pyx_kp_u_no_message_to_discard, __pyx_k_no_message_to_discard, sizeof(__pyx_k_no_message_to_discard), 0, 1, 0, 0}, + {&__pyx_kp_u_non_homogeneous_array, __pyx_k_non_homogeneous_array, sizeof(__pyx_k_non_homogeneous_array), 0, 1, 0, 0}, + {&__pyx_kp_u_not_connected, __pyx_k_not_connected, sizeof(__pyx_k_not_connected), 0, 1, 0, 0}, + {&__pyx_kp_u_not_enough_data_to_read_bytes, __pyx_k_not_enough_data_to_read_bytes, sizeof(__pyx_k_not_enough_data_to_read_bytes), 0, 1, 0, 0}, + {&__pyx_kp_u_not_enough_data_to_read_one_byte, __pyx_k_not_enough_data_to_read_one_byte, sizeof(__pyx_k_not_enough_data_to_read_one_byte), 0, 1, 0, 0}, + {&__pyx_n_s_notify, __pyx_k_notify, sizeof(__pyx_k_notify), 0, 0, 1, 1}, + {&__pyx_n_u_ns, __pyx_k_ns, sizeof(__pyx_k_ns), 0, 1, 0, 1}, + {&__pyx_kp_u_null_value_not_allowed_in_hstore, __pyx_k_null_value_not_allowed_in_hstore, sizeof(__pyx_k_null_value_not_allowed_in_hstore), 0, 1, 0, 0}, + {&__pyx_kp_u_number_of_arguments_does_not_mat, __pyx_k_number_of_arguments_does_not_mat, sizeof(__pyx_k_number_of_arguments_does_not_mat), 0, 1, 0, 0}, + {&__pyx_kp_u_number_of_array_dimensions_excee, __pyx_k_number_of_array_dimensions_excee, sizeof(__pyx_k_number_of_array_dimensions_excee), 0, 1, 0, 0}, + {&__pyx_kp_u_number_of_columns_in_result_is_d, __pyx_k_number_of_columns_in_result_is_d, sizeof(__pyx_k_number_of_columns_in_result_is_d), 0, 1, 0, 0}, + {&__pyx_n_u_numeric, __pyx_k_numeric, sizeof(__pyx_k_numeric), 0, 1, 0, 1}, + {&__pyx_n_s_object, __pyx_k_object, sizeof(__pyx_k_object), 0, 0, 1, 1}, + {&__pyx_n_s_oid, __pyx_k_oid, sizeof(__pyx_k_oid), 0, 0, 1, 1}, + {&__pyx_n_u_oid, __pyx_k_oid, sizeof(__pyx_k_oid), 0, 1, 0, 1}, + {&__pyx_kp_u_oid_2, __pyx_k_oid_2, sizeof(__pyx_k_oid_2), 0, 1, 0, 0}, + {&__pyx_n_s_on_error, __pyx_k_on_error, sizeof(__pyx_k_on_error), 0, 0, 1, 1}, + {&__pyx_kp_u_on_result__prepare_statement_is, __pyx_k_on_result__prepare_statement_is, sizeof(__pyx_k_on_result__prepare_statement_is), 0, 1, 0, 0}, + {&__pyx_kp_u_on_result_waiter_is_None, __pyx_k_on_result_waiter_is_None, sizeof(__pyx_k_on_result_waiter_is_None), 0, 1, 0, 0}, + {&__pyx_kp_u_on_result_waiter_is_done, __pyx_k_on_result_waiter_is_done, sizeof(__pyx_k_on_result_waiter_is_done), 0, 1, 0, 0}, + {&__pyx_n_s_on_timeout, __pyx_k_on_timeout, sizeof(__pyx_k_on_timeout), 0, 0, 1, 1}, + {&__pyx_n_s_on_waiter_completed, __pyx_k_on_waiter_completed, sizeof(__pyx_k_on_waiter_completed), 0, 0, 1, 1}, + {&__pyx_n_u_opaque, __pyx_k_opaque, sizeof(__pyx_k_opaque), 0, 1, 0, 1}, + {&__pyx_n_s_packed, __pyx_k_packed, sizeof(__pyx_k_packed), 0, 0, 1, 1}, + {&__pyx_kp_u_parse_data_msgs_first_message_i, __pyx_k_parse_data_msgs_first_message_i, sizeof(__pyx_k_parse_data_msgs_first_message_i), 0, 1, 0, 0}, + {&__pyx_kp_u_parse_data_msgs_result_is_not_a, __pyx_k_parse_data_msgs_result_is_not_a, sizeof(__pyx_k_parse_data_msgs_result_is_not_a), 0, 1, 0, 0}, + {&__pyx_n_s_password, __pyx_k_password, sizeof(__pyx_k_password), 0, 0, 1, 1}, + {&__pyx_n_u_password, __pyx_k_password, sizeof(__pyx_k_password), 0, 1, 0, 1}, + {&__pyx_n_u_path, __pyx_k_path, sizeof(__pyx_k_path), 0, 1, 0, 1}, + {&__pyx_kp_u_path_value_too_long, __pyx_k_path_value_too_long, sizeof(__pyx_k_path_value_too_long), 0, 1, 0, 0}, + {&__pyx_n_u_pg_catalog, __pyx_k_pg_catalog, sizeof(__pyx_k_pg_catalog), 0, 1, 0, 1}, + {&__pyx_kp_u_pg_contrib_hstore, __pyx_k_pg_contrib_hstore, sizeof(__pyx_k_pg_contrib_hstore), 0, 1, 0, 0}, + {&__pyx_n_u_pg_ddl_command, __pyx_k_pg_ddl_command, sizeof(__pyx_k_pg_ddl_command), 0, 1, 0, 1}, + {&__pyx_n_s_pg_epoch_date, __pyx_k_pg_epoch_date, sizeof(__pyx_k_pg_epoch_date), 0, 0, 1, 1}, + {&__pyx_n_s_pg_epoch_datetime, __pyx_k_pg_epoch_datetime, sizeof(__pyx_k_pg_epoch_datetime), 0, 0, 1, 1}, + {&__pyx_n_s_pg_epoch_datetime_utc, __pyx_k_pg_epoch_datetime_utc, sizeof(__pyx_k_pg_epoch_datetime_utc), 0, 0, 1, 1}, + {&__pyx_n_u_pg_lsn, __pyx_k_pg_lsn, sizeof(__pyx_k_pg_lsn), 0, 1, 0, 1}, + {&__pyx_n_u_pg_node_tree, __pyx_k_pg_node_tree, sizeof(__pyx_k_pg_node_tree), 0, 1, 0, 1}, + {&__pyx_n_u_point, __pyx_k_point, sizeof(__pyx_k_point), 0, 1, 0, 1}, + {&__pyx_n_u_polygon, __pyx_k_polygon, sizeof(__pyx_k_polygon), 0, 1, 0, 1}, + {&__pyx_kp_u_polygon_value_too_long, __pyx_k_polygon_value_too_long, sizeof(__pyx_k_polygon_value_too_long), 0, 1, 0, 0}, + {&__pyx_n_s_popleft, __pyx_k_popleft, sizeof(__pyx_k_popleft), 0, 0, 1, 1}, + {&__pyx_n_s_portal_name, __pyx_k_portal_name, sizeof(__pyx_k_portal_name), 0, 0, 1, 1}, + {&__pyx_n_s_prefixlen, __pyx_k_prefixlen, sizeof(__pyx_k_prefixlen), 0, 0, 1, 1}, + {&__pyx_n_s_prepare, __pyx_k_prepare, sizeof(__pyx_k_prepare), 0, 0, 1, 1}, + {&__pyx_n_s_prepare_2, __pyx_k_prepare_2, sizeof(__pyx_k_prepare_2), 0, 0, 1, 1}, + {&__pyx_n_s_print, __pyx_k_print, sizeof(__pyx_k_print), 0, 0, 1, 1}, + {&__pyx_n_s_protocol, __pyx_k_protocol, sizeof(__pyx_k_protocol), 0, 0, 1, 1}, + {&__pyx_kp_u_protocol_is_already_in_the_idle, __pyx_k_protocol_is_already_in_the_idle, sizeof(__pyx_k_protocol_is_already_in_the_idle), 0, 1, 0, 0}, + {&__pyx_kp_u_protocol_is_in_an_unknown_state, __pyx_k_protocol_is_in_an_unknown_state, sizeof(__pyx_k_protocol_is_in_an_unknown_state), 0, 1, 0, 0}, + {&__pyx_n_s_pyx_capi, __pyx_k_pyx_capi, sizeof(__pyx_k_pyx_capi), 0, 0, 1, 1}, + {&__pyx_n_s_pyx_vtable, __pyx_k_pyx_vtable, sizeof(__pyx_k_pyx_vtable), 0, 0, 1, 1}, + {&__pyx_n_s_qualname, __pyx_k_qualname, sizeof(__pyx_k_qualname), 0, 0, 1, 1}, + {&__pyx_n_s_query, __pyx_k_query, sizeof(__pyx_k_query), 0, 0, 1, 1}, + {&__pyx_n_b_r, __pyx_k_r, sizeof(__pyx_k_r), 0, 0, 0, 1}, + {&__pyx_n_s_range, __pyx_k_range, sizeof(__pyx_k_range), 0, 0, 1, 1}, + {&__pyx_n_u_range, __pyx_k_range, sizeof(__pyx_k_range), 0, 1, 0, 1}, + {&__pyx_n_u_range_subtype, __pyx_k_range_subtype, sizeof(__pyx_k_range_subtype), 0, 1, 0, 1}, + {&__pyx_kp_u_read_cstr_buffer_overread, __pyx_k_read_cstr_buffer_overread, sizeof(__pyx_k_read_cstr_buffer_overread), 0, 1, 0, 0}, + {&__pyx_kp_u_read_cstr_only_works_when_the_me, __pyx_k_read_cstr_only_works_when_the_me, sizeof(__pyx_k_read_cstr_only_works_when_the_me), 0, 1, 0, 0}, + {&__pyx_n_s_rec, __pyx_k_rec, sizeof(__pyx_k_rec), 0, 0, 1, 1}, + {&__pyx_n_u_record, __pyx_k_record, sizeof(__pyx_k_record), 0, 1, 0, 1}, + {&__pyx_n_u_refcursor, __pyx_k_refcursor, sizeof(__pyx_k_refcursor), 0, 1, 0, 1}, + {&__pyx_n_u_regclass, __pyx_k_regclass, sizeof(__pyx_k_regclass), 0, 1, 0, 1}, + {&__pyx_n_u_regconfig, __pyx_k_regconfig, sizeof(__pyx_k_regconfig), 0, 1, 0, 1}, + {&__pyx_n_u_regdictionary, __pyx_k_regdictionary, sizeof(__pyx_k_regdictionary), 0, 1, 0, 1}, + {&__pyx_n_u_regnamespace, __pyx_k_regnamespace, sizeof(__pyx_k_regnamespace), 0, 1, 0, 1}, + {&__pyx_n_u_regoper, __pyx_k_regoper, sizeof(__pyx_k_regoper), 0, 1, 0, 1}, + {&__pyx_n_u_regoperator, __pyx_k_regoperator, sizeof(__pyx_k_regoperator), 0, 1, 0, 1}, + {&__pyx_n_u_regproc, __pyx_k_regproc, sizeof(__pyx_k_regproc), 0, 1, 0, 1}, + {&__pyx_n_u_regprocedure, __pyx_k_regprocedure, sizeof(__pyx_k_regprocedure), 0, 1, 0, 1}, + {&__pyx_n_u_regrole, __pyx_k_regrole, sizeof(__pyx_k_regrole), 0, 1, 0, 1}, + {&__pyx_n_u_regtype, __pyx_k_regtype, sizeof(__pyx_k_regtype), 0, 1, 0, 1}, + {&__pyx_n_u_reltime, __pyx_k_reltime, sizeof(__pyx_k_reltime), 0, 1, 0, 1}, + {&__pyx_n_s_replace, __pyx_k_replace, sizeof(__pyx_k_replace), 0, 0, 1, 1}, + {&__pyx_n_s_request_cancel, __pyx_k_request_cancel, sizeof(__pyx_k_request_cancel), 0, 0, 1, 1}, + {&__pyx_n_s_return_extra, __pyx_k_return_extra, sizeof(__pyx_k_return_extra), 0, 0, 1, 1}, + {&__pyx_n_u_scalar, __pyx_k_scalar, sizeof(__pyx_k_scalar), 0, 1, 0, 1}, + {&__pyx_n_s_second, __pyx_k_second, sizeof(__pyx_k_second), 0, 0, 1, 1}, + {&__pyx_n_s_seconds, __pyx_k_seconds, sizeof(__pyx_k_seconds), 0, 0, 1, 1}, + {&__pyx_n_s_send, __pyx_k_send, sizeof(__pyx_k_send), 0, 0, 1, 1}, + {&__pyx_n_s_set_builtin_type_codec, __pyx_k_set_builtin_type_codec, sizeof(__pyx_k_set_builtin_type_codec), 0, 0, 1, 1}, + {&__pyx_n_s_set_exception, __pyx_k_set_exception, sizeof(__pyx_k_set_exception), 0, 0, 1, 1}, + {&__pyx_n_s_set_result, __pyx_k_set_result, sizeof(__pyx_k_set_result), 0, 0, 1, 1}, + {&__pyx_n_s_setsockopt, __pyx_k_setsockopt, sizeof(__pyx_k_setsockopt), 0, 0, 1, 1}, + {&__pyx_n_u_shift_jis, __pyx_k_shift_jis, sizeof(__pyx_k_shift_jis), 0, 1, 0, 1}, + {&__pyx_n_u_shift_jis_2004, __pyx_k_shift_jis_2004, sizeof(__pyx_k_shift_jis_2004), 0, 1, 0, 1}, + {&__pyx_n_u_sjis, __pyx_k_sjis, sizeof(__pyx_k_sjis), 0, 1, 0, 1}, + {&__pyx_n_u_smgr, __pyx_k_smgr, sizeof(__pyx_k_smgr), 0, 1, 0, 1}, + {&__pyx_n_s_socket, __pyx_k_socket, sizeof(__pyx_k_socket), 0, 0, 1, 1}, + {&__pyx_n_u_socket, __pyx_k_socket, sizeof(__pyx_k_socket), 0, 1, 0, 1}, + {&__pyx_kp_u_specified_array_dimensions_do_no, __pyx_k_specified_array_dimensions_do_no, sizeof(__pyx_k_specified_array_dimensions_do_no), 0, 1, 0, 0}, + {&__pyx_n_u_sql_ascii, __pyx_k_sql_ascii, sizeof(__pyx_k_sql_ascii), 0, 1, 0, 1}, + {&__pyx_n_s_startswith, __pyx_k_startswith, sizeof(__pyx_k_startswith), 0, 0, 1, 1}, + {&__pyx_n_s_state, __pyx_k_state, sizeof(__pyx_k_state), 0, 0, 1, 1}, + {&__pyx_kp_u_stmt, __pyx_k_stmt, sizeof(__pyx_k_stmt), 0, 1, 0, 0}, + {&__pyx_n_s_stmt_name, __pyx_k_stmt_name, sizeof(__pyx_k_stmt_name), 0, 0, 1, 1}, + {&__pyx_kp_u_string_too_long, __pyx_k_string_too_long, sizeof(__pyx_k_string_too_long), 0, 1, 0, 0}, + {&__pyx_n_s_supernet, __pyx_k_supernet, sizeof(__pyx_k_supernet), 0, 0, 1, 1}, + {&__pyx_n_u_tcvn, __pyx_k_tcvn, sizeof(__pyx_k_tcvn), 0, 1, 0, 1}, + {&__pyx_n_u_tcvn5712, __pyx_k_tcvn5712, sizeof(__pyx_k_tcvn5712), 0, 1, 0, 1}, + {&__pyx_n_s_test, __pyx_k_test, sizeof(__pyx_k_test), 0, 0, 1, 1}, + {&__pyx_n_u_text, __pyx_k_text, sizeof(__pyx_k_text), 0, 1, 0, 1}, + {&__pyx_kp_u_text_2, __pyx_k_text_2, sizeof(__pyx_k_text_2), 0, 1, 0, 0}, + {&__pyx_kp_u_the_buffer_is_in_read_only_mode, __pyx_k_the_buffer_is_in_read_only_mode, sizeof(__pyx_k_the_buffer_is_in_read_only_mode), 0, 1, 0, 0}, + {&__pyx_n_s_throw, __pyx_k_throw, sizeof(__pyx_k_throw), 0, 0, 1, 1}, + {&__pyx_n_u_tid, __pyx_k_tid, sizeof(__pyx_k_tid), 0, 1, 0, 1}, + {&__pyx_n_s_time, __pyx_k_time, sizeof(__pyx_k_time), 0, 0, 1, 1}, + {&__pyx_n_u_time, __pyx_k_time, sizeof(__pyx_k_time), 0, 1, 0, 1}, + {&__pyx_n_s_timedelta, __pyx_k_timedelta, sizeof(__pyx_k_timedelta), 0, 0, 1, 1}, + {&__pyx_n_s_timeout, __pyx_k_timeout, sizeof(__pyx_k_timeout), 0, 0, 1, 1}, + {&__pyx_n_s_timestamp, __pyx_k_timestamp, sizeof(__pyx_k_timestamp), 0, 0, 1, 1}, + {&__pyx_n_u_timestamp, __pyx_k_timestamp, sizeof(__pyx_k_timestamp), 0, 1, 0, 1}, + {&__pyx_n_u_timestamptz, __pyx_k_timestamptz, sizeof(__pyx_k_timestamptz), 0, 1, 0, 1}, + {&__pyx_n_u_timetz, __pyx_k_timetz, sizeof(__pyx_k_timetz), 0, 1, 0, 1}, + {&__pyx_n_s_timezone, __pyx_k_timezone, sizeof(__pyx_k_timezone), 0, 0, 1, 1}, + {&__pyx_n_u_tinterval, __pyx_k_tinterval, sizeof(__pyx_k_tinterval), 0, 1, 0, 1}, + {&__pyx_kp_u_too_many_elements_in_array_value, __pyx_k_too_many_elements_in_array_value, sizeof(__pyx_k_too_many_elements_in_array_value), 0, 1, 0, 0}, + {&__pyx_kp_u_too_many_elements_in_composite_t, __pyx_k_too_many_elements_in_composite_t, sizeof(__pyx_k_too_many_elements_in_composite_t), 0, 1, 0, 0}, + {&__pyx_n_s_toordinal, __pyx_k_toordinal, sizeof(__pyx_k_toordinal), 0, 0, 1, 1}, + {&__pyx_n_u_trigger, __pyx_k_trigger, sizeof(__pyx_k_trigger), 0, 1, 0, 1}, + {&__pyx_n_u_tsm_handler, __pyx_k_tsm_handler, sizeof(__pyx_k_tsm_handler), 0, 1, 0, 1}, + {&__pyx_n_u_tsquery, __pyx_k_tsquery, sizeof(__pyx_k_tsquery), 0, 1, 0, 1}, + {&__pyx_n_u_tsvector, __pyx_k_tsvector, sizeof(__pyx_k_tsvector), 0, 1, 0, 1}, + {&__pyx_n_u_txid_snapshot, __pyx_k_txid_snapshot, sizeof(__pyx_k_txid_snapshot), 0, 1, 0, 1}, + {&__pyx_kp_u_txid_snapshot_value_is_too_long, __pyx_k_txid_snapshot_value_is_too_long, sizeof(__pyx_k_txid_snapshot_value_is_too_long), 0, 1, 0, 0}, + {&__pyx_kp_u_type_record_missing_base_type_fo, __pyx_k_type_record_missing_base_type_fo, sizeof(__pyx_k_type_record_missing_base_type_fo), 0, 1, 0, 0}, + {&__pyx_kp_u_type_record_missing_base_type_fo_2, __pyx_k_type_record_missing_base_type_fo_2, sizeof(__pyx_k_type_record_missing_base_type_fo_2), 0, 1, 0, 0}, + {&__pyx_kp_u_type_record_missing_field_types, __pyx_k_type_record_missing_field_types, sizeof(__pyx_k_type_record_missing_field_types), 0, 1, 0, 0}, + {&__pyx_n_s_typekind, __pyx_k_typekind, sizeof(__pyx_k_typekind), 0, 0, 1, 1}, + {&__pyx_n_s_typename, __pyx_k_typename, sizeof(__pyx_k_typename), 0, 0, 1, 1}, + {&__pyx_n_s_typeoid, __pyx_k_typeoid, sizeof(__pyx_k_typeoid), 0, 0, 1, 1}, + {&__pyx_n_s_types, __pyx_k_types, sizeof(__pyx_k_types), 0, 0, 1, 1}, + {&__pyx_n_s_typeschema, __pyx_k_typeschema, sizeof(__pyx_k_typeschema), 0, 0, 1, 1}, + {&__pyx_n_s_tzinfo, __pyx_k_tzinfo, sizeof(__pyx_k_tzinfo), 0, 0, 1, 1}, + {&__pyx_kp_u_unexpected_JSONB_format, __pyx_k_unexpected_JSONB_format, sizeof(__pyx_k_unexpected_JSONB_format), 0, 1, 0, 0}, + {&__pyx_kp_u_unexpected_character_r_at_positi, __pyx_k_unexpected_character_r_at_positi, sizeof(__pyx_k_unexpected_character_r_at_positi), 0, 1, 0, 0}, + {&__pyx_kp_u_unexpected_codec_type, __pyx_k_unexpected_codec_type, sizeof(__pyx_k_unexpected_codec_type), 0, 1, 0, 0}, + {&__pyx_kp_u_unexpected_data_type_of_composit, __pyx_k_unexpected_data_type_of_composit, sizeof(__pyx_k_unexpected_data_type_of_composit), 0, 1, 0, 0}, + {&__pyx_kp_u_unexpected_end_of_string, __pyx_k_unexpected_end_of_string, sizeof(__pyx_k_unexpected_end_of_string), 0, 1, 0, 0}, + {&__pyx_kp_u_unexpected_trailing_bytes_in_buf, __pyx_k_unexpected_trailing_bytes_in_buf, sizeof(__pyx_k_unexpected_trailing_bytes_in_buf), 0, 1, 0, 0}, + {&__pyx_kp_u_unhandled_standard_data_type_r_O, __pyx_k_unhandled_standard_data_type_r_O, sizeof(__pyx_k_unhandled_standard_data_type_r_O), 0, 1, 0, 0}, + {&__pyx_n_u_unicode, __pyx_k_unicode, sizeof(__pyx_k_unicode), 0, 1, 0, 1}, + {&__pyx_n_u_unknown, __pyx_k_unknown, sizeof(__pyx_k_unknown), 0, 1, 0, 1}, + {&__pyx_kp_u_unknown_alias_target, __pyx_k_unknown_alias_target, sizeof(__pyx_k_unknown_alias_target), 0, 1, 0, 0}, + {&__pyx_kp_u_unknown_error_in_protocol_implem, __pyx_k_unknown_error_in_protocol_implem, sizeof(__pyx_k_unknown_error_in_protocol_implem), 0, 1, 0, 0}, + {&__pyx_kp_u_unsupported_authentication_metho, __pyx_k_unsupported_authentication_metho, sizeof(__pyx_k_unsupported_authentication_metho), 0, 1, 0, 0}, + {&__pyx_kp_u_unsupported_authentication_metho_2, __pyx_k_unsupported_authentication_metho_2, sizeof(__pyx_k_unsupported_authentication_metho_2), 0, 1, 0, 0}, + {&__pyx_n_s_upper, __pyx_k_upper, sizeof(__pyx_k_upper), 0, 0, 1, 1}, + {&__pyx_n_s_upper_inc, __pyx_k_upper_inc, sizeof(__pyx_k_upper_inc), 0, 0, 1, 1}, + {&__pyx_n_s_user, __pyx_k_user, sizeof(__pyx_k_user), 0, 0, 1, 1}, + {&__pyx_n_u_user, __pyx_k_user, sizeof(__pyx_k_user), 0, 1, 0, 1}, + {&__pyx_n_s_utc, __pyx_k_utc, sizeof(__pyx_k_utc), 0, 0, 1, 1}, + {&__pyx_n_s_utcoffset, __pyx_k_utcoffset, sizeof(__pyx_k_utcoffset), 0, 0, 1, 1}, + {&__pyx_kp_u_utf_8, __pyx_k_utf_8, sizeof(__pyx_k_utf_8), 0, 1, 0, 0}, + {&__pyx_n_u_utf_8_2, __pyx_k_utf_8_2, sizeof(__pyx_k_utf_8_2), 0, 1, 0, 1}, + {&__pyx_n_s_uuid, __pyx_k_uuid, sizeof(__pyx_k_uuid), 0, 0, 1, 1}, + {&__pyx_n_u_uuid, __pyx_k_uuid, sizeof(__pyx_k_uuid), 0, 1, 0, 1}, + {&__pyx_n_u_varbit, __pyx_k_varbit, sizeof(__pyx_k_varbit), 0, 1, 0, 1}, + {&__pyx_n_u_varchar, __pyx_k_varchar, sizeof(__pyx_k_varchar), 0, 1, 0, 1}, + {&__pyx_n_s_version, __pyx_k_version, sizeof(__pyx_k_version), 0, 0, 1, 1}, + {&__pyx_n_u_void, __pyx_k_void, sizeof(__pyx_k_void), 0, 1, 0, 1}, + {&__pyx_n_u_vscii, __pyx_k_vscii, sizeof(__pyx_k_vscii), 0, 1, 0, 1}, + {&__pyx_n_u_win, __pyx_k_win, sizeof(__pyx_k_win), 0, 1, 0, 1}, + {&__pyx_n_u_win1250, __pyx_k_win1250, sizeof(__pyx_k_win1250), 0, 1, 0, 1}, + {&__pyx_n_u_win1251, __pyx_k_win1251, sizeof(__pyx_k_win1251), 0, 1, 0, 1}, + {&__pyx_n_u_win1252, __pyx_k_win1252, sizeof(__pyx_k_win1252), 0, 1, 0, 1}, + {&__pyx_n_u_win1253, __pyx_k_win1253, sizeof(__pyx_k_win1253), 0, 1, 0, 1}, + {&__pyx_n_u_win1254, __pyx_k_win1254, sizeof(__pyx_k_win1254), 0, 1, 0, 1}, + {&__pyx_n_u_win1255, __pyx_k_win1255, sizeof(__pyx_k_win1255), 0, 1, 0, 1}, + {&__pyx_n_u_win1256, __pyx_k_win1256, sizeof(__pyx_k_win1256), 0, 1, 0, 1}, + {&__pyx_n_u_win1257, __pyx_k_win1257, sizeof(__pyx_k_win1257), 0, 1, 0, 1}, + {&__pyx_n_u_win1258, __pyx_k_win1258, sizeof(__pyx_k_win1258), 0, 1, 0, 1}, + {&__pyx_n_u_win866, __pyx_k_win866, sizeof(__pyx_k_win866), 0, 1, 0, 1}, + {&__pyx_n_u_win874, __pyx_k_win874, sizeof(__pyx_k_win874), 0, 1, 0, 1}, + {&__pyx_n_u_win932, __pyx_k_win932, sizeof(__pyx_k_win932), 0, 1, 0, 1}, + {&__pyx_n_u_win936, __pyx_k_win936, sizeof(__pyx_k_win936), 0, 1, 0, 1}, + {&__pyx_n_u_win949, __pyx_k_win949, sizeof(__pyx_k_win949), 0, 1, 0, 1}, + {&__pyx_n_u_win950, __pyx_k_win950, sizeof(__pyx_k_win950), 0, 1, 0, 1}, + {&__pyx_n_u_windows1250, __pyx_k_windows1250, sizeof(__pyx_k_windows1250), 0, 1, 0, 1}, + {&__pyx_n_u_windows1251, __pyx_k_windows1251, sizeof(__pyx_k_windows1251), 0, 1, 0, 1}, + {&__pyx_n_u_windows1252, __pyx_k_windows1252, sizeof(__pyx_k_windows1252), 0, 1, 0, 1}, + {&__pyx_n_u_windows1253, __pyx_k_windows1253, sizeof(__pyx_k_windows1253), 0, 1, 0, 1}, + {&__pyx_n_u_windows1254, __pyx_k_windows1254, sizeof(__pyx_k_windows1254), 0, 1, 0, 1}, + {&__pyx_n_u_windows1255, __pyx_k_windows1255, sizeof(__pyx_k_windows1255), 0, 1, 0, 1}, + {&__pyx_n_u_windows1256, __pyx_k_windows1256, sizeof(__pyx_k_windows1256), 0, 1, 0, 1}, + {&__pyx_n_u_windows1257, __pyx_k_windows1257, sizeof(__pyx_k_windows1257), 0, 1, 0, 1}, + {&__pyx_n_u_windows1258, __pyx_k_windows1258, sizeof(__pyx_k_windows1258), 0, 1, 0, 1}, + {&__pyx_n_u_windows866, __pyx_k_windows866, sizeof(__pyx_k_windows866), 0, 1, 0, 1}, + {&__pyx_n_u_windows874, __pyx_k_windows874, sizeof(__pyx_k_windows874), 0, 1, 0, 1}, + {&__pyx_n_u_windows932, __pyx_k_windows932, sizeof(__pyx_k_windows932), 0, 1, 0, 1}, + {&__pyx_n_u_windows936, __pyx_k_windows936, sizeof(__pyx_k_windows936), 0, 1, 0, 1}, + {&__pyx_n_u_windows949, __pyx_k_windows949, sizeof(__pyx_k_windows949), 0, 1, 0, 1}, + {&__pyx_n_u_windows950, __pyx_k_windows950, sizeof(__pyx_k_windows950), 0, 1, 0, 1}, + {&__pyx_n_s_write, __pyx_k_write, sizeof(__pyx_k_write), 0, 0, 1, 1}, + {&__pyx_n_u_xid, __pyx_k_xid, sizeof(__pyx_k_xid), 0, 1, 0, 1}, + {&__pyx_n_u_xml, __pyx_k_xml, sizeof(__pyx_k_xml), 0, 1, 0, 1}, + {0, 0, 0, 0, 0, 0, 0} +}; +static int __Pyx_InitCachedBuiltins(void) { + __pyx_builtin_KeyError = __Pyx_GetBuiltinName(__pyx_n_s_KeyError); if (!__pyx_builtin_KeyError) __PYX_ERR(0, 59, __pyx_L1_error) + __pyx_builtin_AttributeError = __Pyx_GetBuiltinName(__pyx_n_s_AttributeError); if (!__pyx_builtin_AttributeError) __PYX_ERR(0, 60, __pyx_L1_error) + __pyx_builtin_object = __Pyx_GetBuiltinName(__pyx_n_s_object); if (!__pyx_builtin_object) __PYX_ERR(0, 62, __pyx_L1_error) + __pyx_builtin_RuntimeError = __Pyx_GetBuiltinName(__pyx_n_s_RuntimeError); if (!__pyx_builtin_RuntimeError) __PYX_ERR(1, 52, __pyx_L1_error) + __pyx_builtin_MemoryError = __Pyx_GetBuiltinName(__pyx_n_s_MemoryError); if (!__pyx_builtin_MemoryError) __PYX_ERR(1, 94, __pyx_L1_error) + __pyx_builtin_chr = __Pyx_GetBuiltinName(__pyx_n_s_chr); if (!__pyx_builtin_chr) __PYX_ERR(1, 543, __pyx_L1_error) + __pyx_builtin_print = __Pyx_GetBuiltinName(__pyx_n_s_print); if (!__pyx_builtin_print) __PYX_ERR(1, 548, __pyx_L1_error) + __pyx_builtin_ValueError = __Pyx_GetBuiltinName(__pyx_n_s_ValueError); if (!__pyx_builtin_ValueError) __PYX_ERR(2, 110, __pyx_L1_error) + __pyx_builtin_range = __Pyx_GetBuiltinName(__pyx_n_s_range); if (!__pyx_builtin_range) __PYX_ERR(2, 167, __pyx_L1_error) + __pyx_builtin_enumerate = __Pyx_GetBuiltinName(__pyx_n_s_enumerate); if (!__pyx_builtin_enumerate) __PYX_ERR(2, 405, __pyx_L1_error) + __pyx_builtin_NotImplementedError = __Pyx_GetBuiltinName(__pyx_n_s_NotImplementedError); if (!__pyx_builtin_NotImplementedError) __PYX_ERR(2, 460, __pyx_L1_error) + __pyx_builtin_TypeError = __Pyx_GetBuiltinName(__pyx_n_s_TypeError); if (!__pyx_builtin_TypeError) __PYX_ERR(3, 10, __pyx_L1_error) + __pyx_builtin_memoryview = __Pyx_GetBuiltinName(__pyx_n_s_memoryview); if (!__pyx_builtin_memoryview) __PYX_ERR(4, 35, __pyx_L1_error) + __pyx_builtin_StopIteration = __Pyx_GetBuiltinName(__pyx_n_s_StopIteration); if (!__pyx_builtin_StopIteration) __PYX_ERR(4, 236, __pyx_L1_error) + return 0; + __pyx_L1_error:; + return -1; +} + +static int __Pyx_InitCachedConstants(void) { + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__Pyx_InitCachedConstants", 0); + + /* "asyncpg/protocol/settings.pyx":15 + * self._is_utf8 = True + * self._settings = {} + * self._codec = codecs.lookup('utf-8') # <<<<<<<<<<<<<< + * self._data_codecs = DataCodecConfig(conn_key) + * + */ + __pyx_tuple_ = PyTuple_Pack(1, __pyx_kp_u_utf_8); if (unlikely(!__pyx_tuple_)) __PYX_ERR(0, 15, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple_); + __Pyx_GIVEREF(__pyx_tuple_); + + /* "asyncpg/protocol/settings.pyx":56 + * + * def __getattr__(self, name): + * if not name.startswith('_'): # <<<<<<<<<<<<<< + * try: + * return self._settings[name] + */ + __pyx_tuple__4 = PyTuple_Pack(1, __pyx_n_u__3); if (unlikely(!__pyx_tuple__4)) __PYX_ERR(0, 56, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__4); + __Pyx_GIVEREF(__pyx_tuple__4); + + /* "asyncpg/protocol/buffer.pyx":52 + * + * if self._view_count: + * raise RuntimeError( # <<<<<<<<<<<<<< + * 'Deallocating buffer with attached memoryviews') + * + */ + __pyx_tuple__5 = PyTuple_Pack(1, __pyx_kp_u_Deallocating_buffer_with_attache); if (unlikely(!__pyx_tuple__5)) __PYX_ERR(1, 52, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__5); + __Pyx_GIVEREF(__pyx_tuple__5); + + /* "asyncpg/protocol/buffer.pyx":68 + * cdef inline _check_readonly(self): + * if self._view_count: + * raise BufferError('the buffer is in read-only mode') # <<<<<<<<<<<<<< + * + * cdef inline len(self): + */ + __pyx_tuple__6 = PyTuple_Pack(1, __pyx_kp_u_the_buffer_is_in_read_only_mode); if (unlikely(!__pyx_tuple__6)) __PYX_ERR(1, 68, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__6); + __Pyx_GIVEREF(__pyx_tuple__6); + + /* "asyncpg/protocol/buffer.pyx":112 + * cdef inline start_message(self, char type): + * if self._length != 0: + * raise BufferError('cannot start_message for a non-empty buffer') # <<<<<<<<<<<<<< + * self._ensure_alloced(5) + * self._message_mode = 1 + */ + __pyx_tuple__7 = PyTuple_Pack(1, __pyx_kp_u_cannot_start_message_for_a_non_e); if (unlikely(!__pyx_tuple__7)) __PYX_ERR(1, 112, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__7); + __Pyx_GIVEREF(__pyx_tuple__7); + + /* "asyncpg/protocol/buffer.pyx":124 + * self._check_readonly() + * if not self._message_mode: + * raise BufferError( # <<<<<<<<<<<<<< + * 'end_message can only be called with start_message') + * if self._length < 5: + */ + __pyx_tuple__8 = PyTuple_Pack(1, __pyx_kp_u_end_message_can_only_be_called_w); if (unlikely(!__pyx_tuple__8)) __PYX_ERR(1, 124, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__8); + __Pyx_GIVEREF(__pyx_tuple__8); + + /* "asyncpg/protocol/buffer.pyx":127 + * 'end_message can only be called with start_message') + * if self._length < 5: + * raise BufferError('end_message: buffer is too small') # <<<<<<<<<<<<<< + * if mlen > _MAXINT32: + * raise BufferError('end_message: message is too large') + */ + __pyx_tuple__9 = PyTuple_Pack(1, __pyx_kp_u_end_message_buffer_is_too_small); if (unlikely(!__pyx_tuple__9)) __PYX_ERR(1, 127, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__9); + __Pyx_GIVEREF(__pyx_tuple__9); + + /* "asyncpg/protocol/buffer.pyx":129 + * raise BufferError('end_message: buffer is too small') + * if mlen > _MAXINT32: + * raise BufferError('end_message: message is too large') # <<<<<<<<<<<<<< + * + * hton.pack_int32(&self._buf[1], mlen) + */ + __pyx_tuple__10 = PyTuple_Pack(1, __pyx_kp_u_end_message_message_is_too_large); if (unlikely(!__pyx_tuple__10)) __PYX_ERR(1, 129, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__10); + __Pyx_GIVEREF(__pyx_tuple__10); + + /* "asyncpg/protocol/buffer.pyx":255 + * + * if not cpython.PyBytes_CheckExact(data): + * raise BufferError('feed_data: bytes object expected') # <<<<<<<<<<<<<< + * data_bytes = data + * + */ + __pyx_tuple__11 = PyTuple_Pack(1, __pyx_kp_u_feed_data_bytes_object_expected); if (unlikely(!__pyx_tuple__11)) __PYX_ERR(1, 255, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__11); + __Pyx_GIVEREF(__pyx_tuple__11); + + /* "asyncpg/protocol/buffer.pyx":275 + * cdef inline _ensure_first_buf(self): + * if self._len0 == 0: + * raise BufferError('empty first buffer') # <<<<<<<<<<<<<< + * + * if self._pos0 == self._len0: + */ + __pyx_tuple__12 = PyTuple_Pack(1, __pyx_kp_u_empty_first_buffer); if (unlikely(!__pyx_tuple__12)) __PYX_ERR(1, 275, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__12); + __Pyx_GIVEREF(__pyx_tuple__12); + + /* "asyncpg/protocol/buffer.pyx":295 + * if ASYNCPG_DEBUG: + * if self._len0 < 1: + * raise RuntimeError( # <<<<<<<<<<<<<< + * 'debug: second buffer of ReadBuffer is empty') + * + */ + __pyx_tuple__13 = PyTuple_Pack(1, __pyx_kp_u_debug_second_buffer_of_ReadBuffe); if (unlikely(!__pyx_tuple__13)) __PYX_ERR(1, 295, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__13); + __Pyx_GIVEREF(__pyx_tuple__13); + + /* "asyncpg/protocol/buffer.pyx":342 + * self._current_message_len_unread -= nbytes + * if self._current_message_len_unread < 0: + * raise BufferError('buffer overread') # <<<<<<<<<<<<<< + * + * result = bytearray() + */ + __pyx_tuple__14 = PyTuple_Pack(1, __pyx_kp_u_buffer_overread); if (unlikely(!__pyx_tuple__14)) __PYX_ERR(1, 342, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__14); + __Pyx_GIVEREF(__pyx_tuple__14); + + /* "asyncpg/protocol/buffer.pyx":368 + * if ASYNCPG_DEBUG: + * if not self._buf0: + * raise RuntimeError( # <<<<<<<<<<<<<< + * 'debug: first buffer of ReadBuffer is empty') + * + */ + __pyx_tuple__15 = PyTuple_Pack(1, __pyx_kp_u_debug_first_buffer_of_ReadBuffer); if (unlikely(!__pyx_tuple__15)) __PYX_ERR(1, 368, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__15); + __Pyx_GIVEREF(__pyx_tuple__15); + + /* "asyncpg/protocol/buffer.pyx":374 + * first_byte = self._try_read_bytes(1) + * if first_byte is NULL: + * raise BufferError('not enough data to read one byte') # <<<<<<<<<<<<<< + * + * return first_byte[0] + */ + __pyx_tuple__16 = PyTuple_Pack(1, __pyx_kp_u_not_enough_data_to_read_one_byte); if (unlikely(!__pyx_tuple__16)) __PYX_ERR(1, 374, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__16); + __Pyx_GIVEREF(__pyx_tuple__16); + + /* "asyncpg/protocol/buffer.pyx":419 + * cdef inline read_cstr(self): + * if not self._current_message_ready: + * raise BufferError( # <<<<<<<<<<<<<< + * 'read_cstr only works when the message guaranteed ' + * 'to be in the buffer') + */ + __pyx_tuple__17 = PyTuple_Pack(1, __pyx_kp_u_read_cstr_only_works_when_the_me); if (unlikely(!__pyx_tuple__17)) __PYX_ERR(1, 419, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__17); + __Pyx_GIVEREF(__pyx_tuple__17); + + /* "asyncpg/protocol/buffer.pyx":457 + * self._current_message_len_unread -= nread + * if self._current_message_len_unread < 0: + * raise BufferError('read_cstr: buffer overread') # <<<<<<<<<<<<<< + * + * return result + */ + __pyx_tuple__20 = PyTuple_Pack(1, __pyx_kp_u_read_cstr_buffer_overread); if (unlikely(!__pyx_tuple__20)) __PYX_ERR(1, 457, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__20); + __Pyx_GIVEREF(__pyx_tuple__20); + + /* "asyncpg/protocol/buffer.pyx":469 + * self._current_message_len_unread -= nread + * if self._current_message_len_unread < 0: + * raise BufferError('read_cstr: buffer overread') # <<<<<<<<<<<<<< + * + * self._ensure_first_buf() + */ + __pyx_tuple__21 = PyTuple_Pack(1, __pyx_kp_u_read_cstr_buffer_overread); if (unlikely(!__pyx_tuple__21)) __PYX_ERR(1, 469, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__21); + __Pyx_GIVEREF(__pyx_tuple__21); + + /* "asyncpg/protocol/buffer.pyx":486 + * cbuf = self._try_read_bytes(1) + * if cbuf == NULL: + * raise BufferError( # <<<<<<<<<<<<<< + * 'failed to read one byte on a non-empty buffer') + * self._current_message_type = cbuf[0] + */ + __pyx_tuple__22 = PyTuple_Pack(1, __pyx_kp_u_failed_to_read_one_byte_on_a_non); if (unlikely(!__pyx_tuple__22)) __PYX_ERR(1, 486, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__22); + __Pyx_GIVEREF(__pyx_tuple__22); + + /* "asyncpg/protocol/buffer.pyx":525 + * cdef Memory consume_message(self): + * if not self._current_message_ready: + * raise BufferError('no message to consume') # <<<<<<<<<<<<<< + * if self._current_message_len_unread > 0: + * mem = self.read(self._current_message_len_unread) + */ + __pyx_tuple__23 = PyTuple_Pack(1, __pyx_kp_u_no_message_to_consume); if (unlikely(!__pyx_tuple__23)) __PYX_ERR(1, 525, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__23); + __Pyx_GIVEREF(__pyx_tuple__23); + + /* "asyncpg/protocol/buffer.pyx":539 + * + * if not self._current_message_ready: + * raise BufferError('no message to discard') # <<<<<<<<<<<<<< + * + * if self._current_message_len_unread: + */ + __pyx_tuple__24 = PyTuple_Pack(1, __pyx_kp_u_no_message_to_discard); if (unlikely(!__pyx_tuple__24)) __PYX_ERR(1, 539, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__24); + __Pyx_GIVEREF(__pyx_tuple__24); + + /* "asyncpg/protocol/codecs/base.pyx":110 + * count = len(obj) + * if count > _MAXINT32: + * raise ValueError('too many elements in composite type record') # <<<<<<<<<<<<<< + * + * elem_data = WriteBuffer.new() + */ + __pyx_tuple__25 = PyTuple_Pack(1, __pyx_kp_u_too_many_elements_in_composite_t); if (unlikely(!__pyx_tuple__25)) __PYX_ERR(2, 110, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__25); + __Pyx_GIVEREF(__pyx_tuple__25); + + /* "asyncpg/protocol/codecs/base.pyx":363 + * + * # Canonicalize type name to "elemtype[]" + * if name.startswith('_'): # <<<<<<<<<<<<<< + * name = name[1:] + * name = '{}[]'.format(name) + */ + __pyx_tuple__26 = PyTuple_Pack(1, __pyx_n_u__3); if (unlikely(!__pyx_tuple__26)) __PYX_ERR(2, 363, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__26); + __Pyx_GIVEREF(__pyx_tuple__26); + + /* "asyncpg/protocol/codecs/base.pyx":364 + * # Canonicalize type name to "elemtype[]" + * if name.startswith('_'): + * name = name[1:] # <<<<<<<<<<<<<< + * name = '{}[]'.format(name) + * + */ + __pyx_slice__27 = PySlice_New(__pyx_int_1, Py_None, Py_None); if (unlikely(!__pyx_slice__27)) __PYX_ERR(2, 364, __pyx_L1_error) + __Pyx_GOTREF(__pyx_slice__27); + __Pyx_GIVEREF(__pyx_slice__27); + + /* "asyncpg/protocol/codecs/base.pyx":591 + * kind = 'scalar' + * + * codec = Codec(INVALIDOID) # <<<<<<<<<<<<<< + * codec.init(name, None, kind, CODEC_C, format, encode, + * decode, None, None, None, None, None, None, 0) + */ + __pyx_tuple__29 = PyTuple_Pack(1, __pyx_int_0); if (unlikely(!__pyx_tuple__29)) __PYX_ERR(2, 591, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__29); + __Pyx_GIVEREF(__pyx_tuple__29); + + /* "asyncpg/protocol/codecs/text.pyx":21 + * + * if size[0] > 0x7fffffff: + * raise ValueError('string too long') # <<<<<<<<<<<<<< + * + * + */ + __pyx_tuple__30 = PyTuple_Pack(1, __pyx_kp_u_string_too_long); if (unlikely(!__pyx_tuple__30)) __PYX_ERR(7, 21, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__30); + __Pyx_GIVEREF(__pyx_tuple__30); + + /* "asyncpg/protocol/codecs/bits.pyx":35 + * try: + * if bitlen > _MAXINT32: + * raise ValueError('bit value too long') # <<<<<<<<<<<<<< + * wbuf.write_int32(4 + len) + * wbuf.write_int32(bitlen) + */ + __pyx_tuple__31 = PyTuple_Pack(1, __pyx_kp_u_bit_value_too_long); if (unlikely(!__pyx_tuple__31)) __PYX_ERR(8, 35, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__31); + __Pyx_GIVEREF(__pyx_tuple__31); + + /* "asyncpg/protocol/codecs/datetime.pyx":211 + * + * cdef timetz_encode(ConnectionSettings settings, WriteBuffer buf, obj): + * offset = obj.tzinfo.utcoffset(None) # <<<<<<<<<<<<<< + * + * cdef: + */ + __pyx_tuple__32 = PyTuple_Pack(1, Py_None); if (unlikely(!__pyx_tuple__32)) __PYX_ERR(9, 211, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__32); + __Pyx_GIVEREF(__pyx_tuple__32); + + /* "asyncpg/protocol/codecs/float.pyx":15 + * cdef float fval = dval + * if math.isinf(fval) and not math.isinf(dval): + * raise ValueError('float value too large to be encoded as FLOAT4') # <<<<<<<<<<<<<< + * + * buf.write_int32(4) + */ + __pyx_tuple__33 = PyTuple_Pack(1, __pyx_kp_u_float_value_too_large_to_be_enco); if (unlikely(!__pyx_tuple__33)) __PYX_ERR(10, 15, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__33); + __Pyx_GIVEREF(__pyx_tuple__33); + + /* "asyncpg/protocol/codecs/geometry.pyx":115 + * encoded_len = 1 + 4 + 16 * npts + * if encoded_len > _MAXINT32: + * raise ValueError('path value too long') # <<<<<<<<<<<<<< + * + * wbuf.write_int32(encoded_len) + */ + __pyx_tuple__34 = PyTuple_Pack(1, __pyx_kp_u_path_value_too_long); if (unlikely(!__pyx_tuple__34)) __PYX_ERR(11, 115, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__34); + __Pyx_GIVEREF(__pyx_tuple__34); + + /* "asyncpg/protocol/codecs/geometry.pyx":141 + * encoded_len = 4 + 16 * npts + * if encoded_len > _MAXINT32: + * raise ValueError('polygon value too long') # <<<<<<<<<<<<<< + * + * wbuf.write_int32(encoded_len) + */ + __pyx_tuple__35 = PyTuple_Pack(1, __pyx_kp_u_polygon_value_too_long); if (unlikely(!__pyx_tuple__35)) __PYX_ERR(11, 141, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__35); + __Pyx_GIVEREF(__pyx_tuple__35); + + /* "asyncpg/protocol/codecs/json.pyx":16 + * + * if size > 0x7fffffff - 1: + * raise ValueError('string too long') # <<<<<<<<<<<<<< + * + * buf.write_int32(size + 1) + */ + __pyx_tuple__36 = PyTuple_Pack(1, __pyx_kp_u_string_too_long); if (unlikely(!__pyx_tuple__36)) __PYX_ERR(12, 16, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__36); + __Pyx_GIVEREF(__pyx_tuple__36); + + /* "asyncpg/protocol/codecs/txid.pyx":21 + * + * if len(obj) != 3: + * raise ValueError( # <<<<<<<<<<<<<< + * 'invalid number of elements in txid_snapshot tuple, expecting 4') + * + */ + __pyx_tuple__37 = PyTuple_Pack(1, __pyx_kp_u_invalid_number_of_elements_in_tx); if (unlikely(!__pyx_tuple__37)) __PYX_ERR(17, 21, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__37); + __Pyx_GIVEREF(__pyx_tuple__37); + + /* "asyncpg/protocol/codecs/txid.pyx":26 + * nxip = len(obj[2]) + * if nxip > _MAXINT32: + * raise ValueError('txid_snapshot value is too long') # <<<<<<<<<<<<<< + * + * xmin = obj[0] + */ + __pyx_tuple__38 = PyTuple_Pack(1, __pyx_kp_u_txid_snapshot_value_is_too_long); if (unlikely(!__pyx_tuple__38)) __PYX_ERR(17, 26, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__38); + __Pyx_GIVEREF(__pyx_tuple__38); + + /* "asyncpg/protocol/codecs/array.pyx":49 + * + * if mylen > _MAXINT32: + * raise ValueError('too many elements in array value') # <<<<<<<<<<<<<< + * + * if ndims[0] > ARRAY_MAXDIM: + */ + __pyx_tuple__39 = PyTuple_Pack(1, __pyx_kp_u_too_many_elements_in_array_value); if (unlikely(!__pyx_tuple__39)) __PYX_ERR(20, 49, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__39); + __Pyx_GIVEREF(__pyx_tuple__39); + + /* "asyncpg/protocol/codecs/array.pyx":63 + * elemlen = len(elem) + * if elemlen > _MAXINT32: + * raise ValueError('too many elements in array value') # <<<<<<<<<<<<<< + * ndims[0] += 1 + * _get_array_shape(elem, dims, ndims) + */ + __pyx_tuple__40 = PyTuple_Pack(1, __pyx_kp_u_too_many_elements_in_array_value); if (unlikely(!__pyx_tuple__40)) __PYX_ERR(20, 63, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__40); + __Pyx_GIVEREF(__pyx_tuple__40); + + /* "asyncpg/protocol/codecs/array.pyx":68 + * else: + * if len(elem) != elemlen: + * raise ValueError('non-homogeneous array') # <<<<<<<<<<<<<< + * else: + * if elemlen >= 0: + */ + __pyx_tuple__41 = PyTuple_Pack(1, __pyx_kp_u_non_homogeneous_array); if (unlikely(!__pyx_tuple__41)) __PYX_ERR(20, 68, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__41); + __Pyx_GIVEREF(__pyx_tuple__41); + + /* "asyncpg/protocol/codecs/array.pyx":71 + * else: + * if elemlen >= 0: + * raise ValueError('non-homogeneous array') # <<<<<<<<<<<<<< + * else: + * elemlen = -1 + */ + __pyx_tuple__42 = PyTuple_Pack(1, __pyx_kp_u_non_homogeneous_array); if (unlikely(!__pyx_tuple__42)) __PYX_ERR(20, 71, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__42); + __Pyx_GIVEREF(__pyx_tuple__42); + + /* "asyncpg/protocol/codecs/array.pyx":397 + * ptr = apg_parse_int32(ptr, &ubound) + * if ptr == NULL: + * raise ValueError('missing array dimension value') # <<<<<<<<<<<<<< + * + * if ptr[0] == ':': + */ + __pyx_tuple__43 = PyTuple_Pack(1, __pyx_kp_u_missing_array_dimension_value); if (unlikely(!__pyx_tuple__43)) __PYX_ERR(20, 397, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__43); + __Pyx_GIVEREF(__pyx_tuple__43); + + /* "asyncpg/protocol/codecs/array.pyx":406 + * ptr = apg_parse_int32(ptr, &ubound) + * if ptr == NULL: + * raise ValueError('missing array dimension value') # <<<<<<<<<<<<<< + * else: + * lbound = 1 + */ + __pyx_tuple__44 = PyTuple_Pack(1, __pyx_kp_u_missing_array_dimension_value); if (unlikely(!__pyx_tuple__44)) __PYX_ERR(20, 406, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__44); + __Pyx_GIVEREF(__pyx_tuple__44); + + /* "asyncpg/protocol/codecs/array.pyx":411 + * + * if ptr[0] != ']': + * raise ValueError('missing \']\' after array dimensions') # <<<<<<<<<<<<<< + * + * ptr += 1 # ']' + */ + __pyx_tuple__45 = PyTuple_Pack(1, __pyx_kp_u_missing_after_array_dimensions); if (unlikely(!__pyx_tuple__45)) __PYX_ERR(20, 411, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__45); + __Pyx_GIVEREF(__pyx_tuple__45); + + /* "asyncpg/protocol/codecs/array.pyx":421 + * # If dimensions were given, the '=' token is expected. + * if ptr[0] != '=': + * raise ValueError('missing \'=\' after array dimensions') # <<<<<<<<<<<<<< + * + * ptr += 1 # '=' + */ + __pyx_tuple__46 = PyTuple_Pack(1, __pyx_kp_u_missing_after_array_dimensions_2); if (unlikely(!__pyx_tuple__46)) __PYX_ERR(20, 421, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__46); + __Pyx_GIVEREF(__pyx_tuple__46); + + /* "asyncpg/protocol/codecs/array.pyx":436 + * + * if inferred_ndims != ndims: + * raise ValueError( # <<<<<<<<<<<<<< + * 'specified array dimensions do not match array content') + * + */ + __pyx_tuple__47 = PyTuple_Pack(1, __pyx_kp_u_specified_array_dimensions_do_no); if (unlikely(!__pyx_tuple__47)) __PYX_ERR(20, 436, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__47); + __Pyx_GIVEREF(__pyx_tuple__47); + + /* "asyncpg/protocol/codecs/array.pyx":441 + * for i in range(ndims): + * if inferred_dims[i] != dims[i]: + * raise ValueError( # <<<<<<<<<<<<<< + * 'specified array dimensions do not match array content') + * else: + */ + __pyx_tuple__48 = PyTuple_Pack(1, __pyx_kp_u_specified_array_dimensions_do_no); if (unlikely(!__pyx_tuple__48)) __PYX_ERR(20, 441, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__48); + __Pyx_GIVEREF(__pyx_tuple__48); + + /* "asyncpg/protocol/codecs/array.pyx":613 + * while not end_of_item: + * if ptr[0] == '\0': + * raise ValueError('unexpected end of string') # <<<<<<<<<<<<<< + * + * elif ptr[0] == '"': + */ + __pyx_tuple__49 = PyTuple_Pack(1, __pyx_kp_u_unexpected_end_of_string); if (unlikely(!__pyx_tuple__49)) __PYX_ERR(20, 613, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__49); + __Pyx_GIVEREF(__pyx_tuple__49); + + /* "asyncpg/protocol/codecs/array.pyx":638 + * ptr += 1 + * else: + * raise ValueError('unexpected end of string') # <<<<<<<<<<<<<< + * + * elif in_quotes: + */ + __pyx_tuple__50 = PyTuple_Pack(1, __pyx_kp_u_unexpected_end_of_string); if (unlikely(!__pyx_tuple__50)) __PYX_ERR(20, 638, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__50); + __Pyx_GIVEREF(__pyx_tuple__50); + + /* "asyncpg/protocol/codecs/hstore.pyx":18 + * count = len(obj) + * if count > _MAXINT32: + * raise ValueError('hstore value is too large') # <<<<<<<<<<<<<< + * item_buf.write_int32(count) + * + */ + __pyx_tuple__51 = PyTuple_Pack(1, __pyx_kp_u_hstore_value_is_too_large); if (unlikely(!__pyx_tuple__51)) __PYX_ERR(23, 18, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__51); + __Pyx_GIVEREF(__pyx_tuple__51); + + /* "asyncpg/protocol/codecs/hstore.pyx":28 + * for k, v in items: + * if k is None: + * raise ValueError('null value not allowed in hstore key') # <<<<<<<<<<<<<< + * as_pg_string_and_size(settings, k, &str, &size) + * item_buf.write_int32(size) + */ + __pyx_tuple__52 = PyTuple_Pack(1, __pyx_kp_u_null_value_not_allowed_in_hstore); if (unlikely(!__pyx_tuple__52)) __PYX_ERR(23, 28, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__52); + __Pyx_GIVEREF(__pyx_tuple__52); + + /* "asyncpg/protocol/codecs/hstore.pyx":61 + * elem_len = hton.unpack_int32(buf.read(4)) + * if elem_len < 0: + * raise ValueError('null value not allowed in hstore key') # <<<<<<<<<<<<<< + * + * k = decode_pg_string(settings, buf.read(elem_len), elem_len) + */ + __pyx_tuple__53 = PyTuple_Pack(1, __pyx_kp_u_null_value_not_allowed_in_hstore); if (unlikely(!__pyx_tuple__53)) __PYX_ERR(23, 61, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__53); + __Pyx_GIVEREF(__pyx_tuple__53); + + /* "asyncpg/protocol/coreproto.pyx":15 + * def __init__(self, con_args): + * self.buffer = ReadBuffer() + * self.user = con_args.get('user') # <<<<<<<<<<<<<< + * self.password = con_args.get('password') + * self.auth_msg = None + */ + __pyx_tuple__54 = PyTuple_Pack(1, __pyx_n_u_user); if (unlikely(!__pyx_tuple__54)) __PYX_ERR(4, 15, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__54); + __Pyx_GIVEREF(__pyx_tuple__54); + + /* "asyncpg/protocol/coreproto.pyx":16 + * self.buffer = ReadBuffer() + * self.user = con_args.get('user') + * self.password = con_args.get('password') # <<<<<<<<<<<<<< + * self.auth_msg = None + * self.con_args = con_args + */ + __pyx_tuple__55 = PyTuple_Pack(1, __pyx_n_u_password); if (unlikely(!__pyx_tuple__55)) __PYX_ERR(4, 16, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__55); + __Pyx_GIVEREF(__pyx_tuple__55); + + /* "asyncpg/protocol/coreproto.pyx":91 + * if self.result_type != RESULT_FAILED: + * self.result_type = RESULT_FAILED + * self.result = RuntimeError( # <<<<<<<<<<<<<< + * 'unknown error in protocol implementation') + * + */ + __pyx_tuple__56 = PyTuple_Pack(1, __pyx_kp_u_unknown_error_in_protocol_implem); if (unlikely(!__pyx_tuple__56)) __PYX_ERR(4, 91, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__56); + __Pyx_GIVEREF(__pyx_tuple__56); + + /* "asyncpg/protocol/coreproto.pyx":326 + * if ASYNCPG_DEBUG: + * if buf.get_message_type() != b'D': + * raise RuntimeError( # <<<<<<<<<<<<<< + * '_parse_data_msgs: first message is not "D"') + * + */ + __pyx_tuple__57 = PyTuple_Pack(1, __pyx_kp_u_parse_data_msgs_first_message_i); if (unlikely(!__pyx_tuple__57)) __PYX_ERR(4, 326, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__57); + __Pyx_GIVEREF(__pyx_tuple__57); + + /* "asyncpg/protocol/coreproto.pyx":420 + * + * msg = WriteBuffer.new_message(b'p') + * msg.write_bytestring(self.password.encode('ascii')) # <<<<<<<<<<<<<< + * msg.end_message() + * + */ + __pyx_tuple__58 = PyTuple_Pack(1, __pyx_n_u_ascii); if (unlikely(!__pyx_tuple__58)) __PYX_ERR(4, 420, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__58); + __Pyx_GIVEREF(__pyx_tuple__58); + + /* "asyncpg/protocol/coreproto.pyx":432 + * + * # 'md5' + md5(md5(password + username) + salt)) + * userpass = ((self.password or '') + (self.user or '')).encode('ascii') # <<<<<<<<<<<<<< + * hash = hashlib_md5(hashlib_md5(userpass).hexdigest().\ + * encode('ascii') + salt).hexdigest().encode('ascii') + */ + __pyx_tuple__59 = PyTuple_Pack(1, __pyx_n_u_ascii); if (unlikely(!__pyx_tuple__59)) __PYX_ERR(4, 432, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__59); + __Pyx_GIVEREF(__pyx_tuple__59); + + /* "asyncpg/protocol/coreproto.pyx":434 + * userpass = ((self.password or '') + (self.user or '')).encode('ascii') + * hash = hashlib_md5(hashlib_md5(userpass).hexdigest().\ + * encode('ascii') + salt).hexdigest().encode('ascii') # <<<<<<<<<<<<<< + * + * msg.write_bytestring(b'md5' + hash) + */ + __pyx_tuple__60 = PyTuple_Pack(1, __pyx_n_u_ascii); if (unlikely(!__pyx_tuple__60)) __PYX_ERR(4, 434, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__60); + __Pyx_GIVEREF(__pyx_tuple__60); + __pyx_tuple__61 = PyTuple_Pack(1, __pyx_n_u_ascii); if (unlikely(!__pyx_tuple__61)) __PYX_ERR(4, 434, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__61); + __Pyx_GIVEREF(__pyx_tuple__61); + + /* "asyncpg/protocol/coreproto.pyx":491 + * if new_state == PROTOCOL_IDLE: + * if self.state == PROTOCOL_FAILED: + * raise RuntimeError( # <<<<<<<<<<<<<< + * 'cannot switch to "idle" state; ' + * 'protocol is in the "failed" state') + */ + __pyx_tuple__62 = PyTuple_Pack(1, __pyx_kp_u_cannot_switch_to_idle_state_prot); if (unlikely(!__pyx_tuple__62)) __PYX_ERR(4, 491, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__62); + __Pyx_GIVEREF(__pyx_tuple__62); + + /* "asyncpg/protocol/coreproto.pyx":495 + * 'protocol is in the "failed" state') + * elif self.state == PROTOCOL_IDLE: + * raise RuntimeError( # <<<<<<<<<<<<<< + * 'protocol is already in the "idle" state') + * else: + */ + __pyx_tuple__63 = PyTuple_Pack(1, __pyx_kp_u_protocol_is_already_in_the_idle); if (unlikely(!__pyx_tuple__63)) __PYX_ERR(4, 495, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__63); + __Pyx_GIVEREF(__pyx_tuple__63); + + /* "asyncpg/protocol/coreproto.pyx":519 + * cdef _ensure_connected(self): + * if self.con_status != CONNECTION_OK: + * raise RuntimeError('not connected') # <<<<<<<<<<<<<< + * + * cdef WriteBuffer _build_bind_message(self, str portal_name, + */ + __pyx_tuple__64 = PyTuple_Pack(1, __pyx_kp_u_not_connected); if (unlikely(!__pyx_tuple__64)) __PYX_ERR(4, 519, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__64); + __Pyx_GIVEREF(__pyx_tuple__64); + + /* "asyncpg/protocol/coreproto.pyx":544 + * + * if self.con_status != CONNECTION_BAD: + * raise RuntimeError('already connected') # <<<<<<<<<<<<<< + * + * self._set_state(PROTOCOL_AUTH) + */ + __pyx_tuple__65 = PyTuple_Pack(1, __pyx_kp_u_already_connected); if (unlikely(!__pyx_tuple__65)) __PYX_ERR(4, 544, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__65); + __Pyx_GIVEREF(__pyx_tuple__65); + + /* "asyncpg/protocol/coreproto.pyx":557 + * + * buf.write_bytestring(b'client_encoding') + * buf.write_bytestring("'{}'".format(self.encoding).encode('ascii')) # <<<<<<<<<<<<<< + * + * for param in self.con_args: + */ + __pyx_tuple__67 = PyTuple_Pack(1, __pyx_n_u_ascii); if (unlikely(!__pyx_tuple__67)) __PYX_ERR(4, 557, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__67); + __Pyx_GIVEREF(__pyx_tuple__67); + + /* "asyncpg/protocol/coreproto.pyx":735 + * self.transport = transport + * + * sock = transport.get_extra_info('socket') # <<<<<<<<<<<<<< + * if (sock is not None and + * (not hasattr(socket, 'AF_UNIX') + */ + __pyx_tuple__68 = PyTuple_Pack(1, __pyx_n_u_socket); if (unlikely(!__pyx_tuple__68)) __PYX_ERR(4, 735, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__68); + __Pyx_GIVEREF(__pyx_tuple__68); + + /* "asyncpg/protocol/prepared_stmt.pyx":228 + * if fnum > 0: + * # It's OK to have no rows_codecs for empty records + * raise RuntimeError('invalid rows_codecs') # <<<<<<<<<<<<<< + * + * dec_row = record.ApgRecord_New(self.cols_desc, fnum) + */ + __pyx_tuple__69 = PyTuple_Pack(1, __pyx_kp_u_invalid_rows_codecs); if (unlikely(!__pyx_tuple__69)) __PYX_ERR(25, 228, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__69); + __Pyx_GIVEREF(__pyx_tuple__69); + + /* "asyncpg/protocol/protocol.pyx":93 + * self.address = addr + * self.settings = ConnectionSettings( + * (self.address, con_args.get('database'))) # <<<<<<<<<<<<<< + * + * self.uid_counter = 0 + */ + __pyx_tuple__70 = PyTuple_Pack(1, __pyx_n_u_database); if (unlikely(!__pyx_tuple__70)) __PYX_ERR(27, 93, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__70); + __Pyx_GIVEREF(__pyx_tuple__70); + + /* "asyncpg/protocol/protocol.pyx":335 + * cdef _handle_waiter_on_connection_lost(self, cause): + * if self.waiter is not None and not self.waiter.done(): + * exc = apg_exc.ConnectionDoesNotExistError( # <<<<<<<<<<<<<< + * 'connection was closed in the middle of ' + * 'operation') + */ + __pyx_tuple__71 = PyTuple_Pack(1, __pyx_kp_u_connection_was_closed_in_the_mid); if (unlikely(!__pyx_tuple__71)) __PYX_ERR(27, 335, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__71); + __Pyx_GIVEREF(__pyx_tuple__71); + + /* "asyncpg/protocol/protocol.pyx":348 + * cdef _ensure_clear_state(self): + * if self.cancel_waiter is not None: + * raise apg_exc.InterfaceError( # <<<<<<<<<<<<<< + * 'cannot perform operation: another operation is cancelling') + * if self.closing: + */ + __pyx_tuple__72 = PyTuple_Pack(1, __pyx_kp_u_cannot_perform_operation_another); if (unlikely(!__pyx_tuple__72)) __PYX_ERR(27, 348, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__72); + __Pyx_GIVEREF(__pyx_tuple__72); + + /* "asyncpg/protocol/protocol.pyx":351 + * 'cannot perform operation: another operation is cancelling') + * if self.closing: + * raise apg_exc.InterfaceError( # <<<<<<<<<<<<<< + * 'cannot perform operation: connection is closed') + * if self.waiter is not None or self.timeout_handle is not None: + */ + __pyx_tuple__73 = PyTuple_Pack(1, __pyx_kp_u_cannot_perform_operation_connect); if (unlikely(!__pyx_tuple__73)) __PYX_ERR(27, 351, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__73); + __Pyx_GIVEREF(__pyx_tuple__73); + + /* "asyncpg/protocol/protocol.pyx":354 + * 'cannot perform operation: connection is closed') + * if self.waiter is not None or self.timeout_handle is not None: + * raise apg_exc.InterfaceError( # <<<<<<<<<<<<<< + * 'cannot perform operation: another operation is in progress') + * + */ + __pyx_tuple__74 = PyTuple_Pack(1, __pyx_kp_u_cannot_perform_operation_another_2); if (unlikely(!__pyx_tuple__74)) __PYX_ERR(27, 354, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__74); + __Pyx_GIVEREF(__pyx_tuple__74); + + /* "asyncpg/protocol/protocol.pyx":368 + * + * cdef _on_result__connect(self, object waiter): + * waiter.set_result(True) # <<<<<<<<<<<<<< + * + * cdef _on_result__prepare(self, object waiter): + */ + __pyx_tuple__75 = PyTuple_Pack(1, Py_True); if (unlikely(!__pyx_tuple__75)) __PYX_ERR(27, 368, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__75); + __Pyx_GIVEREF(__pyx_tuple__75); + + /* "asyncpg/protocol/protocol.pyx":373 + * if ASYNCPG_DEBUG: + * if self.statement is None: + * raise RuntimeError( # <<<<<<<<<<<<<< + * '_on_result__prepare: statement is None') + * + */ + __pyx_tuple__76 = PyTuple_Pack(1, __pyx_kp_u_on_result__prepare_statement_is); if (unlikely(!__pyx_tuple__76)) __PYX_ERR(27, 373, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__76); + __Pyx_GIVEREF(__pyx_tuple__76); + + /* "asyncpg/protocol/protocol.pyx":403 + * if ASYNCPG_DEBUG: + * if self.statement is None: + * raise RuntimeError( # <<<<<<<<<<<<<< + * '_decode_row: statement is None') + * + */ + __pyx_tuple__77 = PyTuple_Pack(1, __pyx_kp_u_decode_row_statement_is_None); if (unlikely(!__pyx_tuple__77)) __PYX_ERR(27, 403, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__77); + __Pyx_GIVEREF(__pyx_tuple__77); + + /* "asyncpg/protocol/protocol.pyx":414 + * if ASYNCPG_DEBUG: + * if waiter is None: + * raise RuntimeError('_on_result: waiter is None') # <<<<<<<<<<<<<< + * + * if waiter.cancelled(): + */ + __pyx_tuple__78 = PyTuple_Pack(1, __pyx_kp_u_on_result_waiter_is_None); if (unlikely(!__pyx_tuple__78)) __PYX_ERR(27, 414, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__78); + __Pyx_GIVEREF(__pyx_tuple__78); + + /* "asyncpg/protocol/protocol.pyx":420 + * + * if waiter.done(): + * raise RuntimeError('_on_result: waiter is done') # <<<<<<<<<<<<<< + * + * if self.result_type == RESULT_FAILED: + */ + __pyx_tuple__79 = PyTuple_Pack(1, __pyx_kp_u_on_result_waiter_is_done); if (unlikely(!__pyx_tuple__79)) __PYX_ERR(27, 420, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__79); + __Pyx_GIVEREF(__pyx_tuple__79); + + /* "asyncpg/protocol/protocol.pyx":472 + * if self.waiter is None or not self.waiter.cancelled(): + * self.cancel_waiter.set_result( + * RuntimeError('invalid state after cancellation')) # <<<<<<<<<<<<<< + * else: + * self.cancel_waiter.set_result(None) + */ + __pyx_tuple__80 = PyTuple_Pack(1, __pyx_kp_u_invalid_state_after_cancellation); if (unlikely(!__pyx_tuple__80)) __PYX_ERR(27, 472, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__80); + __Pyx_GIVEREF(__pyx_tuple__80); + + /* "asyncpg/protocol/protocol.pyx":474 + * RuntimeError('invalid state after cancellation')) + * else: + * self.cancel_waiter.set_result(None) # <<<<<<<<<<<<<< + * self.cancel_waiter = None + * self.waiter = None + */ + __pyx_tuple__81 = PyTuple_Pack(1, Py_None); if (unlikely(!__pyx_tuple__81)) __PYX_ERR(27, 474, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__81); + __Pyx_GIVEREF(__pyx_tuple__81); + + /* "asyncpg/protocol/protocol.pyx":495 + * if self.waiter is not None and not self.waiter.done(): + * if exc is None: + * self.waiter.set_result(None) # <<<<<<<<<<<<<< + * else: + * self.waiter.set_exception(exc) + */ + __pyx_tuple__82 = PyTuple_Pack(1, Py_None); if (unlikely(!__pyx_tuple__82)) __PYX_ERR(27, 495, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__82); + __Pyx_GIVEREF(__pyx_tuple__82); + + /* "asyncpg/protocol/pgtypes.pxi":98 + * DEF REGROLEOID = 4096 + * + * cdef ARRAY_TYPES = (_TEXTOID, _OIDOID,) # <<<<<<<<<<<<<< + * + * TYPEMAP = { + */ + __pyx_tuple__83 = PyTuple_Pack(2, __pyx_int_1009, __pyx_int_1028); if (unlikely(!__pyx_tuple__83)) __PYX_ERR(32, 98, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__83); + __Pyx_GIVEREF(__pyx_tuple__83); + + /* "asyncpg/protocol/codecs/datetime.pyx":14 + * timedelta = datetime.timedelta + * + * pg_epoch_datetime = datetime.datetime(2000, 1, 1) # <<<<<<<<<<<<<< + * cdef int32_t pg_epoch_datetime_ts = \ + * cpython.PyLong_AsLong(int(pg_epoch_datetime.timestamp())) + */ + __pyx_tuple__84 = PyTuple_Pack(3, __pyx_int_2000, __pyx_int_1, __pyx_int_1); if (unlikely(!__pyx_tuple__84)) __PYX_ERR(9, 14, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__84); + __Pyx_GIVEREF(__pyx_tuple__84); + + /* "asyncpg/protocol/codecs/datetime.pyx":18 + * cpython.PyLong_AsLong(int(pg_epoch_datetime.timestamp())) + * + * pg_epoch_datetime_utc = datetime.datetime(2000, 1, 1, tzinfo=utc) # <<<<<<<<<<<<<< + * cdef int32_t pg_epoch_datetime_utc_ts = \ + * cpython.PyLong_AsLong(pg_epoch_datetime_utc.timestamp()) + */ + __pyx_tuple__85 = PyTuple_Pack(3, __pyx_int_2000, __pyx_int_1, __pyx_int_1); if (unlikely(!__pyx_tuple__85)) __PYX_ERR(9, 18, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__85); + __Pyx_GIVEREF(__pyx_tuple__85); + + /* "asyncpg/protocol/codecs/datetime.pyx":22 + * cpython.PyLong_AsLong(pg_epoch_datetime_utc.timestamp()) + * + * pg_epoch_date = datetime.date(2000, 1, 1) # <<<<<<<<<<<<<< + * cdef int32_t pg_date_offset_ord = \ + * cpython.PyLong_AsLong(pg_epoch_date.toordinal()) + */ + __pyx_tuple__86 = PyTuple_Pack(3, __pyx_int_2000, __pyx_int_1, __pyx_int_1); if (unlikely(!__pyx_tuple__86)) __PYX_ERR(9, 22, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__86); + __Pyx_GIVEREF(__pyx_tuple__86); + + /* "asyncpg/protocol/protocol.pyx":511 + * + * + * def _create_record(object mapping, tuple elems): # <<<<<<<<<<<<<< + * # Exposed only for testing purposes. + * + */ + __pyx_tuple__87 = PyTuple_Pack(6, __pyx_n_s_mapping, __pyx_n_s_elems, __pyx_n_s_rec, __pyx_n_s_i, __pyx_n_s_desc, __pyx_n_s_elem); if (unlikely(!__pyx_tuple__87)) __PYX_ERR(27, 511, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__87); + __Pyx_GIVEREF(__pyx_tuple__87); + __pyx_codeobj__88 = (PyObject*)__Pyx_PyCode_New(2, 0, 6, 0, 0, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__87, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_home_travis_build_MagicStack_as, __pyx_n_s_create_record, 511, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__88)) __PYX_ERR(27, 511, __pyx_L1_error) + __Pyx_RefNannyFinishContext(); + return 0; + __pyx_L1_error:; + __Pyx_RefNannyFinishContext(); + return -1; +} + +static int __Pyx_InitGlobals(void) { + if (__Pyx_InitStrings(__pyx_string_tab) < 0) __PYX_ERR(27, 1, __pyx_L1_error); + __pyx_int_0 = PyInt_FromLong(0); if (unlikely(!__pyx_int_0)) __PYX_ERR(27, 1, __pyx_L1_error) + __pyx_int_1 = PyInt_FromLong(1); if (unlikely(!__pyx_int_1)) __PYX_ERR(27, 1, __pyx_L1_error) + __pyx_int_4 = PyInt_FromLong(4); if (unlikely(!__pyx_int_4)) __PYX_ERR(27, 1, __pyx_L1_error) + __pyx_int_6 = PyInt_FromLong(6); if (unlikely(!__pyx_int_6)) __PYX_ERR(27, 1, __pyx_L1_error) + __pyx_int_12 = PyInt_FromLong(12); if (unlikely(!__pyx_int_12)) __PYX_ERR(27, 1, __pyx_L1_error) + __pyx_int_16 = PyInt_FromLong(16); if (unlikely(!__pyx_int_16)) __PYX_ERR(27, 1, __pyx_L1_error) + __pyx_int_17 = PyInt_FromLong(17); if (unlikely(!__pyx_int_17)) __PYX_ERR(27, 1, __pyx_L1_error) + __pyx_int_18 = PyInt_FromLong(18); if (unlikely(!__pyx_int_18)) __PYX_ERR(27, 1, __pyx_L1_error) + __pyx_int_19 = PyInt_FromLong(19); if (unlikely(!__pyx_int_19)) __PYX_ERR(27, 1, __pyx_L1_error) + __pyx_int_20 = PyInt_FromLong(20); if (unlikely(!__pyx_int_20)) __PYX_ERR(27, 1, __pyx_L1_error) + __pyx_int_21 = PyInt_FromLong(21); if (unlikely(!__pyx_int_21)) __PYX_ERR(27, 1, __pyx_L1_error) + __pyx_int_23 = PyInt_FromLong(23); if (unlikely(!__pyx_int_23)) __PYX_ERR(27, 1, __pyx_L1_error) + __pyx_int_24 = PyInt_FromLong(24); if (unlikely(!__pyx_int_24)) __PYX_ERR(27, 1, __pyx_L1_error) + __pyx_int_25 = PyInt_FromLong(25); if (unlikely(!__pyx_int_25)) __PYX_ERR(27, 1, __pyx_L1_error) + __pyx_int_26 = PyInt_FromLong(26); if (unlikely(!__pyx_int_26)) __PYX_ERR(27, 1, __pyx_L1_error) + __pyx_int_27 = PyInt_FromLong(27); if (unlikely(!__pyx_int_27)) __PYX_ERR(27, 1, __pyx_L1_error) + __pyx_int_28 = PyInt_FromLong(28); if (unlikely(!__pyx_int_28)) __PYX_ERR(27, 1, __pyx_L1_error) + __pyx_int_29 = PyInt_FromLong(29); if (unlikely(!__pyx_int_29)) __PYX_ERR(27, 1, __pyx_L1_error) + __pyx_int_31 = PyInt_FromLong(31); if (unlikely(!__pyx_int_31)) __PYX_ERR(27, 1, __pyx_L1_error) + __pyx_int_32 = PyInt_FromLong(32); if (unlikely(!__pyx_int_32)) __PYX_ERR(27, 1, __pyx_L1_error) + __pyx_int_59 = PyInt_FromLong(59); if (unlikely(!__pyx_int_59)) __PYX_ERR(27, 1, __pyx_L1_error) + __pyx_int_114 = PyInt_FromLong(114); if (unlikely(!__pyx_int_114)) __PYX_ERR(27, 1, __pyx_L1_error) + __pyx_int_142 = PyInt_FromLong(142); if (unlikely(!__pyx_int_142)) __PYX_ERR(27, 1, __pyx_L1_error) + __pyx_int_194 = PyInt_FromLong(194); if (unlikely(!__pyx_int_194)) __PYX_ERR(27, 1, __pyx_L1_error) + __pyx_int_210 = PyInt_FromLong(210); if (unlikely(!__pyx_int_210)) __PYX_ERR(27, 1, __pyx_L1_error) + __pyx_int_600 = PyInt_FromLong(600); if (unlikely(!__pyx_int_600)) __PYX_ERR(27, 1, __pyx_L1_error) + __pyx_int_601 = PyInt_FromLong(601); if (unlikely(!__pyx_int_601)) __PYX_ERR(27, 1, __pyx_L1_error) + __pyx_int_602 = PyInt_FromLong(602); if (unlikely(!__pyx_int_602)) __PYX_ERR(27, 1, __pyx_L1_error) + __pyx_int_603 = PyInt_FromLong(603); if (unlikely(!__pyx_int_603)) __PYX_ERR(27, 1, __pyx_L1_error) + __pyx_int_604 = PyInt_FromLong(604); if (unlikely(!__pyx_int_604)) __PYX_ERR(27, 1, __pyx_L1_error) + __pyx_int_628 = PyInt_FromLong(628); if (unlikely(!__pyx_int_628)) __PYX_ERR(27, 1, __pyx_L1_error) + __pyx_int_650 = PyInt_FromLong(650); if (unlikely(!__pyx_int_650)) __PYX_ERR(27, 1, __pyx_L1_error) + __pyx_int_700 = PyInt_FromLong(700); if (unlikely(!__pyx_int_700)) __PYX_ERR(27, 1, __pyx_L1_error) + __pyx_int_701 = PyInt_FromLong(701); if (unlikely(!__pyx_int_701)) __PYX_ERR(27, 1, __pyx_L1_error) + __pyx_int_702 = PyInt_FromLong(702); if (unlikely(!__pyx_int_702)) __PYX_ERR(27, 1, __pyx_L1_error) + __pyx_int_703 = PyInt_FromLong(703); if (unlikely(!__pyx_int_703)) __PYX_ERR(27, 1, __pyx_L1_error) + __pyx_int_704 = PyInt_FromLong(704); if (unlikely(!__pyx_int_704)) __PYX_ERR(27, 1, __pyx_L1_error) + __pyx_int_705 = PyInt_FromLong(705); if (unlikely(!__pyx_int_705)) __PYX_ERR(27, 1, __pyx_L1_error) + __pyx_int_718 = PyInt_FromLong(718); if (unlikely(!__pyx_int_718)) __PYX_ERR(27, 1, __pyx_L1_error) + __pyx_int_790 = PyInt_FromLong(790); if (unlikely(!__pyx_int_790)) __PYX_ERR(27, 1, __pyx_L1_error) + __pyx_int_829 = PyInt_FromLong(829); if (unlikely(!__pyx_int_829)) __PYX_ERR(27, 1, __pyx_L1_error) + __pyx_int_869 = PyInt_FromLong(869); if (unlikely(!__pyx_int_869)) __PYX_ERR(27, 1, __pyx_L1_error) + __pyx_int_1009 = PyInt_FromLong(1009); if (unlikely(!__pyx_int_1009)) __PYX_ERR(27, 1, __pyx_L1_error) + __pyx_int_1028 = PyInt_FromLong(1028); if (unlikely(!__pyx_int_1028)) __PYX_ERR(27, 1, __pyx_L1_error) + __pyx_int_1033 = PyInt_FromLong(1033); if (unlikely(!__pyx_int_1033)) __PYX_ERR(27, 1, __pyx_L1_error) + __pyx_int_1042 = PyInt_FromLong(1042); if (unlikely(!__pyx_int_1042)) __PYX_ERR(27, 1, __pyx_L1_error) + __pyx_int_1043 = PyInt_FromLong(1043); if (unlikely(!__pyx_int_1043)) __PYX_ERR(27, 1, __pyx_L1_error) + __pyx_int_1082 = PyInt_FromLong(1082); if (unlikely(!__pyx_int_1082)) __PYX_ERR(27, 1, __pyx_L1_error) + __pyx_int_1083 = PyInt_FromLong(1083); if (unlikely(!__pyx_int_1083)) __PYX_ERR(27, 1, __pyx_L1_error) + __pyx_int_1114 = PyInt_FromLong(1114); if (unlikely(!__pyx_int_1114)) __PYX_ERR(27, 1, __pyx_L1_error) + __pyx_int_1184 = PyInt_FromLong(1184); if (unlikely(!__pyx_int_1184)) __PYX_ERR(27, 1, __pyx_L1_error) + __pyx_int_1186 = PyInt_FromLong(1186); if (unlikely(!__pyx_int_1186)) __PYX_ERR(27, 1, __pyx_L1_error) + __pyx_int_1266 = PyInt_FromLong(1266); if (unlikely(!__pyx_int_1266)) __PYX_ERR(27, 1, __pyx_L1_error) + __pyx_int_1560 = PyInt_FromLong(1560); if (unlikely(!__pyx_int_1560)) __PYX_ERR(27, 1, __pyx_L1_error) + __pyx_int_1562 = PyInt_FromLong(1562); if (unlikely(!__pyx_int_1562)) __PYX_ERR(27, 1, __pyx_L1_error) + __pyx_int_1700 = PyInt_FromLong(1700); if (unlikely(!__pyx_int_1700)) __PYX_ERR(27, 1, __pyx_L1_error) + __pyx_int_1790 = PyInt_FromLong(1790); if (unlikely(!__pyx_int_1790)) __PYX_ERR(27, 1, __pyx_L1_error) + __pyx_int_2000 = PyInt_FromLong(2000); if (unlikely(!__pyx_int_2000)) __PYX_ERR(27, 1, __pyx_L1_error) + __pyx_int_2202 = PyInt_FromLong(2202); if (unlikely(!__pyx_int_2202)) __PYX_ERR(27, 1, __pyx_L1_error) + __pyx_int_2203 = PyInt_FromLong(2203); if (unlikely(!__pyx_int_2203)) __PYX_ERR(27, 1, __pyx_L1_error) + __pyx_int_2204 = PyInt_FromLong(2204); if (unlikely(!__pyx_int_2204)) __PYX_ERR(27, 1, __pyx_L1_error) + __pyx_int_2205 = PyInt_FromLong(2205); if (unlikely(!__pyx_int_2205)) __PYX_ERR(27, 1, __pyx_L1_error) + __pyx_int_2206 = PyInt_FromLong(2206); if (unlikely(!__pyx_int_2206)) __PYX_ERR(27, 1, __pyx_L1_error) + __pyx_int_2249 = PyInt_FromLong(2249); if (unlikely(!__pyx_int_2249)) __PYX_ERR(27, 1, __pyx_L1_error) + __pyx_int_2275 = PyInt_FromLong(2275); if (unlikely(!__pyx_int_2275)) __PYX_ERR(27, 1, __pyx_L1_error) + __pyx_int_2276 = PyInt_FromLong(2276); if (unlikely(!__pyx_int_2276)) __PYX_ERR(27, 1, __pyx_L1_error) + __pyx_int_2277 = PyInt_FromLong(2277); if (unlikely(!__pyx_int_2277)) __PYX_ERR(27, 1, __pyx_L1_error) + __pyx_int_2278 = PyInt_FromLong(2278); if (unlikely(!__pyx_int_2278)) __PYX_ERR(27, 1, __pyx_L1_error) + __pyx_int_2279 = PyInt_FromLong(2279); if (unlikely(!__pyx_int_2279)) __PYX_ERR(27, 1, __pyx_L1_error) + __pyx_int_2280 = PyInt_FromLong(2280); if (unlikely(!__pyx_int_2280)) __PYX_ERR(27, 1, __pyx_L1_error) + __pyx_int_2281 = PyInt_FromLong(2281); if (unlikely(!__pyx_int_2281)) __PYX_ERR(27, 1, __pyx_L1_error) + __pyx_int_2282 = PyInt_FromLong(2282); if (unlikely(!__pyx_int_2282)) __PYX_ERR(27, 1, __pyx_L1_error) + __pyx_int_2283 = PyInt_FromLong(2283); if (unlikely(!__pyx_int_2283)) __PYX_ERR(27, 1, __pyx_L1_error) + __pyx_int_2776 = PyInt_FromLong(2776); if (unlikely(!__pyx_int_2776)) __PYX_ERR(27, 1, __pyx_L1_error) + __pyx_int_2950 = PyInt_FromLong(2950); if (unlikely(!__pyx_int_2950)) __PYX_ERR(27, 1, __pyx_L1_error) + __pyx_int_2970 = PyInt_FromLong(2970); if (unlikely(!__pyx_int_2970)) __PYX_ERR(27, 1, __pyx_L1_error) + __pyx_int_3115 = PyInt_FromLong(3115); if (unlikely(!__pyx_int_3115)) __PYX_ERR(27, 1, __pyx_L1_error) + __pyx_int_3220 = PyInt_FromLong(3220); if (unlikely(!__pyx_int_3220)) __PYX_ERR(27, 1, __pyx_L1_error) + __pyx_int_3310 = PyInt_FromLong(3310); if (unlikely(!__pyx_int_3310)) __PYX_ERR(27, 1, __pyx_L1_error) + __pyx_int_3500 = PyInt_FromLong(3500); if (unlikely(!__pyx_int_3500)) __PYX_ERR(27, 1, __pyx_L1_error) + __pyx_int_3614 = PyInt_FromLong(3614); if (unlikely(!__pyx_int_3614)) __PYX_ERR(27, 1, __pyx_L1_error) + __pyx_int_3615 = PyInt_FromLong(3615); if (unlikely(!__pyx_int_3615)) __PYX_ERR(27, 1, __pyx_L1_error) + __pyx_int_3642 = PyInt_FromLong(3642); if (unlikely(!__pyx_int_3642)) __PYX_ERR(27, 1, __pyx_L1_error) + __pyx_int_3734 = PyInt_FromLong(3734); if (unlikely(!__pyx_int_3734)) __PYX_ERR(27, 1, __pyx_L1_error) + __pyx_int_3769 = PyInt_FromLong(3769); if (unlikely(!__pyx_int_3769)) __PYX_ERR(27, 1, __pyx_L1_error) + __pyx_int_3802 = PyInt_FromLong(3802); if (unlikely(!__pyx_int_3802)) __PYX_ERR(27, 1, __pyx_L1_error) + __pyx_int_3831 = PyInt_FromLong(3831); if (unlikely(!__pyx_int_3831)) __PYX_ERR(27, 1, __pyx_L1_error) + __pyx_int_3838 = PyInt_FromLong(3838); if (unlikely(!__pyx_int_3838)) __PYX_ERR(27, 1, __pyx_L1_error) + __pyx_int_4089 = PyInt_FromLong(4089); if (unlikely(!__pyx_int_4089)) __PYX_ERR(27, 1, __pyx_L1_error) + __pyx_int_4096 = PyInt_FromLong(4096); if (unlikely(!__pyx_int_4096)) __PYX_ERR(27, 1, __pyx_L1_error) + __pyx_int_9999 = PyInt_FromLong(9999); if (unlikely(!__pyx_int_9999)) __PYX_ERR(27, 1, __pyx_L1_error) + __pyx_int_999999 = PyInt_FromLong(999999L); if (unlikely(!__pyx_int_999999)) __PYX_ERR(27, 1, __pyx_L1_error) + return 0; + __pyx_L1_error:; + return -1; +} + +#if PY_MAJOR_VERSION < 3 +PyMODINIT_FUNC initprotocol(void); /*proto*/ +PyMODINIT_FUNC initprotocol(void) +#else +PyMODINIT_FUNC PyInit_protocol(void); /*proto*/ +PyMODINIT_FUNC PyInit_protocol(void) +#endif +{ + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + long __pyx_t_5; + int __pyx_t_6; + PyObject *__pyx_t_7 = NULL; + static Py_UCS4 __pyx_t_8[5]; + __Pyx_RefNannyDeclarations + #if CYTHON_REFNANNY + __Pyx_RefNanny = __Pyx_RefNannyImportAPI("refnanny"); + if (!__Pyx_RefNanny) { + PyErr_Clear(); + __Pyx_RefNanny = __Pyx_RefNannyImportAPI("Cython.Runtime.refnanny"); + if (!__Pyx_RefNanny) + Py_FatalError("failed to import 'refnanny' module"); + } + #endif + __Pyx_RefNannySetupContext("PyMODINIT_FUNC PyInit_protocol(void)", 0); + if (__Pyx_check_binary_version() < 0) __PYX_ERR(27, 1, __pyx_L1_error) + __pyx_empty_tuple = PyTuple_New(0); if (unlikely(!__pyx_empty_tuple)) __PYX_ERR(27, 1, __pyx_L1_error) + __pyx_empty_bytes = PyBytes_FromStringAndSize("", 0); if (unlikely(!__pyx_empty_bytes)) __PYX_ERR(27, 1, __pyx_L1_error) + __pyx_empty_unicode = PyUnicode_FromStringAndSize("", 0); if (unlikely(!__pyx_empty_unicode)) __PYX_ERR(27, 1, __pyx_L1_error) + #ifdef __Pyx_CyFunction_USED + if (__pyx_CyFunction_init() < 0) __PYX_ERR(27, 1, __pyx_L1_error) + #endif + #ifdef __Pyx_FusedFunction_USED + if (__pyx_FusedFunction_init() < 0) __PYX_ERR(27, 1, __pyx_L1_error) + #endif + #ifdef __Pyx_Coroutine_USED + if (__pyx_Coroutine_init() < 0) __PYX_ERR(27, 1, __pyx_L1_error) + #endif + #ifdef __Pyx_Generator_USED + if (__pyx_Generator_init() < 0) __PYX_ERR(27, 1, __pyx_L1_error) + #endif + #ifdef __Pyx_StopAsyncIteration_USED + if (__pyx_StopAsyncIteration_init() < 0) __PYX_ERR(27, 1, __pyx_L1_error) + #endif + /*--- Library function declarations ---*/ + /*--- Threads initialization code ---*/ + #if defined(__PYX_FORCE_INIT_THREADS) && __PYX_FORCE_INIT_THREADS + #ifdef WITH_THREAD /* Python build with threading support? */ + PyEval_InitThreads(); + #endif + #endif + /*--- Module creation code ---*/ + #if PY_MAJOR_VERSION < 3 + __pyx_m = Py_InitModule4("protocol", __pyx_methods, 0, 0, PYTHON_API_VERSION); Py_XINCREF(__pyx_m); + #else + __pyx_m = PyModule_Create(&__pyx_moduledef); + #endif + if (unlikely(!__pyx_m)) __PYX_ERR(27, 1, __pyx_L1_error) + __pyx_d = PyModule_GetDict(__pyx_m); if (unlikely(!__pyx_d)) __PYX_ERR(27, 1, __pyx_L1_error) + Py_INCREF(__pyx_d); + __pyx_b = PyImport_AddModule(__Pyx_BUILTIN_MODULE_NAME); if (unlikely(!__pyx_b)) __PYX_ERR(27, 1, __pyx_L1_error) + #if CYTHON_COMPILING_IN_PYPY + Py_INCREF(__pyx_b); + #endif + if (PyObject_SetAttrString(__pyx_m, "__builtins__", __pyx_b) < 0) __PYX_ERR(27, 1, __pyx_L1_error); + /*--- Initialize various global constants etc. ---*/ + if (__Pyx_InitGlobals() < 0) __PYX_ERR(27, 1, __pyx_L1_error) + #if PY_MAJOR_VERSION < 3 && (__PYX_DEFAULT_STRING_ENCODING_IS_ASCII || __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT) + if (__Pyx_init_sys_getdefaultencoding_params() < 0) __PYX_ERR(27, 1, __pyx_L1_error) + #endif + if (__pyx_module_is_main_asyncpg__protocol__protocol) { + if (PyObject_SetAttrString(__pyx_m, "__name__", __pyx_n_s_main) < 0) __PYX_ERR(27, 1, __pyx_L1_error) + } + #if PY_MAJOR_VERSION >= 3 + { + PyObject *modules = PyImport_GetModuleDict(); if (unlikely(!modules)) __PYX_ERR(27, 1, __pyx_L1_error) + if (!PyDict_GetItemString(modules, "asyncpg.protocol.protocol")) { + if (unlikely(PyDict_SetItemString(modules, "asyncpg.protocol.protocol", __pyx_m) < 0)) __PYX_ERR(27, 1, __pyx_L1_error) + } + } + #endif + /*--- Builtin init code ---*/ + if (__Pyx_InitCachedBuiltins() < 0) __PYX_ERR(27, 1, __pyx_L1_error) + /*--- Constants init code ---*/ + if (__Pyx_InitCachedConstants() < 0) __PYX_ERR(27, 1, __pyx_L1_error) + /*--- Global init code ---*/ + __pyx_v_7asyncpg_8protocol_8protocol_ARRAY_TYPES = Py_None; Py_INCREF(Py_None); + __pyx_v_7asyncpg_8protocol_8protocol_ENCODINGS_MAP = ((PyObject*)Py_None); Py_INCREF(Py_None); + __pyx_v_7asyncpg_8protocol_8protocol_TYPE_CODECS_CACHE = ((PyObject*)Py_None); Py_INCREF(Py_None); + __pyx_v_7asyncpg_8protocol_8protocol_EXTRA_CODECS = ((PyObject*)Py_None); Py_INCREF(Py_None); + __pyx_v_7asyncpg_8protocol_8protocol_SYNC_MESSAGE = ((PyObject*)Py_None); Py_INCREF(Py_None); + /*--- Variable export code ---*/ + if (__Pyx_ExportVoidPtr(__pyx_n_s_ARRAY_TYPES, (void *)&__pyx_v_7asyncpg_8protocol_8protocol_ARRAY_TYPES, "PyObject *") < 0) __PYX_ERR(27, 1, __pyx_L1_error) + /*--- Function export code ---*/ + /*--- Type init code ---*/ + __pyx_vtabptr_7asyncpg_8protocol_8protocol_Memory = &__pyx_vtable_7asyncpg_8protocol_8protocol_Memory; + __pyx_vtable_7asyncpg_8protocol_8protocol_Memory.as_bytes = (PyObject *(*)(struct __pyx_obj_7asyncpg_8protocol_8protocol_Memory *))__pyx_f_7asyncpg_8protocol_8protocol_6Memory_as_bytes; + __pyx_vtable_7asyncpg_8protocol_8protocol_Memory.new = (struct __pyx_obj_7asyncpg_8protocol_8protocol_Memory *(*)(char *, PyObject *, Py_ssize_t))__pyx_f_7asyncpg_8protocol_8protocol_6Memory_new; + if (PyType_Ready(&__pyx_type_7asyncpg_8protocol_8protocol_Memory) < 0) __PYX_ERR(1, 18, __pyx_L1_error) + __pyx_type_7asyncpg_8protocol_8protocol_Memory.tp_print = 0; + if (__Pyx_SetVtable(__pyx_type_7asyncpg_8protocol_8protocol_Memory.tp_dict, __pyx_vtabptr_7asyncpg_8protocol_8protocol_Memory) < 0) __PYX_ERR(1, 18, __pyx_L1_error) + if (PyObject_SetAttrString(__pyx_m, "Memory", (PyObject *)&__pyx_type_7asyncpg_8protocol_8protocol_Memory) < 0) __PYX_ERR(1, 18, __pyx_L1_error) + __pyx_ptype_7asyncpg_8protocol_8protocol_Memory = &__pyx_type_7asyncpg_8protocol_8protocol_Memory; + __pyx_vtabptr_7asyncpg_8protocol_8protocol_WriteBuffer = &__pyx_vtable_7asyncpg_8protocol_8protocol_WriteBuffer; + __pyx_vtable_7asyncpg_8protocol_8protocol_WriteBuffer._check_readonly = (PyObject *(*)(struct __pyx_obj_7asyncpg_8protocol_8protocol_WriteBuffer *))__pyx_f_7asyncpg_8protocol_8protocol_11WriteBuffer__check_readonly; + __pyx_vtable_7asyncpg_8protocol_8protocol_WriteBuffer.len = (PyObject *(*)(struct __pyx_obj_7asyncpg_8protocol_8protocol_WriteBuffer *))__pyx_f_7asyncpg_8protocol_8protocol_11WriteBuffer_len; + __pyx_vtable_7asyncpg_8protocol_8protocol_WriteBuffer._ensure_alloced = (PyObject *(*)(struct __pyx_obj_7asyncpg_8protocol_8protocol_WriteBuffer *, Py_ssize_t))__pyx_f_7asyncpg_8protocol_8protocol_11WriteBuffer__ensure_alloced; + __pyx_vtable_7asyncpg_8protocol_8protocol_WriteBuffer._reallocate = (PyObject *(*)(struct __pyx_obj_7asyncpg_8protocol_8protocol_WriteBuffer *, Py_ssize_t))__pyx_f_7asyncpg_8protocol_8protocol_11WriteBuffer__reallocate; + __pyx_vtable_7asyncpg_8protocol_8protocol_WriteBuffer.start_message = (PyObject *(*)(struct __pyx_obj_7asyncpg_8protocol_8protocol_WriteBuffer *, char))__pyx_f_7asyncpg_8protocol_8protocol_11WriteBuffer_start_message; + __pyx_vtable_7asyncpg_8protocol_8protocol_WriteBuffer.end_message = (PyObject *(*)(struct __pyx_obj_7asyncpg_8protocol_8protocol_WriteBuffer *))__pyx_f_7asyncpg_8protocol_8protocol_11WriteBuffer_end_message; + __pyx_vtable_7asyncpg_8protocol_8protocol_WriteBuffer.write_buffer = (PyObject *(*)(struct __pyx_obj_7asyncpg_8protocol_8protocol_WriteBuffer *, struct __pyx_obj_7asyncpg_8protocol_8protocol_WriteBuffer *))__pyx_f_7asyncpg_8protocol_8protocol_11WriteBuffer_write_buffer; + __pyx_vtable_7asyncpg_8protocol_8protocol_WriteBuffer.write_byte = (PyObject *(*)(struct __pyx_obj_7asyncpg_8protocol_8protocol_WriteBuffer *, char))__pyx_f_7asyncpg_8protocol_8protocol_11WriteBuffer_write_byte; + __pyx_vtable_7asyncpg_8protocol_8protocol_WriteBuffer.write_bytes = (PyObject *(*)(struct __pyx_obj_7asyncpg_8protocol_8protocol_WriteBuffer *, PyObject *))__pyx_f_7asyncpg_8protocol_8protocol_11WriteBuffer_write_bytes; + __pyx_vtable_7asyncpg_8protocol_8protocol_WriteBuffer.write_bytestring = (PyObject *(*)(struct __pyx_obj_7asyncpg_8protocol_8protocol_WriteBuffer *, PyObject *))__pyx_f_7asyncpg_8protocol_8protocol_11WriteBuffer_write_bytestring; + __pyx_vtable_7asyncpg_8protocol_8protocol_WriteBuffer.write_str = (PyObject *(*)(struct __pyx_obj_7asyncpg_8protocol_8protocol_WriteBuffer *, PyObject *, PyObject *))__pyx_f_7asyncpg_8protocol_8protocol_11WriteBuffer_write_str; + __pyx_vtable_7asyncpg_8protocol_8protocol_WriteBuffer.write_cstr = (PyObject *(*)(struct __pyx_obj_7asyncpg_8protocol_8protocol_WriteBuffer *, char *, Py_ssize_t))__pyx_f_7asyncpg_8protocol_8protocol_11WriteBuffer_write_cstr; + __pyx_vtable_7asyncpg_8protocol_8protocol_WriteBuffer.write_int16 = (PyObject *(*)(struct __pyx_obj_7asyncpg_8protocol_8protocol_WriteBuffer *, int16_t))__pyx_f_7asyncpg_8protocol_8protocol_11WriteBuffer_write_int16; + __pyx_vtable_7asyncpg_8protocol_8protocol_WriteBuffer.write_int32 = (PyObject *(*)(struct __pyx_obj_7asyncpg_8protocol_8protocol_WriteBuffer *, int32_t))__pyx_f_7asyncpg_8protocol_8protocol_11WriteBuffer_write_int32; + __pyx_vtable_7asyncpg_8protocol_8protocol_WriteBuffer.write_int64 = (PyObject *(*)(struct __pyx_obj_7asyncpg_8protocol_8protocol_WriteBuffer *, int64_t))__pyx_f_7asyncpg_8protocol_8protocol_11WriteBuffer_write_int64; + __pyx_vtable_7asyncpg_8protocol_8protocol_WriteBuffer.write_float = (PyObject *(*)(struct __pyx_obj_7asyncpg_8protocol_8protocol_WriteBuffer *, float))__pyx_f_7asyncpg_8protocol_8protocol_11WriteBuffer_write_float; + __pyx_vtable_7asyncpg_8protocol_8protocol_WriteBuffer.write_double = (PyObject *(*)(struct __pyx_obj_7asyncpg_8protocol_8protocol_WriteBuffer *, double))__pyx_f_7asyncpg_8protocol_8protocol_11WriteBuffer_write_double; + __pyx_vtable_7asyncpg_8protocol_8protocol_WriteBuffer.new_message = (struct __pyx_obj_7asyncpg_8protocol_8protocol_WriteBuffer *(*)(char))__pyx_f_7asyncpg_8protocol_8protocol_11WriteBuffer_new_message; + __pyx_vtable_7asyncpg_8protocol_8protocol_WriteBuffer.new = (struct __pyx_obj_7asyncpg_8protocol_8protocol_WriteBuffer *(*)(void))__pyx_f_7asyncpg_8protocol_8protocol_11WriteBuffer_new; + if (PyType_Ready(&__pyx_type_7asyncpg_8protocol_8protocol_WriteBuffer) < 0) __PYX_ERR(1, 36, __pyx_L1_error) + __pyx_type_7asyncpg_8protocol_8protocol_WriteBuffer.tp_print = 0; + if (__Pyx_SetVtable(__pyx_type_7asyncpg_8protocol_8protocol_WriteBuffer.tp_dict, __pyx_vtabptr_7asyncpg_8protocol_8protocol_WriteBuffer) < 0) __PYX_ERR(1, 36, __pyx_L1_error) + if (PyObject_SetAttrString(__pyx_m, "WriteBuffer", (PyObject *)&__pyx_type_7asyncpg_8protocol_8protocol_WriteBuffer) < 0) __PYX_ERR(1, 36, __pyx_L1_error) + __pyx_ptype_7asyncpg_8protocol_8protocol_WriteBuffer = &__pyx_type_7asyncpg_8protocol_8protocol_WriteBuffer; + __pyx_vtabptr_7asyncpg_8protocol_8protocol_ReadBuffer = &__pyx_vtable_7asyncpg_8protocol_8protocol_ReadBuffer; + __pyx_vtable_7asyncpg_8protocol_8protocol_ReadBuffer.feed_data = (PyObject *(*)(struct __pyx_obj_7asyncpg_8protocol_8protocol_ReadBuffer *, PyObject *))__pyx_f_7asyncpg_8protocol_8protocol_10ReadBuffer_feed_data; + __pyx_vtable_7asyncpg_8protocol_8protocol_ReadBuffer._ensure_first_buf = (PyObject *(*)(struct __pyx_obj_7asyncpg_8protocol_8protocol_ReadBuffer *))__pyx_f_7asyncpg_8protocol_8protocol_10ReadBuffer__ensure_first_buf; + __pyx_vtable_7asyncpg_8protocol_8protocol_ReadBuffer._switch_to_next_buf = (PyObject *(*)(struct __pyx_obj_7asyncpg_8protocol_8protocol_ReadBuffer *))__pyx_f_7asyncpg_8protocol_8protocol_10ReadBuffer__switch_to_next_buf; + __pyx_vtable_7asyncpg_8protocol_8protocol_ReadBuffer.read_byte = (PyObject *(*)(struct __pyx_obj_7asyncpg_8protocol_8protocol_ReadBuffer *))__pyx_f_7asyncpg_8protocol_8protocol_10ReadBuffer_read_byte; + __pyx_vtable_7asyncpg_8protocol_8protocol_ReadBuffer._try_read_bytes = (char *(*)(struct __pyx_obj_7asyncpg_8protocol_8protocol_ReadBuffer *, Py_ssize_t))__pyx_f_7asyncpg_8protocol_8protocol_10ReadBuffer__try_read_bytes; + __pyx_vtable_7asyncpg_8protocol_8protocol_ReadBuffer.read = (PyObject *(*)(struct __pyx_obj_7asyncpg_8protocol_8protocol_ReadBuffer *, Py_ssize_t))__pyx_f_7asyncpg_8protocol_8protocol_10ReadBuffer_read; + __pyx_vtable_7asyncpg_8protocol_8protocol_ReadBuffer.read_bytes = (PyObject *(*)(struct __pyx_obj_7asyncpg_8protocol_8protocol_ReadBuffer *, Py_ssize_t))__pyx_f_7asyncpg_8protocol_8protocol_10ReadBuffer_read_bytes; + __pyx_vtable_7asyncpg_8protocol_8protocol_ReadBuffer.read_int32 = (PyObject *(*)(struct __pyx_obj_7asyncpg_8protocol_8protocol_ReadBuffer *))__pyx_f_7asyncpg_8protocol_8protocol_10ReadBuffer_read_int32; + __pyx_vtable_7asyncpg_8protocol_8protocol_ReadBuffer.read_int16 = (PyObject *(*)(struct __pyx_obj_7asyncpg_8protocol_8protocol_ReadBuffer *))__pyx_f_7asyncpg_8protocol_8protocol_10ReadBuffer_read_int16; + __pyx_vtable_7asyncpg_8protocol_8protocol_ReadBuffer.read_cstr = (PyObject *(*)(struct __pyx_obj_7asyncpg_8protocol_8protocol_ReadBuffer *))__pyx_f_7asyncpg_8protocol_8protocol_10ReadBuffer_read_cstr; + __pyx_vtable_7asyncpg_8protocol_8protocol_ReadBuffer.has_message = (int32_t (*)(struct __pyx_obj_7asyncpg_8protocol_8protocol_ReadBuffer *))__pyx_f_7asyncpg_8protocol_8protocol_10ReadBuffer_has_message; + __pyx_vtable_7asyncpg_8protocol_8protocol_ReadBuffer.try_consume_message = (char *(*)(struct __pyx_obj_7asyncpg_8protocol_8protocol_ReadBuffer *, Py_ssize_t *))__pyx_f_7asyncpg_8protocol_8protocol_10ReadBuffer_try_consume_message; + __pyx_vtable_7asyncpg_8protocol_8protocol_ReadBuffer.consume_message = (struct __pyx_obj_7asyncpg_8protocol_8protocol_Memory *(*)(struct __pyx_obj_7asyncpg_8protocol_8protocol_ReadBuffer *))__pyx_f_7asyncpg_8protocol_8protocol_10ReadBuffer_consume_message; + __pyx_vtable_7asyncpg_8protocol_8protocol_ReadBuffer.discard_message = (PyObject *(*)(struct __pyx_obj_7asyncpg_8protocol_8protocol_ReadBuffer *))__pyx_f_7asyncpg_8protocol_8protocol_10ReadBuffer_discard_message; + __pyx_vtable_7asyncpg_8protocol_8protocol_ReadBuffer._discard_message = (PyObject *(*)(struct __pyx_obj_7asyncpg_8protocol_8protocol_ReadBuffer *))__pyx_f_7asyncpg_8protocol_8protocol_10ReadBuffer__discard_message; + __pyx_vtable_7asyncpg_8protocol_8protocol_ReadBuffer.get_message_type = (char (*)(struct __pyx_obj_7asyncpg_8protocol_8protocol_ReadBuffer *))__pyx_f_7asyncpg_8protocol_8protocol_10ReadBuffer_get_message_type; + __pyx_vtable_7asyncpg_8protocol_8protocol_ReadBuffer.get_message_length = (int32_t (*)(struct __pyx_obj_7asyncpg_8protocol_8protocol_ReadBuffer *))__pyx_f_7asyncpg_8protocol_8protocol_10ReadBuffer_get_message_length; + __pyx_vtable_7asyncpg_8protocol_8protocol_ReadBuffer.new_message_parser = (struct __pyx_obj_7asyncpg_8protocol_8protocol_ReadBuffer *(*)(PyObject *))__pyx_f_7asyncpg_8protocol_8protocol_10ReadBuffer_new_message_parser; + if (PyType_Ready(&__pyx_type_7asyncpg_8protocol_8protocol_ReadBuffer) < 0) __PYX_ERR(1, 231, __pyx_L1_error) + __pyx_type_7asyncpg_8protocol_8protocol_ReadBuffer.tp_print = 0; + if (__Pyx_SetVtable(__pyx_type_7asyncpg_8protocol_8protocol_ReadBuffer.tp_dict, __pyx_vtabptr_7asyncpg_8protocol_8protocol_ReadBuffer) < 0) __PYX_ERR(1, 231, __pyx_L1_error) + if (PyObject_SetAttrString(__pyx_m, "ReadBuffer", (PyObject *)&__pyx_type_7asyncpg_8protocol_8protocol_ReadBuffer) < 0) __PYX_ERR(1, 231, __pyx_L1_error) + __pyx_ptype_7asyncpg_8protocol_8protocol_ReadBuffer = &__pyx_type_7asyncpg_8protocol_8protocol_ReadBuffer; + __pyx_vtabptr_7asyncpg_8protocol_8protocol_FastReadBuffer = &__pyx_vtable_7asyncpg_8protocol_8protocol_FastReadBuffer; + __pyx_vtable_7asyncpg_8protocol_8protocol_FastReadBuffer.read = (char const *(*)(struct __pyx_obj_7asyncpg_8protocol_8protocol_FastReadBuffer *, Py_ssize_t))__pyx_f_7asyncpg_8protocol_8protocol_14FastReadBuffer_read; + __pyx_vtable_7asyncpg_8protocol_8protocol_FastReadBuffer.read_all = (char const *(*)(struct __pyx_obj_7asyncpg_8protocol_8protocol_FastReadBuffer *))__pyx_f_7asyncpg_8protocol_8protocol_14FastReadBuffer_read_all; + __pyx_vtable_7asyncpg_8protocol_8protocol_FastReadBuffer.slice_from = (struct __pyx_obj_7asyncpg_8protocol_8protocol_FastReadBuffer *(*)(struct __pyx_obj_7asyncpg_8protocol_8protocol_FastReadBuffer *, struct __pyx_obj_7asyncpg_8protocol_8protocol_FastReadBuffer *, Py_ssize_t))__pyx_f_7asyncpg_8protocol_8protocol_14FastReadBuffer_slice_from; + __pyx_vtable_7asyncpg_8protocol_8protocol_FastReadBuffer._raise_ins_err = (PyObject *(*)(struct __pyx_obj_7asyncpg_8protocol_8protocol_FastReadBuffer *, Py_ssize_t, Py_ssize_t))__pyx_f_7asyncpg_8protocol_8protocol_14FastReadBuffer__raise_ins_err; + __pyx_vtable_7asyncpg_8protocol_8protocol_FastReadBuffer.new = (struct __pyx_obj_7asyncpg_8protocol_8protocol_FastReadBuffer *(*)(void))__pyx_f_7asyncpg_8protocol_8protocol_14FastReadBuffer_new; + if (PyType_Ready(&__pyx_type_7asyncpg_8protocol_8protocol_FastReadBuffer) < 0) __PYX_ERR(1, 582, __pyx_L1_error) + __pyx_type_7asyncpg_8protocol_8protocol_FastReadBuffer.tp_print = 0; + if (__Pyx_SetVtable(__pyx_type_7asyncpg_8protocol_8protocol_FastReadBuffer.tp_dict, __pyx_vtabptr_7asyncpg_8protocol_8protocol_FastReadBuffer) < 0) __PYX_ERR(1, 582, __pyx_L1_error) + if (PyObject_SetAttrString(__pyx_m, "FastReadBuffer", (PyObject *)&__pyx_type_7asyncpg_8protocol_8protocol_FastReadBuffer) < 0) __PYX_ERR(1, 582, __pyx_L1_error) + __pyx_ptype_7asyncpg_8protocol_8protocol_FastReadBuffer = &__pyx_type_7asyncpg_8protocol_8protocol_FastReadBuffer; + __pyx_vtabptr_7asyncpg_8protocol_8protocol_Codec = &__pyx_vtable_7asyncpg_8protocol_8protocol_Codec; + __pyx_vtable_7asyncpg_8protocol_8protocol_Codec.init = (PyObject *(*)(struct __pyx_obj_7asyncpg_8protocol_8protocol_Codec *, PyObject *, PyObject *, PyObject *, enum __pyx_t_7asyncpg_8protocol_8protocol_CodecType, enum __pyx_t_7asyncpg_8protocol_8protocol_CodecFormat, __pyx_t_7asyncpg_8protocol_8protocol_encode_func, __pyx_t_7asyncpg_8protocol_8protocol_decode_func, PyObject *, PyObject *, struct __pyx_obj_7asyncpg_8protocol_8protocol_Codec *, PyObject *, PyObject *, PyObject *, Py_UCS4))__pyx_f_7asyncpg_8protocol_8protocol_5Codec_init; + __pyx_vtable_7asyncpg_8protocol_8protocol_Codec.encode_scalar = (PyObject *(*)(struct __pyx_obj_7asyncpg_8protocol_8protocol_Codec *, struct __pyx_obj_7asyncpg_8protocol_8protocol_ConnectionSettings *, struct __pyx_obj_7asyncpg_8protocol_8protocol_WriteBuffer *, PyObject *))__pyx_f_7asyncpg_8protocol_8protocol_5Codec_encode_scalar; + __pyx_vtable_7asyncpg_8protocol_8protocol_Codec.encode_array = (PyObject *(*)(struct __pyx_obj_7asyncpg_8protocol_8protocol_Codec *, struct __pyx_obj_7asyncpg_8protocol_8protocol_ConnectionSettings *, struct __pyx_obj_7asyncpg_8protocol_8protocol_WriteBuffer *, PyObject *))__pyx_f_7asyncpg_8protocol_8protocol_5Codec_encode_array; + __pyx_vtable_7asyncpg_8protocol_8protocol_Codec.encode_range = (PyObject *(*)(struct __pyx_obj_7asyncpg_8protocol_8protocol_Codec *, struct __pyx_obj_7asyncpg_8protocol_8protocol_ConnectionSettings *, struct __pyx_obj_7asyncpg_8protocol_8protocol_WriteBuffer *, PyObject *))__pyx_f_7asyncpg_8protocol_8protocol_5Codec_encode_range; + __pyx_vtable_7asyncpg_8protocol_8protocol_Codec.encode_composite = (PyObject *(*)(struct __pyx_obj_7asyncpg_8protocol_8protocol_Codec *, struct __pyx_obj_7asyncpg_8protocol_8protocol_ConnectionSettings *, struct __pyx_obj_7asyncpg_8protocol_8protocol_WriteBuffer *, PyObject *))__pyx_f_7asyncpg_8protocol_8protocol_5Codec_encode_composite; + __pyx_vtable_7asyncpg_8protocol_8protocol_Codec.encode_in_python = (PyObject *(*)(struct __pyx_obj_7asyncpg_8protocol_8protocol_Codec *, struct __pyx_obj_7asyncpg_8protocol_8protocol_ConnectionSettings *, struct __pyx_obj_7asyncpg_8protocol_8protocol_WriteBuffer *, PyObject *))__pyx_f_7asyncpg_8protocol_8protocol_5Codec_encode_in_python; + __pyx_vtable_7asyncpg_8protocol_8protocol_Codec.decode_scalar = (PyObject *(*)(struct __pyx_obj_7asyncpg_8protocol_8protocol_Codec *, struct __pyx_obj_7asyncpg_8protocol_8protocol_ConnectionSettings *, struct __pyx_obj_7asyncpg_8protocol_8protocol_FastReadBuffer *))__pyx_f_7asyncpg_8protocol_8protocol_5Codec_decode_scalar; + __pyx_vtable_7asyncpg_8protocol_8protocol_Codec.decode_array = (PyObject *(*)(struct __pyx_obj_7asyncpg_8protocol_8protocol_Codec *, struct __pyx_obj_7asyncpg_8protocol_8protocol_ConnectionSettings *, struct __pyx_obj_7asyncpg_8protocol_8protocol_FastReadBuffer *))__pyx_f_7asyncpg_8protocol_8protocol_5Codec_decode_array; + __pyx_vtable_7asyncpg_8protocol_8protocol_Codec.decode_array_text = (PyObject *(*)(struct __pyx_obj_7asyncpg_8protocol_8protocol_Codec *, struct __pyx_obj_7asyncpg_8protocol_8protocol_ConnectionSettings *, struct __pyx_obj_7asyncpg_8protocol_8protocol_FastReadBuffer *))__pyx_f_7asyncpg_8protocol_8protocol_5Codec_decode_array_text; + __pyx_vtable_7asyncpg_8protocol_8protocol_Codec.decode_range = (PyObject *(*)(struct __pyx_obj_7asyncpg_8protocol_8protocol_Codec *, struct __pyx_obj_7asyncpg_8protocol_8protocol_ConnectionSettings *, struct __pyx_obj_7asyncpg_8protocol_8protocol_FastReadBuffer *))__pyx_f_7asyncpg_8protocol_8protocol_5Codec_decode_range; + __pyx_vtable_7asyncpg_8protocol_8protocol_Codec.decode_composite = (PyObject *(*)(struct __pyx_obj_7asyncpg_8protocol_8protocol_Codec *, struct __pyx_obj_7asyncpg_8protocol_8protocol_ConnectionSettings *, struct __pyx_obj_7asyncpg_8protocol_8protocol_FastReadBuffer *))__pyx_f_7asyncpg_8protocol_8protocol_5Codec_decode_composite; + __pyx_vtable_7asyncpg_8protocol_8protocol_Codec.decode_in_python = (PyObject *(*)(struct __pyx_obj_7asyncpg_8protocol_8protocol_Codec *, struct __pyx_obj_7asyncpg_8protocol_8protocol_ConnectionSettings *, struct __pyx_obj_7asyncpg_8protocol_8protocol_FastReadBuffer *))__pyx_f_7asyncpg_8protocol_8protocol_5Codec_decode_in_python; + __pyx_vtable_7asyncpg_8protocol_8protocol_Codec.encode = (PyObject *(*)(struct __pyx_obj_7asyncpg_8protocol_8protocol_Codec *, struct __pyx_obj_7asyncpg_8protocol_8protocol_ConnectionSettings *, struct __pyx_obj_7asyncpg_8protocol_8protocol_WriteBuffer *, PyObject *))__pyx_f_7asyncpg_8protocol_8protocol_5Codec_encode; + __pyx_vtable_7asyncpg_8protocol_8protocol_Codec.decode = (PyObject *(*)(struct __pyx_obj_7asyncpg_8protocol_8protocol_Codec *, struct __pyx_obj_7asyncpg_8protocol_8protocol_ConnectionSettings *, struct __pyx_obj_7asyncpg_8protocol_8protocol_FastReadBuffer *))__pyx_f_7asyncpg_8protocol_8protocol_5Codec_decode; + __pyx_vtable_7asyncpg_8protocol_8protocol_Codec.has_encoder = (PyObject *(*)(struct __pyx_obj_7asyncpg_8protocol_8protocol_Codec *))__pyx_f_7asyncpg_8protocol_8protocol_5Codec_has_encoder; + __pyx_vtable_7asyncpg_8protocol_8protocol_Codec.has_decoder = (PyObject *(*)(struct __pyx_obj_7asyncpg_8protocol_8protocol_Codec *))__pyx_f_7asyncpg_8protocol_8protocol_5Codec_has_decoder; + __pyx_vtable_7asyncpg_8protocol_8protocol_Codec.is_binary = (PyObject *(*)(struct __pyx_obj_7asyncpg_8protocol_8protocol_Codec *))__pyx_f_7asyncpg_8protocol_8protocol_5Codec_is_binary; + __pyx_vtable_7asyncpg_8protocol_8protocol_Codec.copy = (struct __pyx_obj_7asyncpg_8protocol_8protocol_Codec *(*)(struct __pyx_obj_7asyncpg_8protocol_8protocol_Codec *))__pyx_f_7asyncpg_8protocol_8protocol_5Codec_copy; + __pyx_vtable_7asyncpg_8protocol_8protocol_Codec.new_array_codec = (struct __pyx_obj_7asyncpg_8protocol_8protocol_Codec *(*)(uint32_t, PyObject *, PyObject *, struct __pyx_obj_7asyncpg_8protocol_8protocol_Codec *, Py_UCS4))__pyx_f_7asyncpg_8protocol_8protocol_5Codec_new_array_codec; + __pyx_vtable_7asyncpg_8protocol_8protocol_Codec.new_range_codec = (struct __pyx_obj_7asyncpg_8protocol_8protocol_Codec *(*)(uint32_t, PyObject *, PyObject *, struct __pyx_obj_7asyncpg_8protocol_8protocol_Codec *))__pyx_f_7asyncpg_8protocol_8protocol_5Codec_new_range_codec; + __pyx_vtable_7asyncpg_8protocol_8protocol_Codec.new_composite_codec = (struct __pyx_obj_7asyncpg_8protocol_8protocol_Codec *(*)(uint32_t, PyObject *, PyObject *, PyObject *, PyObject *, PyObject *))__pyx_f_7asyncpg_8protocol_8protocol_5Codec_new_composite_codec; + __pyx_vtable_7asyncpg_8protocol_8protocol_Codec.new_python_codec = (struct __pyx_obj_7asyncpg_8protocol_8protocol_Codec *(*)(uint32_t, PyObject *, PyObject *, PyObject *, PyObject *, PyObject *, enum __pyx_t_7asyncpg_8protocol_8protocol_CodecFormat))__pyx_f_7asyncpg_8protocol_8protocol_5Codec_new_python_codec; + if (PyType_Ready(&__pyx_type_7asyncpg_8protocol_8protocol_Codec) < 0) __PYX_ERR(2, 15, __pyx_L1_error) + __pyx_type_7asyncpg_8protocol_8protocol_Codec.tp_print = 0; + if (__Pyx_SetVtable(__pyx_type_7asyncpg_8protocol_8protocol_Codec.tp_dict, __pyx_vtabptr_7asyncpg_8protocol_8protocol_Codec) < 0) __PYX_ERR(2, 15, __pyx_L1_error) + if (PyObject_SetAttrString(__pyx_m, "Codec", (PyObject *)&__pyx_type_7asyncpg_8protocol_8protocol_Codec) < 0) __PYX_ERR(2, 15, __pyx_L1_error) + __pyx_ptype_7asyncpg_8protocol_8protocol_Codec = &__pyx_type_7asyncpg_8protocol_8protocol_Codec; + __pyx_vtabptr_7asyncpg_8protocol_8protocol_DataCodecConfig = &__pyx_vtable_7asyncpg_8protocol_8protocol_DataCodecConfig; + __pyx_vtable_7asyncpg_8protocol_8protocol_DataCodecConfig.get_codec = (struct __pyx_obj_7asyncpg_8protocol_8protocol_Codec *(*)(struct __pyx_obj_7asyncpg_8protocol_8protocol_DataCodecConfig *, uint32_t, enum __pyx_t_7asyncpg_8protocol_8protocol_CodecFormat))__pyx_f_7asyncpg_8protocol_8protocol_15DataCodecConfig_get_codec; + if (PyType_Ready(&__pyx_type_7asyncpg_8protocol_8protocol_DataCodecConfig) < 0) __PYX_ERR(2, 318, __pyx_L1_error) + __pyx_type_7asyncpg_8protocol_8protocol_DataCodecConfig.tp_print = 0; + if (__Pyx_SetVtable(__pyx_type_7asyncpg_8protocol_8protocol_DataCodecConfig.tp_dict, __pyx_vtabptr_7asyncpg_8protocol_8protocol_DataCodecConfig) < 0) __PYX_ERR(2, 318, __pyx_L1_error) + if (PyObject_SetAttrString(__pyx_m, "DataCodecConfig", (PyObject *)&__pyx_type_7asyncpg_8protocol_8protocol_DataCodecConfig) < 0) __PYX_ERR(2, 318, __pyx_L1_error) + __pyx_ptype_7asyncpg_8protocol_8protocol_DataCodecConfig = &__pyx_type_7asyncpg_8protocol_8protocol_DataCodecConfig; + __pyx_vtabptr_7asyncpg_8protocol_8protocol_ConnectionSettings = &__pyx_vtable_7asyncpg_8protocol_8protocol_ConnectionSettings; + __pyx_vtable_7asyncpg_8protocol_8protocol_ConnectionSettings.add_setting = (PyObject *(*)(struct __pyx_obj_7asyncpg_8protocol_8protocol_ConnectionSettings *, PyObject *, PyObject *))__pyx_f_7asyncpg_8protocol_8protocol_18ConnectionSettings_add_setting; + __pyx_vtable_7asyncpg_8protocol_8protocol_ConnectionSettings.is_encoding_utf8 = (PyObject *(*)(struct __pyx_obj_7asyncpg_8protocol_8protocol_ConnectionSettings *))__pyx_f_7asyncpg_8protocol_8protocol_18ConnectionSettings_is_encoding_utf8; + __pyx_vtable_7asyncpg_8protocol_8protocol_ConnectionSettings.get_text_codec = (PyObject *(*)(struct __pyx_obj_7asyncpg_8protocol_8protocol_ConnectionSettings *, int __pyx_skip_dispatch))__pyx_f_7asyncpg_8protocol_8protocol_18ConnectionSettings_get_text_codec; + __pyx_vtable_7asyncpg_8protocol_8protocol_ConnectionSettings.register_data_types = (PyObject *(*)(struct __pyx_obj_7asyncpg_8protocol_8protocol_ConnectionSettings *, PyObject *, int __pyx_skip_dispatch))__pyx_f_7asyncpg_8protocol_8protocol_18ConnectionSettings_register_data_types; + __pyx_vtable_7asyncpg_8protocol_8protocol_ConnectionSettings.add_python_codec = (PyObject *(*)(struct __pyx_obj_7asyncpg_8protocol_8protocol_ConnectionSettings *, PyObject *, PyObject *, PyObject *, PyObject *, PyObject *, PyObject *, PyObject *, int __pyx_skip_dispatch))__pyx_f_7asyncpg_8protocol_8protocol_18ConnectionSettings_add_python_codec; + __pyx_vtable_7asyncpg_8protocol_8protocol_ConnectionSettings.set_builtin_type_codec = (PyObject *(*)(struct __pyx_obj_7asyncpg_8protocol_8protocol_ConnectionSettings *, PyObject *, PyObject *, PyObject *, PyObject *, PyObject *, int __pyx_skip_dispatch))__pyx_f_7asyncpg_8protocol_8protocol_18ConnectionSettings_set_builtin_type_codec; + __pyx_vtable_7asyncpg_8protocol_8protocol_ConnectionSettings.get_data_codec = (struct __pyx_obj_7asyncpg_8protocol_8protocol_Codec *(*)(struct __pyx_obj_7asyncpg_8protocol_8protocol_ConnectionSettings *, uint32_t, int __pyx_skip_dispatch, struct __pyx_opt_args_7asyncpg_8protocol_8protocol_18ConnectionSettings_get_data_codec *__pyx_optional_args))__pyx_f_7asyncpg_8protocol_8protocol_18ConnectionSettings_get_data_codec; + if (PyType_Ready(&__pyx_type_7asyncpg_8protocol_8protocol_ConnectionSettings) < 0) __PYX_ERR(0, 9, __pyx_L1_error) + __pyx_type_7asyncpg_8protocol_8protocol_ConnectionSettings.tp_print = 0; + if (__Pyx_SetVtable(__pyx_type_7asyncpg_8protocol_8protocol_ConnectionSettings.tp_dict, __pyx_vtabptr_7asyncpg_8protocol_8protocol_ConnectionSettings) < 0) __PYX_ERR(0, 9, __pyx_L1_error) + if (PyObject_SetAttrString(__pyx_m, "ConnectionSettings", (PyObject *)&__pyx_type_7asyncpg_8protocol_8protocol_ConnectionSettings) < 0) __PYX_ERR(0, 9, __pyx_L1_error) + __pyx_ptype_7asyncpg_8protocol_8protocol_ConnectionSettings = &__pyx_type_7asyncpg_8protocol_8protocol_ConnectionSettings; + __pyx_vtabptr_7asyncpg_8protocol_8protocol_CoreProtocol = &__pyx_vtable_7asyncpg_8protocol_8protocol_CoreProtocol; + __pyx_vtable_7asyncpg_8protocol_8protocol_CoreProtocol._process__auth = (PyObject *(*)(struct __pyx_obj_7asyncpg_8protocol_8protocol_CoreProtocol *, char))__pyx_f_7asyncpg_8protocol_8protocol_12CoreProtocol__process__auth; + __pyx_vtable_7asyncpg_8protocol_8protocol_CoreProtocol._process__prepare = (PyObject *(*)(struct __pyx_obj_7asyncpg_8protocol_8protocol_CoreProtocol *, char))__pyx_f_7asyncpg_8protocol_8protocol_12CoreProtocol__process__prepare; + __pyx_vtable_7asyncpg_8protocol_8protocol_CoreProtocol._process__bind_execute = (PyObject *(*)(struct __pyx_obj_7asyncpg_8protocol_8protocol_CoreProtocol *, char))__pyx_f_7asyncpg_8protocol_8protocol_12CoreProtocol__process__bind_execute; + __pyx_vtable_7asyncpg_8protocol_8protocol_CoreProtocol._process__bind_execute_many = (PyObject *(*)(struct __pyx_obj_7asyncpg_8protocol_8protocol_CoreProtocol *, char))__pyx_f_7asyncpg_8protocol_8protocol_12CoreProtocol__process__bind_execute_many; + __pyx_vtable_7asyncpg_8protocol_8protocol_CoreProtocol._process__close_stmt_portal = (PyObject *(*)(struct __pyx_obj_7asyncpg_8protocol_8protocol_CoreProtocol *, char))__pyx_f_7asyncpg_8protocol_8protocol_12CoreProtocol__process__close_stmt_portal; + __pyx_vtable_7asyncpg_8protocol_8protocol_CoreProtocol._process__simple_query = (PyObject *(*)(struct __pyx_obj_7asyncpg_8protocol_8protocol_CoreProtocol *, char))__pyx_f_7asyncpg_8protocol_8protocol_12CoreProtocol__process__simple_query; + __pyx_vtable_7asyncpg_8protocol_8protocol_CoreProtocol._process__bind = (PyObject *(*)(struct __pyx_obj_7asyncpg_8protocol_8protocol_CoreProtocol *, char))__pyx_f_7asyncpg_8protocol_8protocol_12CoreProtocol__process__bind; + __pyx_vtable_7asyncpg_8protocol_8protocol_CoreProtocol._parse_msg_authentication = (PyObject *(*)(struct __pyx_obj_7asyncpg_8protocol_8protocol_CoreProtocol *))__pyx_f_7asyncpg_8protocol_8protocol_12CoreProtocol__parse_msg_authentication; + __pyx_vtable_7asyncpg_8protocol_8protocol_CoreProtocol._parse_msg_parameter_status = (PyObject *(*)(struct __pyx_obj_7asyncpg_8protocol_8protocol_CoreProtocol *))__pyx_f_7asyncpg_8protocol_8protocol_12CoreProtocol__parse_msg_parameter_status; + __pyx_vtable_7asyncpg_8protocol_8protocol_CoreProtocol._parse_msg_notification = (PyObject *(*)(struct __pyx_obj_7asyncpg_8protocol_8protocol_CoreProtocol *))__pyx_f_7asyncpg_8protocol_8protocol_12CoreProtocol__parse_msg_notification; + __pyx_vtable_7asyncpg_8protocol_8protocol_CoreProtocol._parse_msg_backend_key_data = (PyObject *(*)(struct __pyx_obj_7asyncpg_8protocol_8protocol_CoreProtocol *))__pyx_f_7asyncpg_8protocol_8protocol_12CoreProtocol__parse_msg_backend_key_data; + __pyx_vtable_7asyncpg_8protocol_8protocol_CoreProtocol._parse_msg_ready_for_query = (PyObject *(*)(struct __pyx_obj_7asyncpg_8protocol_8protocol_CoreProtocol *))__pyx_f_7asyncpg_8protocol_8protocol_12CoreProtocol__parse_msg_ready_for_query; + __pyx_vtable_7asyncpg_8protocol_8protocol_CoreProtocol._parse_data_msgs = (PyObject *(*)(struct __pyx_obj_7asyncpg_8protocol_8protocol_CoreProtocol *))__pyx_f_7asyncpg_8protocol_8protocol_12CoreProtocol__parse_data_msgs; + __pyx_vtable_7asyncpg_8protocol_8protocol_CoreProtocol._parse_msg_error_response = (PyObject *(*)(struct __pyx_obj_7asyncpg_8protocol_8protocol_CoreProtocol *, PyObject *))__pyx_f_7asyncpg_8protocol_8protocol_12CoreProtocol__parse_msg_error_response; + __pyx_vtable_7asyncpg_8protocol_8protocol_CoreProtocol._parse_msg_command_complete = (PyObject *(*)(struct __pyx_obj_7asyncpg_8protocol_8protocol_CoreProtocol *))__pyx_f_7asyncpg_8protocol_8protocol_12CoreProtocol__parse_msg_command_complete; + __pyx_vtable_7asyncpg_8protocol_8protocol_CoreProtocol._auth_password_message_cleartext = (PyObject *(*)(struct __pyx_obj_7asyncpg_8protocol_8protocol_CoreProtocol *))__pyx_f_7asyncpg_8protocol_8protocol_12CoreProtocol__auth_password_message_cleartext; + __pyx_vtable_7asyncpg_8protocol_8protocol_CoreProtocol._auth_password_message_md5 = (PyObject *(*)(struct __pyx_obj_7asyncpg_8protocol_8protocol_CoreProtocol *, PyObject *))__pyx_f_7asyncpg_8protocol_8protocol_12CoreProtocol__auth_password_message_md5; + __pyx_vtable_7asyncpg_8protocol_8protocol_CoreProtocol._write = (PyObject *(*)(struct __pyx_obj_7asyncpg_8protocol_8protocol_CoreProtocol *, PyObject *))__pyx_f_7asyncpg_8protocol_8protocol_12CoreProtocol__write; + __pyx_vtable_7asyncpg_8protocol_8protocol_CoreProtocol._write_sync_message = (PyObject *(*)(struct __pyx_obj_7asyncpg_8protocol_8protocol_CoreProtocol *))__pyx_f_7asyncpg_8protocol_8protocol_12CoreProtocol__write_sync_message; + __pyx_vtable_7asyncpg_8protocol_8protocol_CoreProtocol._read_server_messages = (PyObject *(*)(struct __pyx_obj_7asyncpg_8protocol_8protocol_CoreProtocol *))__pyx_f_7asyncpg_8protocol_8protocol_12CoreProtocol__read_server_messages; + __pyx_vtable_7asyncpg_8protocol_8protocol_CoreProtocol._push_result = (PyObject *(*)(struct __pyx_obj_7asyncpg_8protocol_8protocol_CoreProtocol *))__pyx_f_7asyncpg_8protocol_8protocol_12CoreProtocol__push_result; + __pyx_vtable_7asyncpg_8protocol_8protocol_CoreProtocol._reset_result = (PyObject *(*)(struct __pyx_obj_7asyncpg_8protocol_8protocol_CoreProtocol *))__pyx_f_7asyncpg_8protocol_8protocol_12CoreProtocol__reset_result; + __pyx_vtable_7asyncpg_8protocol_8protocol_CoreProtocol._set_state = (PyObject *(*)(struct __pyx_obj_7asyncpg_8protocol_8protocol_CoreProtocol *, enum __pyx_t_7asyncpg_8protocol_8protocol_ProtocolState))__pyx_f_7asyncpg_8protocol_8protocol_12CoreProtocol__set_state; + __pyx_vtable_7asyncpg_8protocol_8protocol_CoreProtocol._ensure_connected = (PyObject *(*)(struct __pyx_obj_7asyncpg_8protocol_8protocol_CoreProtocol *))__pyx_f_7asyncpg_8protocol_8protocol_12CoreProtocol__ensure_connected; + __pyx_vtable_7asyncpg_8protocol_8protocol_CoreProtocol._build_bind_message = (struct __pyx_obj_7asyncpg_8protocol_8protocol_WriteBuffer *(*)(struct __pyx_obj_7asyncpg_8protocol_8protocol_CoreProtocol *, PyObject *, PyObject *, struct __pyx_obj_7asyncpg_8protocol_8protocol_WriteBuffer *))__pyx_f_7asyncpg_8protocol_8protocol_12CoreProtocol__build_bind_message; + __pyx_vtable_7asyncpg_8protocol_8protocol_CoreProtocol._connect = (PyObject *(*)(struct __pyx_obj_7asyncpg_8protocol_8protocol_CoreProtocol *))__pyx_f_7asyncpg_8protocol_8protocol_12CoreProtocol__connect; + __pyx_vtable_7asyncpg_8protocol_8protocol_CoreProtocol._prepare = (PyObject *(*)(struct __pyx_obj_7asyncpg_8protocol_8protocol_CoreProtocol *, PyObject *, PyObject *))__pyx_f_7asyncpg_8protocol_8protocol_12CoreProtocol__prepare; + __pyx_vtable_7asyncpg_8protocol_8protocol_CoreProtocol._send_bind_message = (PyObject *(*)(struct __pyx_obj_7asyncpg_8protocol_8protocol_CoreProtocol *, PyObject *, PyObject *, struct __pyx_obj_7asyncpg_8protocol_8protocol_WriteBuffer *, int32_t))__pyx_f_7asyncpg_8protocol_8protocol_12CoreProtocol__send_bind_message; + __pyx_vtable_7asyncpg_8protocol_8protocol_CoreProtocol._bind_execute = (PyObject *(*)(struct __pyx_obj_7asyncpg_8protocol_8protocol_CoreProtocol *, PyObject *, PyObject *, struct __pyx_obj_7asyncpg_8protocol_8protocol_WriteBuffer *, int32_t))__pyx_f_7asyncpg_8protocol_8protocol_12CoreProtocol__bind_execute; + __pyx_vtable_7asyncpg_8protocol_8protocol_CoreProtocol._bind_execute_many = (PyObject *(*)(struct __pyx_obj_7asyncpg_8protocol_8protocol_CoreProtocol *, PyObject *, PyObject *, PyObject *))__pyx_f_7asyncpg_8protocol_8protocol_12CoreProtocol__bind_execute_many; + __pyx_vtable_7asyncpg_8protocol_8protocol_CoreProtocol._bind = (PyObject *(*)(struct __pyx_obj_7asyncpg_8protocol_8protocol_CoreProtocol *, PyObject *, PyObject *, struct __pyx_obj_7asyncpg_8protocol_8protocol_WriteBuffer *))__pyx_f_7asyncpg_8protocol_8protocol_12CoreProtocol__bind; + __pyx_vtable_7asyncpg_8protocol_8protocol_CoreProtocol._execute = (PyObject *(*)(struct __pyx_obj_7asyncpg_8protocol_8protocol_CoreProtocol *, PyObject *, int32_t))__pyx_f_7asyncpg_8protocol_8protocol_12CoreProtocol__execute; + __pyx_vtable_7asyncpg_8protocol_8protocol_CoreProtocol._close = (PyObject *(*)(struct __pyx_obj_7asyncpg_8protocol_8protocol_CoreProtocol *, PyObject *, int))__pyx_f_7asyncpg_8protocol_8protocol_12CoreProtocol__close; + __pyx_vtable_7asyncpg_8protocol_8protocol_CoreProtocol._simple_query = (PyObject *(*)(struct __pyx_obj_7asyncpg_8protocol_8protocol_CoreProtocol *, PyObject *))__pyx_f_7asyncpg_8protocol_8protocol_12CoreProtocol__simple_query; + __pyx_vtable_7asyncpg_8protocol_8protocol_CoreProtocol._terminate = (PyObject *(*)(struct __pyx_obj_7asyncpg_8protocol_8protocol_CoreProtocol *))__pyx_f_7asyncpg_8protocol_8protocol_12CoreProtocol__terminate; + __pyx_vtable_7asyncpg_8protocol_8protocol_CoreProtocol._decode_row = (PyObject *(*)(struct __pyx_obj_7asyncpg_8protocol_8protocol_CoreProtocol *, char const *, Py_ssize_t))__pyx_f_7asyncpg_8protocol_8protocol_12CoreProtocol__decode_row; + __pyx_vtable_7asyncpg_8protocol_8protocol_CoreProtocol._on_result = (PyObject *(*)(struct __pyx_obj_7asyncpg_8protocol_8protocol_CoreProtocol *))__pyx_f_7asyncpg_8protocol_8protocol_12CoreProtocol__on_result; + __pyx_vtable_7asyncpg_8protocol_8protocol_CoreProtocol._on_notification = (PyObject *(*)(struct __pyx_obj_7asyncpg_8protocol_8protocol_CoreProtocol *, PyObject *, PyObject *, PyObject *))__pyx_f_7asyncpg_8protocol_8protocol_12CoreProtocol__on_notification; + __pyx_vtable_7asyncpg_8protocol_8protocol_CoreProtocol._set_server_parameter = (PyObject *(*)(struct __pyx_obj_7asyncpg_8protocol_8protocol_CoreProtocol *, PyObject *, PyObject *))__pyx_f_7asyncpg_8protocol_8protocol_12CoreProtocol__set_server_parameter; + __pyx_vtable_7asyncpg_8protocol_8protocol_CoreProtocol._on_connection_lost = (PyObject *(*)(struct __pyx_obj_7asyncpg_8protocol_8protocol_CoreProtocol *, PyObject *))__pyx_f_7asyncpg_8protocol_8protocol_12CoreProtocol__on_connection_lost; + if (PyType_Ready(&__pyx_type_7asyncpg_8protocol_8protocol_CoreProtocol) < 0) __PYX_ERR(4, 11, __pyx_L1_error) + __pyx_type_7asyncpg_8protocol_8protocol_CoreProtocol.tp_print = 0; + if (__Pyx_SetVtable(__pyx_type_7asyncpg_8protocol_8protocol_CoreProtocol.tp_dict, __pyx_vtabptr_7asyncpg_8protocol_8protocol_CoreProtocol) < 0) __PYX_ERR(4, 11, __pyx_L1_error) + if (PyObject_SetAttrString(__pyx_m, "CoreProtocol", (PyObject *)&__pyx_type_7asyncpg_8protocol_8protocol_CoreProtocol) < 0) __PYX_ERR(4, 11, __pyx_L1_error) + __pyx_ptype_7asyncpg_8protocol_8protocol_CoreProtocol = &__pyx_type_7asyncpg_8protocol_8protocol_CoreProtocol; + __pyx_vtabptr_7asyncpg_8protocol_8protocol_PreparedStatementState = &__pyx_vtable_7asyncpg_8protocol_8protocol_PreparedStatementState; + __pyx_vtable_7asyncpg_8protocol_8protocol_PreparedStatementState._encode_bind_msg = (PyObject *(*)(struct __pyx_obj_7asyncpg_8protocol_8protocol_PreparedStatementState *, PyObject *))__pyx_f_7asyncpg_8protocol_8protocol_22PreparedStatementState__encode_bind_msg; + __pyx_vtable_7asyncpg_8protocol_8protocol_PreparedStatementState._ensure_rows_decoder = (PyObject *(*)(struct __pyx_obj_7asyncpg_8protocol_8protocol_PreparedStatementState *))__pyx_f_7asyncpg_8protocol_8protocol_22PreparedStatementState__ensure_rows_decoder; + __pyx_vtable_7asyncpg_8protocol_8protocol_PreparedStatementState._ensure_args_encoder = (PyObject *(*)(struct __pyx_obj_7asyncpg_8protocol_8protocol_PreparedStatementState *))__pyx_f_7asyncpg_8protocol_8protocol_22PreparedStatementState__ensure_args_encoder; + __pyx_vtable_7asyncpg_8protocol_8protocol_PreparedStatementState._set_row_desc = (PyObject *(*)(struct __pyx_obj_7asyncpg_8protocol_8protocol_PreparedStatementState *, PyObject *))__pyx_f_7asyncpg_8protocol_8protocol_22PreparedStatementState__set_row_desc; + __pyx_vtable_7asyncpg_8protocol_8protocol_PreparedStatementState._set_args_desc = (PyObject *(*)(struct __pyx_obj_7asyncpg_8protocol_8protocol_PreparedStatementState *, PyObject *))__pyx_f_7asyncpg_8protocol_8protocol_22PreparedStatementState__set_args_desc; + __pyx_vtable_7asyncpg_8protocol_8protocol_PreparedStatementState._decode_row = (PyObject *(*)(struct __pyx_obj_7asyncpg_8protocol_8protocol_PreparedStatementState *, char const *, Py_ssize_t))__pyx_f_7asyncpg_8protocol_8protocol_22PreparedStatementState__decode_row; + if (PyType_Ready(&__pyx_type_7asyncpg_8protocol_8protocol_PreparedStatementState) < 0) __PYX_ERR(25, 9, __pyx_L1_error) + __pyx_type_7asyncpg_8protocol_8protocol_PreparedStatementState.tp_print = 0; + if (__Pyx_SetVtable(__pyx_type_7asyncpg_8protocol_8protocol_PreparedStatementState.tp_dict, __pyx_vtabptr_7asyncpg_8protocol_8protocol_PreparedStatementState) < 0) __PYX_ERR(25, 9, __pyx_L1_error) + if (PyObject_SetAttrString(__pyx_m, "PreparedStatementState", (PyObject *)&__pyx_type_7asyncpg_8protocol_8protocol_PreparedStatementState) < 0) __PYX_ERR(25, 9, __pyx_L1_error) + __pyx_ptype_7asyncpg_8protocol_8protocol_PreparedStatementState = &__pyx_type_7asyncpg_8protocol_8protocol_PreparedStatementState; + __pyx_vtabptr_7asyncpg_8protocol_8protocol_BaseProtocol = &__pyx_vtable_7asyncpg_8protocol_8protocol_BaseProtocol; + __pyx_vtable_7asyncpg_8protocol_8protocol_BaseProtocol.__pyx_base = *__pyx_vtabptr_7asyncpg_8protocol_8protocol_CoreProtocol; + __pyx_vtable_7asyncpg_8protocol_8protocol_BaseProtocol.__pyx_base._decode_row = (PyObject *(*)(struct __pyx_obj_7asyncpg_8protocol_8protocol_CoreProtocol *, char const *, Py_ssize_t))__pyx_f_7asyncpg_8protocol_8protocol_12BaseProtocol__decode_row; + __pyx_vtable_7asyncpg_8protocol_8protocol_BaseProtocol.__pyx_base._on_result = (PyObject *(*)(struct __pyx_obj_7asyncpg_8protocol_8protocol_CoreProtocol *))__pyx_f_7asyncpg_8protocol_8protocol_12BaseProtocol__on_result; + __pyx_vtable_7asyncpg_8protocol_8protocol_BaseProtocol.__pyx_base._on_notification = (PyObject *(*)(struct __pyx_obj_7asyncpg_8protocol_8protocol_CoreProtocol *, PyObject *, PyObject *, PyObject *))__pyx_f_7asyncpg_8protocol_8protocol_12BaseProtocol__on_notification; + __pyx_vtable_7asyncpg_8protocol_8protocol_BaseProtocol.__pyx_base._set_server_parameter = (PyObject *(*)(struct __pyx_obj_7asyncpg_8protocol_8protocol_CoreProtocol *, PyObject *, PyObject *))__pyx_f_7asyncpg_8protocol_8protocol_12BaseProtocol__set_server_parameter; + __pyx_vtable_7asyncpg_8protocol_8protocol_BaseProtocol.__pyx_base._on_connection_lost = (PyObject *(*)(struct __pyx_obj_7asyncpg_8protocol_8protocol_CoreProtocol *, PyObject *))__pyx_f_7asyncpg_8protocol_8protocol_12BaseProtocol__on_connection_lost; + __pyx_vtable_7asyncpg_8protocol_8protocol_BaseProtocol._ensure_clear_state = (PyObject *(*)(struct __pyx_obj_7asyncpg_8protocol_8protocol_BaseProtocol *))__pyx_f_7asyncpg_8protocol_8protocol_12BaseProtocol__ensure_clear_state; + __pyx_vtable_7asyncpg_8protocol_8protocol_BaseProtocol._new_waiter = (PyObject *(*)(struct __pyx_obj_7asyncpg_8protocol_8protocol_BaseProtocol *, PyObject *))__pyx_f_7asyncpg_8protocol_8protocol_12BaseProtocol__new_waiter; + __pyx_vtable_7asyncpg_8protocol_8protocol_BaseProtocol._on_result__connect = (PyObject *(*)(struct __pyx_obj_7asyncpg_8protocol_8protocol_BaseProtocol *, PyObject *))__pyx_f_7asyncpg_8protocol_8protocol_12BaseProtocol__on_result__connect; + __pyx_vtable_7asyncpg_8protocol_8protocol_BaseProtocol._on_result__prepare = (PyObject *(*)(struct __pyx_obj_7asyncpg_8protocol_8protocol_BaseProtocol *, PyObject *))__pyx_f_7asyncpg_8protocol_8protocol_12BaseProtocol__on_result__prepare; + __pyx_vtable_7asyncpg_8protocol_8protocol_BaseProtocol._on_result__bind_and_exec = (PyObject *(*)(struct __pyx_obj_7asyncpg_8protocol_8protocol_BaseProtocol *, PyObject *))__pyx_f_7asyncpg_8protocol_8protocol_12BaseProtocol__on_result__bind_and_exec; + __pyx_vtable_7asyncpg_8protocol_8protocol_BaseProtocol._on_result__close_stmt_or_portal = (PyObject *(*)(struct __pyx_obj_7asyncpg_8protocol_8protocol_BaseProtocol *, PyObject *))__pyx_f_7asyncpg_8protocol_8protocol_12BaseProtocol__on_result__close_stmt_or_portal; + __pyx_vtable_7asyncpg_8protocol_8protocol_BaseProtocol._on_result__simple_query = (PyObject *(*)(struct __pyx_obj_7asyncpg_8protocol_8protocol_BaseProtocol *, PyObject *))__pyx_f_7asyncpg_8protocol_8protocol_12BaseProtocol__on_result__simple_query; + __pyx_vtable_7asyncpg_8protocol_8protocol_BaseProtocol._on_result__bind = (PyObject *(*)(struct __pyx_obj_7asyncpg_8protocol_8protocol_BaseProtocol *, PyObject *))__pyx_f_7asyncpg_8protocol_8protocol_12BaseProtocol__on_result__bind; + __pyx_vtable_7asyncpg_8protocol_8protocol_BaseProtocol._handle_waiter_on_connection_lost = (PyObject *(*)(struct __pyx_obj_7asyncpg_8protocol_8protocol_BaseProtocol *, PyObject *))__pyx_f_7asyncpg_8protocol_8protocol_12BaseProtocol__handle_waiter_on_connection_lost; + __pyx_vtable_7asyncpg_8protocol_8protocol_BaseProtocol._dispatch_result = (PyObject *(*)(struct __pyx_obj_7asyncpg_8protocol_8protocol_BaseProtocol *))__pyx_f_7asyncpg_8protocol_8protocol_12BaseProtocol__dispatch_result; + __pyx_type_7asyncpg_8protocol_8protocol_BaseProtocol.tp_base = __pyx_ptype_7asyncpg_8protocol_8protocol_CoreProtocol; + if (PyType_Ready(&__pyx_type_7asyncpg_8protocol_8protocol_BaseProtocol) < 0) __PYX_ERR(27, 82, __pyx_L1_error) + __pyx_type_7asyncpg_8protocol_8protocol_BaseProtocol.tp_print = 0; + if (__Pyx_SetVtable(__pyx_type_7asyncpg_8protocol_8protocol_BaseProtocol.tp_dict, __pyx_vtabptr_7asyncpg_8protocol_8protocol_BaseProtocol) < 0) __PYX_ERR(27, 82, __pyx_L1_error) + if (PyObject_SetAttrString(__pyx_m, "BaseProtocol", (PyObject *)&__pyx_type_7asyncpg_8protocol_8protocol_BaseProtocol) < 0) __PYX_ERR(27, 82, __pyx_L1_error) + __pyx_ptype_7asyncpg_8protocol_8protocol_BaseProtocol = &__pyx_type_7asyncpg_8protocol_8protocol_BaseProtocol; + if (PyType_Ready(&__pyx_type_7asyncpg_8protocol_8protocol___pyx_scope_struct__prepare) < 0) __PYX_ERR(27, 123, __pyx_L1_error) + __pyx_type_7asyncpg_8protocol_8protocol___pyx_scope_struct__prepare.tp_print = 0; + __pyx_ptype_7asyncpg_8protocol_8protocol___pyx_scope_struct__prepare = &__pyx_type_7asyncpg_8protocol_8protocol___pyx_scope_struct__prepare; + if (PyType_Ready(&__pyx_type_7asyncpg_8protocol_8protocol___pyx_scope_struct_1_bind_execute) < 0) __PYX_ERR(27, 142, __pyx_L1_error) + __pyx_type_7asyncpg_8protocol_8protocol___pyx_scope_struct_1_bind_execute.tp_print = 0; + __pyx_ptype_7asyncpg_8protocol_8protocol___pyx_scope_struct_1_bind_execute = &__pyx_type_7asyncpg_8protocol_8protocol___pyx_scope_struct_1_bind_execute; + if (PyType_Ready(&__pyx_type_7asyncpg_8protocol_8protocol___pyx_scope_struct_2_bind_execute_many) < 0) __PYX_ERR(27, 167, __pyx_L1_error) + __pyx_type_7asyncpg_8protocol_8protocol___pyx_scope_struct_2_bind_execute_many.tp_print = 0; + __pyx_ptype_7asyncpg_8protocol_8protocol___pyx_scope_struct_2_bind_execute_many = &__pyx_type_7asyncpg_8protocol_8protocol___pyx_scope_struct_2_bind_execute_many; + if (PyType_Ready(&__pyx_type_7asyncpg_8protocol_8protocol___pyx_scope_struct_3_genexpr) < 0) __PYX_ERR(27, 181, __pyx_L1_error) + __pyx_type_7asyncpg_8protocol_8protocol___pyx_scope_struct_3_genexpr.tp_print = 0; + __pyx_ptype_7asyncpg_8protocol_8protocol___pyx_scope_struct_3_genexpr = &__pyx_type_7asyncpg_8protocol_8protocol___pyx_scope_struct_3_genexpr; + if (PyType_Ready(&__pyx_type_7asyncpg_8protocol_8protocol___pyx_scope_struct_4_bind) < 0) __PYX_ERR(27, 198, __pyx_L1_error) + __pyx_type_7asyncpg_8protocol_8protocol___pyx_scope_struct_4_bind.tp_print = 0; + __pyx_ptype_7asyncpg_8protocol_8protocol___pyx_scope_struct_4_bind = &__pyx_type_7asyncpg_8protocol_8protocol___pyx_scope_struct_4_bind; + if (PyType_Ready(&__pyx_type_7asyncpg_8protocol_8protocol___pyx_scope_struct_5_execute) < 0) __PYX_ERR(27, 219, __pyx_L1_error) + __pyx_type_7asyncpg_8protocol_8protocol___pyx_scope_struct_5_execute.tp_print = 0; + __pyx_ptype_7asyncpg_8protocol_8protocol___pyx_scope_struct_5_execute = &__pyx_type_7asyncpg_8protocol_8protocol___pyx_scope_struct_5_execute; + if (PyType_Ready(&__pyx_type_7asyncpg_8protocol_8protocol___pyx_scope_struct_6_query) < 0) __PYX_ERR(27, 242, __pyx_L1_error) + __pyx_type_7asyncpg_8protocol_8protocol___pyx_scope_struct_6_query.tp_print = 0; + __pyx_ptype_7asyncpg_8protocol_8protocol___pyx_scope_struct_6_query = &__pyx_type_7asyncpg_8protocol_8protocol___pyx_scope_struct_6_query; + if (PyType_Ready(&__pyx_type_7asyncpg_8protocol_8protocol___pyx_scope_struct_7_close_statement) < 0) __PYX_ERR(27, 257, __pyx_L1_error) + __pyx_type_7asyncpg_8protocol_8protocol___pyx_scope_struct_7_close_statement.tp_print = 0; + __pyx_ptype_7asyncpg_8protocol_8protocol___pyx_scope_struct_7_close_statement = &__pyx_type_7asyncpg_8protocol_8protocol___pyx_scope_struct_7_close_statement; + if (PyType_Ready(&__pyx_type_7asyncpg_8protocol_8protocol___pyx_scope_struct_8_close) < 0) __PYX_ERR(27, 289, __pyx_L1_error) + __pyx_type_7asyncpg_8protocol_8protocol___pyx_scope_struct_8_close.tp_print = 0; + __pyx_ptype_7asyncpg_8protocol_8protocol___pyx_scope_struct_8_close = &__pyx_type_7asyncpg_8protocol_8protocol___pyx_scope_struct_8_close; + /*--- Type import code ---*/ + __pyx_ptype_7cpython_4type_type = __Pyx_ImportType(__Pyx_BUILTIN_MODULE_NAME, "type", + #if CYTHON_COMPILING_IN_PYPY + sizeof(PyTypeObject), + #else + sizeof(PyHeapTypeObject), + #endif + 0); if (unlikely(!__pyx_ptype_7cpython_4type_type)) __PYX_ERR(29, 9, __pyx_L1_error) + __pyx_ptype_7cpython_4bool_bool = __Pyx_ImportType(__Pyx_BUILTIN_MODULE_NAME, "bool", sizeof(PyBoolObject), 0); if (unlikely(!__pyx_ptype_7cpython_4bool_bool)) __PYX_ERR(30, 8, __pyx_L1_error) + __pyx_ptype_7cpython_7complex_complex = __Pyx_ImportType(__Pyx_BUILTIN_MODULE_NAME, "complex", sizeof(PyComplexObject), 0); if (unlikely(!__pyx_ptype_7cpython_7complex_complex)) __PYX_ERR(31, 15, __pyx_L1_error) + /*--- Variable import code ---*/ + /*--- Function import code ---*/ + /*--- Execution code ---*/ + #if defined(__Pyx_Generator_USED) || defined(__Pyx_Coroutine_USED) + if (__Pyx_patch_abc() < 0) __PYX_ERR(27, 1, __pyx_L1_error) + #endif + + /* "asyncpg/protocol/protocol.pyx":13 + * cimport cpython + * + * import asyncio # <<<<<<<<<<<<<< + * import codecs + * import collections + */ + __pyx_t_1 = __Pyx_patch_asyncio(__Pyx_Import(__pyx_n_s_asyncio, 0, 0)); if (unlikely(!__pyx_t_1)) __PYX_ERR(27, 13, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_asyncio, __pyx_t_1) < 0) __PYX_ERR(27, 13, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "asyncpg/protocol/protocol.pyx":14 + * + * import asyncio + * import codecs # <<<<<<<<<<<<<< + * import collections + * import socket + */ + __pyx_t_1 = __Pyx_Import(__pyx_n_s_codecs, 0, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(27, 14, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_codecs, __pyx_t_1) < 0) __PYX_ERR(27, 14, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "asyncpg/protocol/protocol.pyx":15 + * import asyncio + * import codecs + * import collections # <<<<<<<<<<<<<< + * import socket + * + */ + __pyx_t_1 = __Pyx_Import(__pyx_n_s_collections, 0, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(27, 15, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_collections, __pyx_t_1) < 0) __PYX_ERR(27, 15, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "asyncpg/protocol/protocol.pyx":16 + * import codecs + * import collections + * import socket # <<<<<<<<<<<<<< + * + * from libc.stdint cimport int8_t, uint8_t, int16_t, uint16_t, \ + */ + __pyx_t_1 = __Pyx_Import(__pyx_n_s_socket, 0, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(27, 16, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_socket, __pyx_t_1) < 0) __PYX_ERR(27, 16, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "asyncpg/protocol/protocol.pyx":32 + * from cpython cimport PyBuffer_FillInfo, PyBytes_AsString + * + * from asyncpg.exceptions import _base as apg_exc_base # <<<<<<<<<<<<<< + * from asyncpg import types as apg_types + * from asyncpg import exceptions as apg_exc + */ + __pyx_t_1 = PyList_New(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(27, 32, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_INCREF(__pyx_n_s_base); + __Pyx_GIVEREF(__pyx_n_s_base); + PyList_SET_ITEM(__pyx_t_1, 0, __pyx_n_s_base); + __pyx_t_2 = __Pyx_Import(__pyx_n_s_asyncpg_exceptions, __pyx_t_1, 0); if (unlikely(!__pyx_t_2)) __PYX_ERR(27, 32, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_1 = __Pyx_ImportFrom(__pyx_t_2, __pyx_n_s_base); if (unlikely(!__pyx_t_1)) __PYX_ERR(27, 32, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_apg_exc_base, __pyx_t_1) < 0) __PYX_ERR(27, 32, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "asyncpg/protocol/protocol.pyx":33 + * + * from asyncpg.exceptions import _base as apg_exc_base + * from asyncpg import types as apg_types # <<<<<<<<<<<<<< + * from asyncpg import exceptions as apg_exc + * + */ + __pyx_t_2 = PyList_New(1); if (unlikely(!__pyx_t_2)) __PYX_ERR(27, 33, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_INCREF(__pyx_n_s_types); + __Pyx_GIVEREF(__pyx_n_s_types); + PyList_SET_ITEM(__pyx_t_2, 0, __pyx_n_s_types); + __pyx_t_1 = __Pyx_Import(__pyx_n_s_asyncpg, __pyx_t_2, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(27, 33, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_2 = __Pyx_ImportFrom(__pyx_t_1, __pyx_n_s_types); if (unlikely(!__pyx_t_2)) __PYX_ERR(27, 33, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_apg_types, __pyx_t_2) < 0) __PYX_ERR(27, 33, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "asyncpg/protocol/protocol.pyx":34 + * from asyncpg.exceptions import _base as apg_exc_base + * from asyncpg import types as apg_types + * from asyncpg import exceptions as apg_exc # <<<<<<<<<<<<<< + * + * from asyncpg.protocol cimport hton + */ + __pyx_t_1 = PyList_New(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(27, 34, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_INCREF(__pyx_n_s_exceptions); + __Pyx_GIVEREF(__pyx_n_s_exceptions); + PyList_SET_ITEM(__pyx_t_1, 0, __pyx_n_s_exceptions); + __pyx_t_2 = __Pyx_Import(__pyx_n_s_asyncpg, __pyx_t_1, 0); if (unlikely(!__pyx_t_2)) __PYX_ERR(27, 34, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_1 = __Pyx_ImportFrom(__pyx_t_2, __pyx_n_s_exceptions); if (unlikely(!__pyx_t_1)) __PYX_ERR(27, 34, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_apg_exc, __pyx_t_1) < 0) __PYX_ERR(27, 34, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "asyncpg/protocol/pgtypes.pxi":98 + * DEF REGROLEOID = 4096 + * + * cdef ARRAY_TYPES = (_TEXTOID, _OIDOID,) # <<<<<<<<<<<<<< + * + * TYPEMAP = { + */ + __Pyx_INCREF(__pyx_tuple__83); + __Pyx_XGOTREF(__pyx_v_7asyncpg_8protocol_8protocol_ARRAY_TYPES); + __Pyx_DECREF_SET(__pyx_v_7asyncpg_8protocol_8protocol_ARRAY_TYPES, __pyx_tuple__83); + __Pyx_GIVEREF(__pyx_tuple__83); + + /* "asyncpg/protocol/pgtypes.pxi":101 + * + * TYPEMAP = { + * ABSTIMEOID: 'abstime', # <<<<<<<<<<<<<< + * ACLITEMOID: 'aclitem', + * ANYARRAYOID: 'anyarray', + */ + __pyx_t_2 = PyDict_New(); if (unlikely(!__pyx_t_2)) __PYX_ERR(32, 101, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + if (PyDict_SetItem(__pyx_t_2, __pyx_int_702, __pyx_n_u_abstime) < 0) __PYX_ERR(32, 101, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_2, __pyx_int_1033, __pyx_n_u_aclitem) < 0) __PYX_ERR(32, 101, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_2, __pyx_int_2277, __pyx_n_u_anyarray) < 0) __PYX_ERR(32, 101, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_2, __pyx_int_2283, __pyx_n_u_anyelement) < 0) __PYX_ERR(32, 101, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_2, __pyx_int_3500, __pyx_n_u_anyenum) < 0) __PYX_ERR(32, 101, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_2, __pyx_int_2776, __pyx_n_u_anynonarray) < 0) __PYX_ERR(32, 101, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_2, __pyx_int_2276, __pyx_n_u_any) < 0) __PYX_ERR(32, 101, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_2, __pyx_int_3831, __pyx_n_u_anyrange) < 0) __PYX_ERR(32, 101, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_2, __pyx_int_1560, __pyx_n_u_bit) < 0) __PYX_ERR(32, 101, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_2, __pyx_int_16, __pyx_n_u_bool) < 0) __PYX_ERR(32, 101, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_2, __pyx_int_603, __pyx_n_u_box) < 0) __PYX_ERR(32, 101, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_2, __pyx_int_1042, __pyx_n_u_bpchar) < 0) __PYX_ERR(32, 101, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_2, __pyx_int_17, __pyx_n_u_bytea) < 0) __PYX_ERR(32, 101, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_2, __pyx_int_18, __pyx_n_u_char) < 0) __PYX_ERR(32, 101, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_2, __pyx_int_29, __pyx_n_u_cid) < 0) __PYX_ERR(32, 101, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_2, __pyx_int_650, __pyx_n_u_cidr) < 0) __PYX_ERR(32, 101, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_2, __pyx_int_718, __pyx_n_u_circle) < 0) __PYX_ERR(32, 101, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_2, __pyx_int_2275, __pyx_n_u_cstring) < 0) __PYX_ERR(32, 101, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_2, __pyx_int_1082, __pyx_n_u_date) < 0) __PYX_ERR(32, 101, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_2, __pyx_int_3838, __pyx_n_u_event_trigger) < 0) __PYX_ERR(32, 101, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_2, __pyx_int_3115, __pyx_n_u_fdw_handler) < 0) __PYX_ERR(32, 101, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_2, __pyx_int_700, __pyx_n_u_float4) < 0) __PYX_ERR(32, 101, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_2, __pyx_int_701, __pyx_n_u_float8) < 0) __PYX_ERR(32, 101, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_2, __pyx_int_3642, __pyx_n_u_gtsvector) < 0) __PYX_ERR(32, 101, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_2, __pyx_int_869, __pyx_n_u_inet) < 0) __PYX_ERR(32, 101, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_2, __pyx_int_21, __pyx_n_u_int2) < 0) __PYX_ERR(32, 101, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_2, __pyx_int_23, __pyx_n_u_int4) < 0) __PYX_ERR(32, 101, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_2, __pyx_int_20, __pyx_n_u_int8) < 0) __PYX_ERR(32, 101, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_2, __pyx_int_2281, __pyx_n_u_internal) < 0) __PYX_ERR(32, 101, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_2, __pyx_int_1186, __pyx_n_u_interval) < 0) __PYX_ERR(32, 101, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_2, __pyx_int_3802, __pyx_n_u_jsonb) < 0) __PYX_ERR(32, 101, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_2, __pyx_int_114, __pyx_n_u_json) < 0) __PYX_ERR(32, 101, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_2, __pyx_int_2280, __pyx_n_u_language_handler) < 0) __PYX_ERR(32, 101, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_2, __pyx_int_628, __pyx_n_u_line) < 0) __PYX_ERR(32, 101, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_2, __pyx_int_601, __pyx_n_u_lseg) < 0) __PYX_ERR(32, 101, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_2, __pyx_int_829, __pyx_n_u_macaddr) < 0) __PYX_ERR(32, 101, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_2, __pyx_int_790, __pyx_n_u_money) < 0) __PYX_ERR(32, 101, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_2, __pyx_int_19, __pyx_n_u_name) < 0) __PYX_ERR(32, 101, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_2, __pyx_int_1700, __pyx_n_u_numeric) < 0) __PYX_ERR(32, 101, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_2, __pyx_int_26, __pyx_n_u_oid) < 0) __PYX_ERR(32, 101, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_2, __pyx_int_2282, __pyx_n_u_opaque) < 0) __PYX_ERR(32, 101, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_2, __pyx_int_602, __pyx_n_u_path) < 0) __PYX_ERR(32, 101, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_2, __pyx_int_32, __pyx_n_u_pg_ddl_command) < 0) __PYX_ERR(32, 101, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_2, __pyx_int_3220, __pyx_n_u_pg_lsn) < 0) __PYX_ERR(32, 101, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_2, __pyx_int_194, __pyx_n_u_pg_node_tree) < 0) __PYX_ERR(32, 101, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_2, __pyx_int_600, __pyx_n_u_point) < 0) __PYX_ERR(32, 101, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_2, __pyx_int_604, __pyx_n_u_polygon) < 0) __PYX_ERR(32, 101, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_2, __pyx_int_2249, __pyx_n_u_record) < 0) __PYX_ERR(32, 101, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_2, __pyx_int_1790, __pyx_n_u_refcursor) < 0) __PYX_ERR(32, 101, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_2, __pyx_int_2205, __pyx_n_u_regclass) < 0) __PYX_ERR(32, 101, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_2, __pyx_int_3734, __pyx_n_u_regconfig) < 0) __PYX_ERR(32, 101, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_2, __pyx_int_3769, __pyx_n_u_regdictionary) < 0) __PYX_ERR(32, 101, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_2, __pyx_int_4089, __pyx_n_u_regnamespace) < 0) __PYX_ERR(32, 101, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_2, __pyx_int_2204, __pyx_n_u_regoperator) < 0) __PYX_ERR(32, 101, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_2, __pyx_int_2203, __pyx_n_u_regoper) < 0) __PYX_ERR(32, 101, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_2, __pyx_int_2202, __pyx_n_u_regprocedure) < 0) __PYX_ERR(32, 101, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_2, __pyx_int_24, __pyx_n_u_regproc) < 0) __PYX_ERR(32, 101, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_2, __pyx_int_4096, __pyx_n_u_regrole) < 0) __PYX_ERR(32, 101, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_2, __pyx_int_2206, __pyx_n_u_regtype) < 0) __PYX_ERR(32, 101, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_2, __pyx_int_703, __pyx_n_u_reltime) < 0) __PYX_ERR(32, 101, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_2, __pyx_int_210, __pyx_n_u_smgr) < 0) __PYX_ERR(32, 101, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_2, __pyx_int_25, __pyx_n_u_text) < 0) __PYX_ERR(32, 101, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_2, __pyx_int_27, __pyx_n_u_tid) < 0) __PYX_ERR(32, 101, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_2, __pyx_int_1083, __pyx_n_u_time) < 0) __PYX_ERR(32, 101, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_2, __pyx_int_1114, __pyx_n_u_timestamp) < 0) __PYX_ERR(32, 101, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_2, __pyx_int_1184, __pyx_n_u_timestamptz) < 0) __PYX_ERR(32, 101, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_2, __pyx_int_1266, __pyx_n_u_timetz) < 0) __PYX_ERR(32, 101, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_2, __pyx_int_704, __pyx_n_u_tinterval) < 0) __PYX_ERR(32, 101, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_2, __pyx_int_2279, __pyx_n_u_trigger) < 0) __PYX_ERR(32, 101, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_2, __pyx_int_3310, __pyx_n_u_tsm_handler) < 0) __PYX_ERR(32, 101, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_2, __pyx_int_3615, __pyx_n_u_tsquery) < 0) __PYX_ERR(32, 101, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_2, __pyx_int_3614, __pyx_n_u_tsvector) < 0) __PYX_ERR(32, 101, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_2, __pyx_int_2970, __pyx_n_u_txid_snapshot) < 0) __PYX_ERR(32, 101, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_2, __pyx_int_705, __pyx_n_u_unknown) < 0) __PYX_ERR(32, 101, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_2, __pyx_int_2950, __pyx_n_u_uuid) < 0) __PYX_ERR(32, 101, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_2, __pyx_int_1562, __pyx_n_u_varbit) < 0) __PYX_ERR(32, 101, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_2, __pyx_int_1043, __pyx_n_u_varchar) < 0) __PYX_ERR(32, 101, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_2, __pyx_int_2278, __pyx_n_u_void) < 0) __PYX_ERR(32, 101, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_2, __pyx_int_28, __pyx_n_u_xid) < 0) __PYX_ERR(32, 101, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_2, __pyx_int_142, __pyx_n_u_xml) < 0) __PYX_ERR(32, 101, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_2, __pyx_int_1028, __pyx_kp_u_oid_2) < 0) __PYX_ERR(32, 101, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_2, __pyx_int_1009, __pyx_kp_u_text_2) < 0) __PYX_ERR(32, 101, __pyx_L1_error) + if (PyDict_SetItem(__pyx_d, __pyx_n_s_TYPEMAP, __pyx_t_2) < 0) __PYX_ERR(32, 100, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "asyncpg/protocol/encodings.pyx":14 + * + * cdef dict ENCODINGS_MAP = { + * 'abc': 'cp1258', # <<<<<<<<<<<<<< + * 'alt': 'cp866', + * 'euc_cn': 'euccn', + */ + __pyx_t_2 = PyDict_New(); if (unlikely(!__pyx_t_2)) __PYX_ERR(5, 14, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + if (PyDict_SetItem(__pyx_t_2, __pyx_n_u_abc, __pyx_n_u_cp1258) < 0) __PYX_ERR(5, 14, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_2, __pyx_n_u_alt, __pyx_n_u_cp866) < 0) __PYX_ERR(5, 14, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_2, __pyx_n_u_euc_cn, __pyx_n_u_euccn) < 0) __PYX_ERR(5, 14, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_2, __pyx_n_u_euc_jp, __pyx_n_u_eucjp) < 0) __PYX_ERR(5, 14, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_2, __pyx_n_u_euc_kr, __pyx_n_u_euckr) < 0) __PYX_ERR(5, 14, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_2, __pyx_n_u_koi8r, __pyx_n_u_koi8_r) < 0) __PYX_ERR(5, 14, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_2, __pyx_n_u_koi8u, __pyx_n_u_koi8_u) < 0) __PYX_ERR(5, 14, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_2, __pyx_n_u_shift_jis_2004, __pyx_n_u_euc_jis_2004) < 0) __PYX_ERR(5, 14, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_2, __pyx_n_u_sjis, __pyx_n_u_shift_jis) < 0) __PYX_ERR(5, 14, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_2, __pyx_n_u_sql_ascii, __pyx_n_u_ascii) < 0) __PYX_ERR(5, 14, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_2, __pyx_n_u_vscii, __pyx_n_u_cp1258) < 0) __PYX_ERR(5, 14, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_2, __pyx_n_u_tcvn, __pyx_n_u_cp1258) < 0) __PYX_ERR(5, 14, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_2, __pyx_n_u_tcvn5712, __pyx_n_u_cp1258) < 0) __PYX_ERR(5, 14, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_2, __pyx_n_u_unicode, __pyx_n_u_utf_8_2) < 0) __PYX_ERR(5, 14, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_2, __pyx_n_u_win, __pyx_n_u_cp1521) < 0) __PYX_ERR(5, 14, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_2, __pyx_n_u_win1250, __pyx_n_u_cp1250) < 0) __PYX_ERR(5, 14, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_2, __pyx_n_u_win1251, __pyx_n_u_cp1251) < 0) __PYX_ERR(5, 14, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_2, __pyx_n_u_win1252, __pyx_n_u_cp1252) < 0) __PYX_ERR(5, 14, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_2, __pyx_n_u_win1253, __pyx_n_u_cp1253) < 0) __PYX_ERR(5, 14, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_2, __pyx_n_u_win1254, __pyx_n_u_cp1254) < 0) __PYX_ERR(5, 14, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_2, __pyx_n_u_win1255, __pyx_n_u_cp1255) < 0) __PYX_ERR(5, 14, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_2, __pyx_n_u_win1256, __pyx_n_u_cp1256) < 0) __PYX_ERR(5, 14, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_2, __pyx_n_u_win1257, __pyx_n_u_cp1257) < 0) __PYX_ERR(5, 14, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_2, __pyx_n_u_win1258, __pyx_n_u_cp1258) < 0) __PYX_ERR(5, 14, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_2, __pyx_n_u_win866, __pyx_n_u_cp866) < 0) __PYX_ERR(5, 14, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_2, __pyx_n_u_win874, __pyx_n_u_cp874) < 0) __PYX_ERR(5, 14, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_2, __pyx_n_u_win932, __pyx_n_u_cp932) < 0) __PYX_ERR(5, 14, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_2, __pyx_n_u_win936, __pyx_n_u_cp936) < 0) __PYX_ERR(5, 14, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_2, __pyx_n_u_win949, __pyx_n_u_cp949) < 0) __PYX_ERR(5, 14, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_2, __pyx_n_u_win950, __pyx_n_u_cp950) < 0) __PYX_ERR(5, 14, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_2, __pyx_n_u_windows1250, __pyx_n_u_cp1250) < 0) __PYX_ERR(5, 14, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_2, __pyx_n_u_windows1251, __pyx_n_u_cp1251) < 0) __PYX_ERR(5, 14, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_2, __pyx_n_u_windows1252, __pyx_n_u_cp1252) < 0) __PYX_ERR(5, 14, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_2, __pyx_n_u_windows1253, __pyx_n_u_cp1253) < 0) __PYX_ERR(5, 14, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_2, __pyx_n_u_windows1254, __pyx_n_u_cp1254) < 0) __PYX_ERR(5, 14, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_2, __pyx_n_u_windows1255, __pyx_n_u_cp1255) < 0) __PYX_ERR(5, 14, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_2, __pyx_n_u_windows1256, __pyx_n_u_cp1256) < 0) __PYX_ERR(5, 14, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_2, __pyx_n_u_windows1257, __pyx_n_u_cp1257) < 0) __PYX_ERR(5, 14, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_2, __pyx_n_u_windows1258, __pyx_n_u_cp1258) < 0) __PYX_ERR(5, 14, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_2, __pyx_n_u_windows866, __pyx_n_u_cp866) < 0) __PYX_ERR(5, 14, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_2, __pyx_n_u_windows874, __pyx_n_u_cp874) < 0) __PYX_ERR(5, 14, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_2, __pyx_n_u_windows932, __pyx_n_u_cp932) < 0) __PYX_ERR(5, 14, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_2, __pyx_n_u_windows936, __pyx_n_u_cp936) < 0) __PYX_ERR(5, 14, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_2, __pyx_n_u_windows949, __pyx_n_u_cp949) < 0) __PYX_ERR(5, 14, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_2, __pyx_n_u_windows950, __pyx_n_u_cp950) < 0) __PYX_ERR(5, 14, __pyx_L1_error) + __Pyx_XGOTREF(__pyx_v_7asyncpg_8protocol_8protocol_ENCODINGS_MAP); + __Pyx_DECREF_SET(__pyx_v_7asyncpg_8protocol_8protocol_ENCODINGS_MAP, ((PyObject*)__pyx_t_2)); + __Pyx_GIVEREF(__pyx_t_2); + __pyx_t_2 = 0; + + /* "asyncpg/protocol/settings.pyx":46 + * + * cpdef inline Codec get_data_codec(self, uint32_t oid, + * CodecFormat format=PG_FORMAT_ANY): # <<<<<<<<<<<<<< + * if format == PG_FORMAT_ANY: + * codec = self._data_codecs.get_codec(oid, PG_FORMAT_BINARY) + */ + __pyx_k__2 = __pyx_e_7asyncpg_8protocol_8protocol_PG_FORMAT_ANY; + + /* "asyncpg/protocol/settings.pyx":45 + * typekind, alias_to) + * + * cpdef inline Codec get_data_codec(self, uint32_t oid, # <<<<<<<<<<<<<< + * CodecFormat format=PG_FORMAT_ANY): + * if format == PG_FORMAT_ANY: + */ + __pyx_k__2 = __pyx_e_7asyncpg_8protocol_8protocol_PG_FORMAT_ANY; + + /* "asyncpg/protocol/buffer.pyx":12 + * + * + * class BufferError(Exception): # <<<<<<<<<<<<<< + * pass + * + */ + __pyx_t_2 = PyTuple_New(1); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 12, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_INCREF(((PyObject *)(&((PyTypeObject*)PyExc_Exception)[0]))); + __Pyx_GIVEREF(((PyObject *)(&((PyTypeObject*)PyExc_Exception)[0]))); + PyTuple_SET_ITEM(__pyx_t_2, 0, ((PyObject *)(&((PyTypeObject*)PyExc_Exception)[0]))); + __pyx_t_1 = __Pyx_CalculateMetaclass(NULL, __pyx_t_2); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 12, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_3 = __Pyx_Py3MetaclassPrepare(__pyx_t_1, __pyx_t_2, __pyx_n_s_BufferError, __pyx_n_s_BufferError, (PyObject *) NULL, __pyx_n_s_asyncpg_protocol_protocol, (PyObject *) NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 12, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = __Pyx_Py3ClassCreate(__pyx_t_1, __pyx_n_s_BufferError, __pyx_t_2, __pyx_t_3, NULL, 0, 0); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 12, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_BufferError, __pyx_t_4) < 0) __PYX_ERR(1, 12, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "asyncpg/protocol/codecs/base.pyx":10 + * cdef void* binary_codec_map[MAXSUPPORTEDOID + 1] + * cdef void* text_codec_map[MAXSUPPORTEDOID + 1] + * cdef dict TYPE_CODECS_CACHE = {} # <<<<<<<<<<<<<< + * cdef dict EXTRA_CODECS = {} + * + */ + __pyx_t_2 = PyDict_New(); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 10, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_XGOTREF(__pyx_v_7asyncpg_8protocol_8protocol_TYPE_CODECS_CACHE); + __Pyx_DECREF_SET(__pyx_v_7asyncpg_8protocol_8protocol_TYPE_CODECS_CACHE, ((PyObject*)__pyx_t_2)); + __Pyx_GIVEREF(__pyx_t_2); + __pyx_t_2 = 0; + + /* "asyncpg/protocol/codecs/base.pyx":11 + * cdef void* text_codec_map[MAXSUPPORTEDOID + 1] + * cdef dict TYPE_CODECS_CACHE = {} + * cdef dict EXTRA_CODECS = {} # <<<<<<<<<<<<<< + * + * + */ + __pyx_t_2 = PyDict_New(); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 11, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_XGOTREF(__pyx_v_7asyncpg_8protocol_8protocol_EXTRA_CODECS); + __Pyx_DECREF_SET(__pyx_v_7asyncpg_8protocol_8protocol_EXTRA_CODECS, ((PyObject*)__pyx_t_2)); + __Pyx_GIVEREF(__pyx_t_2); + __pyx_t_2 = 0; + + /* "asyncpg/protocol/codecs/bytea.pyx":48 + * PG_FORMAT_BINARY) + * + * init_bytea_codecs() # <<<<<<<<<<<<<< + */ + __pyx_t_2 = __pyx_f_7asyncpg_8protocol_8protocol_init_bytea_codecs(); if (unlikely(!__pyx_t_2)) __PYX_ERR(6, 48, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "asyncpg/protocol/codecs/text.pyx":67 + * + * + * init_text_codecs() # <<<<<<<<<<<<<< + */ + __pyx_t_2 = __pyx_f_7asyncpg_8protocol_8protocol_init_text_codecs(); if (unlikely(!__pyx_t_2)) __PYX_ERR(7, 67, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "asyncpg/protocol/codecs/bits.pyx":8 + * + * + * from asyncpg.types import BitString # <<<<<<<<<<<<<< + * + * + */ + __pyx_t_2 = PyList_New(1); if (unlikely(!__pyx_t_2)) __PYX_ERR(8, 8, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_INCREF(__pyx_n_s_BitString); + __Pyx_GIVEREF(__pyx_n_s_BitString); + PyList_SET_ITEM(__pyx_t_2, 0, __pyx_n_s_BitString); + __pyx_t_1 = __Pyx_Import(__pyx_n_s_asyncpg_types, __pyx_t_2, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(8, 8, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_2 = __Pyx_ImportFrom(__pyx_t_1, __pyx_n_s_BitString); if (unlikely(!__pyx_t_2)) __PYX_ERR(8, 8, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_BitString, __pyx_t_2) < 0) __PYX_ERR(8, 8, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "asyncpg/protocol/codecs/bits.pyx":64 + * PG_FORMAT_BINARY) + * + * init_bits_codecs() # <<<<<<<<<<<<<< + */ + __pyx_t_1 = __pyx_f_7asyncpg_8protocol_8protocol_init_bits_codecs(); if (unlikely(!__pyx_t_1)) __PYX_ERR(8, 64, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "asyncpg/protocol/codecs/datetime.pyx":8 + * + * + * import datetime # <<<<<<<<<<<<<< + * + * utc = datetime.timezone.utc + */ + __pyx_t_1 = __Pyx_Import(__pyx_n_s_datetime, 0, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(9, 8, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_datetime, __pyx_t_1) < 0) __PYX_ERR(9, 8, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "asyncpg/protocol/codecs/datetime.pyx":10 + * import datetime + * + * utc = datetime.timezone.utc # <<<<<<<<<<<<<< + * date_from_ordinal = datetime.date.fromordinal + * timedelta = datetime.timedelta + */ + __pyx_t_1 = __Pyx_GetModuleGlobalName(__pyx_n_s_datetime); if (unlikely(!__pyx_t_1)) __PYX_ERR(9, 10, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_timezone); if (unlikely(!__pyx_t_2)) __PYX_ERR(9, 10, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_utc); if (unlikely(!__pyx_t_1)) __PYX_ERR(9, 10, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + if (PyDict_SetItem(__pyx_d, __pyx_n_s_utc, __pyx_t_1) < 0) __PYX_ERR(9, 10, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "asyncpg/protocol/codecs/datetime.pyx":11 + * + * utc = datetime.timezone.utc + * date_from_ordinal = datetime.date.fromordinal # <<<<<<<<<<<<<< + * timedelta = datetime.timedelta + * + */ + __pyx_t_1 = __Pyx_GetModuleGlobalName(__pyx_n_s_datetime); if (unlikely(!__pyx_t_1)) __PYX_ERR(9, 11, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_date); if (unlikely(!__pyx_t_2)) __PYX_ERR(9, 11, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_fromordinal); if (unlikely(!__pyx_t_1)) __PYX_ERR(9, 11, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + if (PyDict_SetItem(__pyx_d, __pyx_n_s_date_from_ordinal, __pyx_t_1) < 0) __PYX_ERR(9, 11, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "asyncpg/protocol/codecs/datetime.pyx":12 + * utc = datetime.timezone.utc + * date_from_ordinal = datetime.date.fromordinal + * timedelta = datetime.timedelta # <<<<<<<<<<<<<< + * + * pg_epoch_datetime = datetime.datetime(2000, 1, 1) + */ + __pyx_t_1 = __Pyx_GetModuleGlobalName(__pyx_n_s_datetime); if (unlikely(!__pyx_t_1)) __PYX_ERR(9, 12, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_timedelta); if (unlikely(!__pyx_t_2)) __PYX_ERR(9, 12, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + if (PyDict_SetItem(__pyx_d, __pyx_n_s_timedelta, __pyx_t_2) < 0) __PYX_ERR(9, 12, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "asyncpg/protocol/codecs/datetime.pyx":14 + * timedelta = datetime.timedelta + * + * pg_epoch_datetime = datetime.datetime(2000, 1, 1) # <<<<<<<<<<<<<< + * cdef int32_t pg_epoch_datetime_ts = \ + * cpython.PyLong_AsLong(int(pg_epoch_datetime.timestamp())) + */ + __pyx_t_2 = __Pyx_GetModuleGlobalName(__pyx_n_s_datetime); if (unlikely(!__pyx_t_2)) __PYX_ERR(9, 14, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_datetime); if (unlikely(!__pyx_t_1)) __PYX_ERR(9, 14, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_tuple__84, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(9, 14, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + if (PyDict_SetItem(__pyx_d, __pyx_n_s_pg_epoch_datetime, __pyx_t_2) < 0) __PYX_ERR(9, 14, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "asyncpg/protocol/codecs/datetime.pyx":16 + * pg_epoch_datetime = datetime.datetime(2000, 1, 1) + * cdef int32_t pg_epoch_datetime_ts = \ + * cpython.PyLong_AsLong(int(pg_epoch_datetime.timestamp())) # <<<<<<<<<<<<<< + * + * pg_epoch_datetime_utc = datetime.datetime(2000, 1, 1, tzinfo=utc) + */ + __pyx_t_1 = __Pyx_GetModuleGlobalName(__pyx_n_s_pg_epoch_datetime); if (unlikely(!__pyx_t_1)) __PYX_ERR(9, 16, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_timestamp); if (unlikely(!__pyx_t_3)) __PYX_ERR(9, 16, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_1 = NULL; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_3))) { + __pyx_t_1 = PyMethod_GET_SELF(__pyx_t_3); + if (likely(__pyx_t_1)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); + __Pyx_INCREF(__pyx_t_1); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_3, function); + } + } + if (__pyx_t_1) { + __pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(9, 16, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + } else { + __pyx_t_2 = __Pyx_PyObject_CallNoArg(__pyx_t_3); if (unlikely(!__pyx_t_2)) __PYX_ERR(9, 16, __pyx_L1_error) + } + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_3 = __Pyx_PyNumber_Int(__pyx_t_2); if (unlikely(!__pyx_t_3)) __PYX_ERR(9, 16, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_5 = PyLong_AsLong(__pyx_t_3); if (unlikely(__pyx_t_5 == -1L && PyErr_Occurred())) __PYX_ERR(9, 16, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_v_7asyncpg_8protocol_8protocol_pg_epoch_datetime_ts = ((int32_t)__pyx_t_5); + + /* "asyncpg/protocol/codecs/datetime.pyx":18 + * cpython.PyLong_AsLong(int(pg_epoch_datetime.timestamp())) + * + * pg_epoch_datetime_utc = datetime.datetime(2000, 1, 1, tzinfo=utc) # <<<<<<<<<<<<<< + * cdef int32_t pg_epoch_datetime_utc_ts = \ + * cpython.PyLong_AsLong(pg_epoch_datetime_utc.timestamp()) + */ + __pyx_t_3 = __Pyx_GetModuleGlobalName(__pyx_n_s_datetime); if (unlikely(!__pyx_t_3)) __PYX_ERR(9, 18, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_datetime); if (unlikely(!__pyx_t_2)) __PYX_ERR(9, 18, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_3 = PyDict_New(); if (unlikely(!__pyx_t_3)) __PYX_ERR(9, 18, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_1 = __Pyx_GetModuleGlobalName(__pyx_n_s_utc); if (unlikely(!__pyx_t_1)) __PYX_ERR(9, 18, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (PyDict_SetItem(__pyx_t_3, __pyx_n_s_tzinfo, __pyx_t_1) < 0) __PYX_ERR(9, 18, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_tuple__85, __pyx_t_3); if (unlikely(!__pyx_t_1)) __PYX_ERR(9, 18, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (PyDict_SetItem(__pyx_d, __pyx_n_s_pg_epoch_datetime_utc, __pyx_t_1) < 0) __PYX_ERR(9, 18, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "asyncpg/protocol/codecs/datetime.pyx":20 + * pg_epoch_datetime_utc = datetime.datetime(2000, 1, 1, tzinfo=utc) + * cdef int32_t pg_epoch_datetime_utc_ts = \ + * cpython.PyLong_AsLong(pg_epoch_datetime_utc.timestamp()) # <<<<<<<<<<<<<< + * + * pg_epoch_date = datetime.date(2000, 1, 1) + */ + __pyx_t_3 = __Pyx_GetModuleGlobalName(__pyx_n_s_pg_epoch_datetime_utc); if (unlikely(!__pyx_t_3)) __PYX_ERR(9, 20, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_timestamp); if (unlikely(!__pyx_t_2)) __PYX_ERR(9, 20, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_3 = NULL; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_3)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_3); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + } + } + if (__pyx_t_3) { + __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_3); if (unlikely(!__pyx_t_1)) __PYX_ERR(9, 20, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + } else { + __pyx_t_1 = __Pyx_PyObject_CallNoArg(__pyx_t_2); if (unlikely(!__pyx_t_1)) __PYX_ERR(9, 20, __pyx_L1_error) + } + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_5 = PyLong_AsLong(__pyx_t_1); if (unlikely(__pyx_t_5 == -1L && PyErr_Occurred())) __PYX_ERR(9, 20, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_v_7asyncpg_8protocol_8protocol_pg_epoch_datetime_utc_ts = ((int32_t)__pyx_t_5); + + /* "asyncpg/protocol/codecs/datetime.pyx":22 + * cpython.PyLong_AsLong(pg_epoch_datetime_utc.timestamp()) + * + * pg_epoch_date = datetime.date(2000, 1, 1) # <<<<<<<<<<<<<< + * cdef int32_t pg_date_offset_ord = \ + * cpython.PyLong_AsLong(pg_epoch_date.toordinal()) + */ + __pyx_t_1 = __Pyx_GetModuleGlobalName(__pyx_n_s_datetime); if (unlikely(!__pyx_t_1)) __PYX_ERR(9, 22, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_date); if (unlikely(!__pyx_t_2)) __PYX_ERR(9, 22, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_tuple__86, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(9, 22, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + if (PyDict_SetItem(__pyx_d, __pyx_n_s_pg_epoch_date, __pyx_t_1) < 0) __PYX_ERR(9, 22, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "asyncpg/protocol/codecs/datetime.pyx":24 + * pg_epoch_date = datetime.date(2000, 1, 1) + * cdef int32_t pg_date_offset_ord = \ + * cpython.PyLong_AsLong(pg_epoch_date.toordinal()) # <<<<<<<<<<<<<< + * + * # Binary representations of infinity for datetimes. + */ + __pyx_t_2 = __Pyx_GetModuleGlobalName(__pyx_n_s_pg_epoch_date); if (unlikely(!__pyx_t_2)) __PYX_ERR(9, 24, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_toordinal); if (unlikely(!__pyx_t_3)) __PYX_ERR(9, 24, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_2 = NULL; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_3))) { + __pyx_t_2 = PyMethod_GET_SELF(__pyx_t_3); + if (likely(__pyx_t_2)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); + __Pyx_INCREF(__pyx_t_2); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_3, function); + } + } + if (__pyx_t_2) { + __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_2); if (unlikely(!__pyx_t_1)) __PYX_ERR(9, 24, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } else { + __pyx_t_1 = __Pyx_PyObject_CallNoArg(__pyx_t_3); if (unlikely(!__pyx_t_1)) __PYX_ERR(9, 24, __pyx_L1_error) + } + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_5 = PyLong_AsLong(__pyx_t_1); if (unlikely(__pyx_t_5 == -1L && PyErr_Occurred())) __PYX_ERR(9, 24, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_v_7asyncpg_8protocol_8protocol_pg_date_offset_ord = ((int32_t)__pyx_t_5); + + /* "asyncpg/protocol/codecs/datetime.pyx":27 + * + * # Binary representations of infinity for datetimes. + * cdef int64_t pg_time64_infinity = 0x7fffffffffffffff # <<<<<<<<<<<<<< + * cdef int64_t pg_time64_negative_infinity = 0x8000000000000000 + * cdef int32_t pg_date_infinity = 0x7fffffff + */ + __pyx_v_7asyncpg_8protocol_8protocol_pg_time64_infinity = 0x7fffffffffffffff; + + /* "asyncpg/protocol/codecs/datetime.pyx":28 + * # Binary representations of infinity for datetimes. + * cdef int64_t pg_time64_infinity = 0x7fffffffffffffff + * cdef int64_t pg_time64_negative_infinity = 0x8000000000000000 # <<<<<<<<<<<<<< + * cdef int32_t pg_date_infinity = 0x7fffffff + * cdef int32_t pg_date_negative_infinity = 0x80000000 + */ + __pyx_v_7asyncpg_8protocol_8protocol_pg_time64_negative_infinity = ((int64_t)0x8000000000000000); + + /* "asyncpg/protocol/codecs/datetime.pyx":29 + * cdef int64_t pg_time64_infinity = 0x7fffffffffffffff + * cdef int64_t pg_time64_negative_infinity = 0x8000000000000000 + * cdef int32_t pg_date_infinity = 0x7fffffff # <<<<<<<<<<<<<< + * cdef int32_t pg_date_negative_infinity = 0x80000000 + * + */ + __pyx_v_7asyncpg_8protocol_8protocol_pg_date_infinity = 0x7fffffff; + + /* "asyncpg/protocol/codecs/datetime.pyx":30 + * cdef int64_t pg_time64_negative_infinity = 0x8000000000000000 + * cdef int32_t pg_date_infinity = 0x7fffffff + * cdef int32_t pg_date_negative_infinity = 0x80000000 # <<<<<<<<<<<<<< + * + * infinity_datetime = datetime.datetime( + */ + __pyx_v_7asyncpg_8protocol_8protocol_pg_date_negative_infinity = ((int32_t)0x80000000); + + /* "asyncpg/protocol/codecs/datetime.pyx":32 + * cdef int32_t pg_date_negative_infinity = 0x80000000 + * + * infinity_datetime = datetime.datetime( # <<<<<<<<<<<<<< + * datetime.MAXYEAR, 12, 31, 23, 59, 59, 999999) + * + */ + __pyx_t_3 = __Pyx_GetModuleGlobalName(__pyx_n_s_datetime); if (unlikely(!__pyx_t_3)) __PYX_ERR(9, 32, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_datetime); if (unlikely(!__pyx_t_2)) __PYX_ERR(9, 32, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + + /* "asyncpg/protocol/codecs/datetime.pyx":33 + * + * infinity_datetime = datetime.datetime( + * datetime.MAXYEAR, 12, 31, 23, 59, 59, 999999) # <<<<<<<<<<<<<< + * + * cdef int32_t infinity_datetime_ord = cpython.PyLong_AsLong( + */ + __pyx_t_3 = __Pyx_GetModuleGlobalName(__pyx_n_s_datetime); if (unlikely(!__pyx_t_3)) __PYX_ERR(9, 33, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_MAXYEAR); if (unlikely(!__pyx_t_4)) __PYX_ERR(9, 33, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_3 = NULL; + __pyx_t_6 = 0; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_3)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_3); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + __pyx_t_6 = 1; + } + } + #if CYTHON_FAST_PYCALL + if (PyFunction_Check(__pyx_t_2)) { + PyObject *__pyx_temp[8] = {__pyx_t_3, __pyx_t_4, __pyx_int_12, __pyx_int_31, __pyx_int_23, __pyx_int_59, __pyx_int_59, __pyx_int_999999}; + __pyx_t_1 = __Pyx_PyFunction_FastCall(__pyx_t_2, __pyx_temp+1-__pyx_t_6, 7+__pyx_t_6); if (unlikely(!__pyx_t_1)) __PYX_ERR(9, 32, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + } else + #endif + #if CYTHON_FAST_PYCCALL + if (__Pyx_PyFastCFunction_Check(__pyx_t_2)) { + PyObject *__pyx_temp[8] = {__pyx_t_3, __pyx_t_4, __pyx_int_12, __pyx_int_31, __pyx_int_23, __pyx_int_59, __pyx_int_59, __pyx_int_999999}; + __pyx_t_1 = __Pyx_PyCFunction_FastCall(__pyx_t_2, __pyx_temp+1-__pyx_t_6, 7+__pyx_t_6); if (unlikely(!__pyx_t_1)) __PYX_ERR(9, 32, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + } else + #endif + { + __pyx_t_7 = PyTuple_New(7+__pyx_t_6); if (unlikely(!__pyx_t_7)) __PYX_ERR(9, 32, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + if (__pyx_t_3) { + __Pyx_GIVEREF(__pyx_t_3); PyTuple_SET_ITEM(__pyx_t_7, 0, __pyx_t_3); __pyx_t_3 = NULL; + } + __Pyx_GIVEREF(__pyx_t_4); + PyTuple_SET_ITEM(__pyx_t_7, 0+__pyx_t_6, __pyx_t_4); + __Pyx_INCREF(__pyx_int_12); + __Pyx_GIVEREF(__pyx_int_12); + PyTuple_SET_ITEM(__pyx_t_7, 1+__pyx_t_6, __pyx_int_12); + __Pyx_INCREF(__pyx_int_31); + __Pyx_GIVEREF(__pyx_int_31); + PyTuple_SET_ITEM(__pyx_t_7, 2+__pyx_t_6, __pyx_int_31); + __Pyx_INCREF(__pyx_int_23); + __Pyx_GIVEREF(__pyx_int_23); + PyTuple_SET_ITEM(__pyx_t_7, 3+__pyx_t_6, __pyx_int_23); + __Pyx_INCREF(__pyx_int_59); + __Pyx_GIVEREF(__pyx_int_59); + PyTuple_SET_ITEM(__pyx_t_7, 4+__pyx_t_6, __pyx_int_59); + __Pyx_INCREF(__pyx_int_59); + __Pyx_GIVEREF(__pyx_int_59); + PyTuple_SET_ITEM(__pyx_t_7, 5+__pyx_t_6, __pyx_int_59); + __Pyx_INCREF(__pyx_int_999999); + __Pyx_GIVEREF(__pyx_int_999999); + PyTuple_SET_ITEM(__pyx_t_7, 6+__pyx_t_6, __pyx_int_999999); + __pyx_t_4 = 0; + __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_t_7, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(9, 32, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + } + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + if (PyDict_SetItem(__pyx_d, __pyx_n_s_infinity_datetime, __pyx_t_1) < 0) __PYX_ERR(9, 32, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "asyncpg/protocol/codecs/datetime.pyx":36 + * + * cdef int32_t infinity_datetime_ord = cpython.PyLong_AsLong( + * infinity_datetime.toordinal()) # <<<<<<<<<<<<<< + * + * cdef int64_t infinity_datetime_ts = 252455615999999999 + */ + __pyx_t_2 = __Pyx_GetModuleGlobalName(__pyx_n_s_infinity_datetime); if (unlikely(!__pyx_t_2)) __PYX_ERR(9, 36, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_toordinal); if (unlikely(!__pyx_t_7)) __PYX_ERR(9, 36, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_2 = NULL; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_7))) { + __pyx_t_2 = PyMethod_GET_SELF(__pyx_t_7); + if (likely(__pyx_t_2)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_7); + __Pyx_INCREF(__pyx_t_2); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_7, function); + } + } + if (__pyx_t_2) { + __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_t_7, __pyx_t_2); if (unlikely(!__pyx_t_1)) __PYX_ERR(9, 36, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } else { + __pyx_t_1 = __Pyx_PyObject_CallNoArg(__pyx_t_7); if (unlikely(!__pyx_t_1)) __PYX_ERR(9, 36, __pyx_L1_error) + } + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + + /* "asyncpg/protocol/codecs/datetime.pyx":35 + * datetime.MAXYEAR, 12, 31, 23, 59, 59, 999999) + * + * cdef int32_t infinity_datetime_ord = cpython.PyLong_AsLong( # <<<<<<<<<<<<<< + * infinity_datetime.toordinal()) + * + */ + __pyx_t_5 = PyLong_AsLong(__pyx_t_1); if (unlikely(__pyx_t_5 == -1L && PyErr_Occurred())) __PYX_ERR(9, 35, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_v_7asyncpg_8protocol_8protocol_infinity_datetime_ord = ((int32_t)__pyx_t_5); + + /* "asyncpg/protocol/codecs/datetime.pyx":38 + * infinity_datetime.toordinal()) + * + * cdef int64_t infinity_datetime_ts = 252455615999999999 # <<<<<<<<<<<<<< + * + * negative_infinity_datetime = datetime.datetime( + */ + __pyx_v_7asyncpg_8protocol_8protocol_infinity_datetime_ts = 0x380E70B913B7FFF; + + /* "asyncpg/protocol/codecs/datetime.pyx":40 + * cdef int64_t infinity_datetime_ts = 252455615999999999 + * + * negative_infinity_datetime = datetime.datetime( # <<<<<<<<<<<<<< + * datetime.MINYEAR, 1, 1, 0, 0, 0, 0) + * + */ + __pyx_t_7 = __Pyx_GetModuleGlobalName(__pyx_n_s_datetime); if (unlikely(!__pyx_t_7)) __PYX_ERR(9, 40, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_7, __pyx_n_s_datetime); if (unlikely(!__pyx_t_2)) __PYX_ERR(9, 40, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + + /* "asyncpg/protocol/codecs/datetime.pyx":41 + * + * negative_infinity_datetime = datetime.datetime( + * datetime.MINYEAR, 1, 1, 0, 0, 0, 0) # <<<<<<<<<<<<<< + * + * cdef int32_t negative_infinity_datetime_ord = cpython.PyLong_AsLong( + */ + __pyx_t_7 = __Pyx_GetModuleGlobalName(__pyx_n_s_datetime); if (unlikely(!__pyx_t_7)) __PYX_ERR(9, 41, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_7, __pyx_n_s_MINYEAR); if (unlikely(!__pyx_t_4)) __PYX_ERR(9, 41, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __pyx_t_7 = NULL; + __pyx_t_6 = 0; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_7 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_7)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_7); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + __pyx_t_6 = 1; + } + } + #if CYTHON_FAST_PYCALL + if (PyFunction_Check(__pyx_t_2)) { + PyObject *__pyx_temp[8] = {__pyx_t_7, __pyx_t_4, __pyx_int_1, __pyx_int_1, __pyx_int_0, __pyx_int_0, __pyx_int_0, __pyx_int_0}; + __pyx_t_1 = __Pyx_PyFunction_FastCall(__pyx_t_2, __pyx_temp+1-__pyx_t_6, 7+__pyx_t_6); if (unlikely(!__pyx_t_1)) __PYX_ERR(9, 40, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + } else + #endif + #if CYTHON_FAST_PYCCALL + if (__Pyx_PyFastCFunction_Check(__pyx_t_2)) { + PyObject *__pyx_temp[8] = {__pyx_t_7, __pyx_t_4, __pyx_int_1, __pyx_int_1, __pyx_int_0, __pyx_int_0, __pyx_int_0, __pyx_int_0}; + __pyx_t_1 = __Pyx_PyCFunction_FastCall(__pyx_t_2, __pyx_temp+1-__pyx_t_6, 7+__pyx_t_6); if (unlikely(!__pyx_t_1)) __PYX_ERR(9, 40, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + } else + #endif + { + __pyx_t_3 = PyTuple_New(7+__pyx_t_6); if (unlikely(!__pyx_t_3)) __PYX_ERR(9, 40, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + if (__pyx_t_7) { + __Pyx_GIVEREF(__pyx_t_7); PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_t_7); __pyx_t_7 = NULL; + } + __Pyx_GIVEREF(__pyx_t_4); + PyTuple_SET_ITEM(__pyx_t_3, 0+__pyx_t_6, __pyx_t_4); + __Pyx_INCREF(__pyx_int_1); + __Pyx_GIVEREF(__pyx_int_1); + PyTuple_SET_ITEM(__pyx_t_3, 1+__pyx_t_6, __pyx_int_1); + __Pyx_INCREF(__pyx_int_1); + __Pyx_GIVEREF(__pyx_int_1); + PyTuple_SET_ITEM(__pyx_t_3, 2+__pyx_t_6, __pyx_int_1); + __Pyx_INCREF(__pyx_int_0); + __Pyx_GIVEREF(__pyx_int_0); + PyTuple_SET_ITEM(__pyx_t_3, 3+__pyx_t_6, __pyx_int_0); + __Pyx_INCREF(__pyx_int_0); + __Pyx_GIVEREF(__pyx_int_0); + PyTuple_SET_ITEM(__pyx_t_3, 4+__pyx_t_6, __pyx_int_0); + __Pyx_INCREF(__pyx_int_0); + __Pyx_GIVEREF(__pyx_int_0); + PyTuple_SET_ITEM(__pyx_t_3, 5+__pyx_t_6, __pyx_int_0); + __Pyx_INCREF(__pyx_int_0); + __Pyx_GIVEREF(__pyx_int_0); + PyTuple_SET_ITEM(__pyx_t_3, 6+__pyx_t_6, __pyx_int_0); + __pyx_t_4 = 0; + __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_t_3, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(9, 40, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + } + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + if (PyDict_SetItem(__pyx_d, __pyx_n_s_negative_infinity_datetime, __pyx_t_1) < 0) __PYX_ERR(9, 40, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "asyncpg/protocol/codecs/datetime.pyx":44 + * + * cdef int32_t negative_infinity_datetime_ord = cpython.PyLong_AsLong( + * negative_infinity_datetime.toordinal()) # <<<<<<<<<<<<<< + * + * cdef int64_t negative_infinity_datetime_ts = -63082281600000000 + */ + __pyx_t_2 = __Pyx_GetModuleGlobalName(__pyx_n_s_negative_infinity_datetime); if (unlikely(!__pyx_t_2)) __PYX_ERR(9, 44, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_toordinal); if (unlikely(!__pyx_t_3)) __PYX_ERR(9, 44, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_2 = NULL; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_3))) { + __pyx_t_2 = PyMethod_GET_SELF(__pyx_t_3); + if (likely(__pyx_t_2)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); + __Pyx_INCREF(__pyx_t_2); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_3, function); + } + } + if (__pyx_t_2) { + __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_2); if (unlikely(!__pyx_t_1)) __PYX_ERR(9, 44, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } else { + __pyx_t_1 = __Pyx_PyObject_CallNoArg(__pyx_t_3); if (unlikely(!__pyx_t_1)) __PYX_ERR(9, 44, __pyx_L1_error) + } + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + + /* "asyncpg/protocol/codecs/datetime.pyx":43 + * datetime.MINYEAR, 1, 1, 0, 0, 0, 0) + * + * cdef int32_t negative_infinity_datetime_ord = cpython.PyLong_AsLong( # <<<<<<<<<<<<<< + * negative_infinity_datetime.toordinal()) + * + */ + __pyx_t_5 = PyLong_AsLong(__pyx_t_1); if (unlikely(__pyx_t_5 == -1L && PyErr_Occurred())) __PYX_ERR(9, 43, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_v_7asyncpg_8protocol_8protocol_negative_infinity_datetime_ord = ((int32_t)__pyx_t_5); + + /* "asyncpg/protocol/codecs/datetime.pyx":46 + * negative_infinity_datetime.toordinal()) + * + * cdef int64_t negative_infinity_datetime_ts = -63082281600000000 # <<<<<<<<<<<<<< + * + * infinity_date = datetime.date(datetime.MAXYEAR, 12, 31) + */ + __pyx_v_7asyncpg_8protocol_8protocol_negative_infinity_datetime_ts = -63082281600000000L; + + /* "asyncpg/protocol/codecs/datetime.pyx":48 + * cdef int64_t negative_infinity_datetime_ts = -63082281600000000 + * + * infinity_date = datetime.date(datetime.MAXYEAR, 12, 31) # <<<<<<<<<<<<<< + * + * cdef int32_t infinity_date_ord = cpython.PyLong_AsLong( + */ + __pyx_t_3 = __Pyx_GetModuleGlobalName(__pyx_n_s_datetime); if (unlikely(!__pyx_t_3)) __PYX_ERR(9, 48, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_date); if (unlikely(!__pyx_t_2)) __PYX_ERR(9, 48, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_3 = __Pyx_GetModuleGlobalName(__pyx_n_s_datetime); if (unlikely(!__pyx_t_3)) __PYX_ERR(9, 48, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_MAXYEAR); if (unlikely(!__pyx_t_4)) __PYX_ERR(9, 48, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_3 = NULL; + __pyx_t_6 = 0; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_3)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_3); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + __pyx_t_6 = 1; + } + } + #if CYTHON_FAST_PYCALL + if (PyFunction_Check(__pyx_t_2)) { + PyObject *__pyx_temp[4] = {__pyx_t_3, __pyx_t_4, __pyx_int_12, __pyx_int_31}; + __pyx_t_1 = __Pyx_PyFunction_FastCall(__pyx_t_2, __pyx_temp+1-__pyx_t_6, 3+__pyx_t_6); if (unlikely(!__pyx_t_1)) __PYX_ERR(9, 48, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + } else + #endif + #if CYTHON_FAST_PYCCALL + if (__Pyx_PyFastCFunction_Check(__pyx_t_2)) { + PyObject *__pyx_temp[4] = {__pyx_t_3, __pyx_t_4, __pyx_int_12, __pyx_int_31}; + __pyx_t_1 = __Pyx_PyCFunction_FastCall(__pyx_t_2, __pyx_temp+1-__pyx_t_6, 3+__pyx_t_6); if (unlikely(!__pyx_t_1)) __PYX_ERR(9, 48, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + } else + #endif + { + __pyx_t_7 = PyTuple_New(3+__pyx_t_6); if (unlikely(!__pyx_t_7)) __PYX_ERR(9, 48, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + if (__pyx_t_3) { + __Pyx_GIVEREF(__pyx_t_3); PyTuple_SET_ITEM(__pyx_t_7, 0, __pyx_t_3); __pyx_t_3 = NULL; + } + __Pyx_GIVEREF(__pyx_t_4); + PyTuple_SET_ITEM(__pyx_t_7, 0+__pyx_t_6, __pyx_t_4); + __Pyx_INCREF(__pyx_int_12); + __Pyx_GIVEREF(__pyx_int_12); + PyTuple_SET_ITEM(__pyx_t_7, 1+__pyx_t_6, __pyx_int_12); + __Pyx_INCREF(__pyx_int_31); + __Pyx_GIVEREF(__pyx_int_31); + PyTuple_SET_ITEM(__pyx_t_7, 2+__pyx_t_6, __pyx_int_31); + __pyx_t_4 = 0; + __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_t_7, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(9, 48, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + } + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + if (PyDict_SetItem(__pyx_d, __pyx_n_s_infinity_date, __pyx_t_1) < 0) __PYX_ERR(9, 48, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "asyncpg/protocol/codecs/datetime.pyx":51 + * + * cdef int32_t infinity_date_ord = cpython.PyLong_AsLong( + * infinity_date.toordinal()) # <<<<<<<<<<<<<< + * + * negative_infinity_date = datetime.date(datetime.MINYEAR, 1, 1) + */ + __pyx_t_2 = __Pyx_GetModuleGlobalName(__pyx_n_s_infinity_date); if (unlikely(!__pyx_t_2)) __PYX_ERR(9, 51, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_toordinal); if (unlikely(!__pyx_t_7)) __PYX_ERR(9, 51, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_2 = NULL; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_7))) { + __pyx_t_2 = PyMethod_GET_SELF(__pyx_t_7); + if (likely(__pyx_t_2)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_7); + __Pyx_INCREF(__pyx_t_2); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_7, function); + } + } + if (__pyx_t_2) { + __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_t_7, __pyx_t_2); if (unlikely(!__pyx_t_1)) __PYX_ERR(9, 51, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } else { + __pyx_t_1 = __Pyx_PyObject_CallNoArg(__pyx_t_7); if (unlikely(!__pyx_t_1)) __PYX_ERR(9, 51, __pyx_L1_error) + } + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + + /* "asyncpg/protocol/codecs/datetime.pyx":50 + * infinity_date = datetime.date(datetime.MAXYEAR, 12, 31) + * + * cdef int32_t infinity_date_ord = cpython.PyLong_AsLong( # <<<<<<<<<<<<<< + * infinity_date.toordinal()) + * + */ + __pyx_t_5 = PyLong_AsLong(__pyx_t_1); if (unlikely(__pyx_t_5 == -1L && PyErr_Occurred())) __PYX_ERR(9, 50, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_v_7asyncpg_8protocol_8protocol_infinity_date_ord = ((int32_t)__pyx_t_5); + + /* "asyncpg/protocol/codecs/datetime.pyx":53 + * infinity_date.toordinal()) + * + * negative_infinity_date = datetime.date(datetime.MINYEAR, 1, 1) # <<<<<<<<<<<<<< + * + * cdef int32_t negative_infinity_date_ord = cpython.PyLong_AsLong( + */ + __pyx_t_7 = __Pyx_GetModuleGlobalName(__pyx_n_s_datetime); if (unlikely(!__pyx_t_7)) __PYX_ERR(9, 53, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_7, __pyx_n_s_date); if (unlikely(!__pyx_t_2)) __PYX_ERR(9, 53, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __pyx_t_7 = __Pyx_GetModuleGlobalName(__pyx_n_s_datetime); if (unlikely(!__pyx_t_7)) __PYX_ERR(9, 53, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_7, __pyx_n_s_MINYEAR); if (unlikely(!__pyx_t_4)) __PYX_ERR(9, 53, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __pyx_t_7 = NULL; + __pyx_t_6 = 0; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_7 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_7)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_7); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + __pyx_t_6 = 1; + } + } + #if CYTHON_FAST_PYCALL + if (PyFunction_Check(__pyx_t_2)) { + PyObject *__pyx_temp[4] = {__pyx_t_7, __pyx_t_4, __pyx_int_1, __pyx_int_1}; + __pyx_t_1 = __Pyx_PyFunction_FastCall(__pyx_t_2, __pyx_temp+1-__pyx_t_6, 3+__pyx_t_6); if (unlikely(!__pyx_t_1)) __PYX_ERR(9, 53, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + } else + #endif + #if CYTHON_FAST_PYCCALL + if (__Pyx_PyFastCFunction_Check(__pyx_t_2)) { + PyObject *__pyx_temp[4] = {__pyx_t_7, __pyx_t_4, __pyx_int_1, __pyx_int_1}; + __pyx_t_1 = __Pyx_PyCFunction_FastCall(__pyx_t_2, __pyx_temp+1-__pyx_t_6, 3+__pyx_t_6); if (unlikely(!__pyx_t_1)) __PYX_ERR(9, 53, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + } else + #endif + { + __pyx_t_3 = PyTuple_New(3+__pyx_t_6); if (unlikely(!__pyx_t_3)) __PYX_ERR(9, 53, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + if (__pyx_t_7) { + __Pyx_GIVEREF(__pyx_t_7); PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_t_7); __pyx_t_7 = NULL; + } + __Pyx_GIVEREF(__pyx_t_4); + PyTuple_SET_ITEM(__pyx_t_3, 0+__pyx_t_6, __pyx_t_4); + __Pyx_INCREF(__pyx_int_1); + __Pyx_GIVEREF(__pyx_int_1); + PyTuple_SET_ITEM(__pyx_t_3, 1+__pyx_t_6, __pyx_int_1); + __Pyx_INCREF(__pyx_int_1); + __Pyx_GIVEREF(__pyx_int_1); + PyTuple_SET_ITEM(__pyx_t_3, 2+__pyx_t_6, __pyx_int_1); + __pyx_t_4 = 0; + __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_t_3, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(9, 53, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + } + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + if (PyDict_SetItem(__pyx_d, __pyx_n_s_negative_infinity_date, __pyx_t_1) < 0) __PYX_ERR(9, 53, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "asyncpg/protocol/codecs/datetime.pyx":56 + * + * cdef int32_t negative_infinity_date_ord = cpython.PyLong_AsLong( + * negative_infinity_date.toordinal()) # <<<<<<<<<<<<<< + * + * + */ + __pyx_t_2 = __Pyx_GetModuleGlobalName(__pyx_n_s_negative_infinity_date); if (unlikely(!__pyx_t_2)) __PYX_ERR(9, 56, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_toordinal); if (unlikely(!__pyx_t_3)) __PYX_ERR(9, 56, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_2 = NULL; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_3))) { + __pyx_t_2 = PyMethod_GET_SELF(__pyx_t_3); + if (likely(__pyx_t_2)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); + __Pyx_INCREF(__pyx_t_2); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_3, function); + } + } + if (__pyx_t_2) { + __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_2); if (unlikely(!__pyx_t_1)) __PYX_ERR(9, 56, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } else { + __pyx_t_1 = __Pyx_PyObject_CallNoArg(__pyx_t_3); if (unlikely(!__pyx_t_1)) __PYX_ERR(9, 56, __pyx_L1_error) + } + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + + /* "asyncpg/protocol/codecs/datetime.pyx":55 + * negative_infinity_date = datetime.date(datetime.MINYEAR, 1, 1) + * + * cdef int32_t negative_infinity_date_ord = cpython.PyLong_AsLong( # <<<<<<<<<<<<<< + * negative_infinity_date.toordinal()) + * + */ + __pyx_t_5 = PyLong_AsLong(__pyx_t_1); if (unlikely(__pyx_t_5 == -1L && PyErr_Occurred())) __PYX_ERR(9, 55, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_v_7asyncpg_8protocol_8protocol_negative_infinity_date_ord = ((int32_t)__pyx_t_5); + + /* "asyncpg/protocol/codecs/datetime.pyx":311 + * PG_FORMAT_TEXT) + * + * init_datetime_codecs() # <<<<<<<<<<<<<< + */ + __pyx_t_1 = __pyx_f_7asyncpg_8protocol_8protocol_init_datetime_codecs(); if (unlikely(!__pyx_t_1)) __PYX_ERR(9, 311, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "asyncpg/protocol/codecs/float.pyx":49 + * + * + * init_float_codecs() # <<<<<<<<<<<<<< + */ + __pyx_t_1 = __pyx_f_7asyncpg_8protocol_8protocol_init_float_codecs(); if (unlikely(!__pyx_t_1)) __PYX_ERR(10, 49, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "asyncpg/protocol/codecs/geometry.pyx":8 + * + * + * from asyncpg.types import Box, Line, LineSegment, Path, Point, Polygon, Circle # <<<<<<<<<<<<<< + * + * + */ + __pyx_t_1 = PyList_New(7); if (unlikely(!__pyx_t_1)) __PYX_ERR(11, 8, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_INCREF(__pyx_n_s_Box); + __Pyx_GIVEREF(__pyx_n_s_Box); + PyList_SET_ITEM(__pyx_t_1, 0, __pyx_n_s_Box); + __Pyx_INCREF(__pyx_n_s_Line); + __Pyx_GIVEREF(__pyx_n_s_Line); + PyList_SET_ITEM(__pyx_t_1, 1, __pyx_n_s_Line); + __Pyx_INCREF(__pyx_n_s_LineSegment); + __Pyx_GIVEREF(__pyx_n_s_LineSegment); + PyList_SET_ITEM(__pyx_t_1, 2, __pyx_n_s_LineSegment); + __Pyx_INCREF(__pyx_n_s_Path); + __Pyx_GIVEREF(__pyx_n_s_Path); + PyList_SET_ITEM(__pyx_t_1, 3, __pyx_n_s_Path); + __Pyx_INCREF(__pyx_n_s_Point); + __Pyx_GIVEREF(__pyx_n_s_Point); + PyList_SET_ITEM(__pyx_t_1, 4, __pyx_n_s_Point); + __Pyx_INCREF(__pyx_n_s_Polygon); + __Pyx_GIVEREF(__pyx_n_s_Polygon); + PyList_SET_ITEM(__pyx_t_1, 5, __pyx_n_s_Polygon); + __Pyx_INCREF(__pyx_n_s_Circle); + __Pyx_GIVEREF(__pyx_n_s_Circle); + PyList_SET_ITEM(__pyx_t_1, 6, __pyx_n_s_Circle); + __pyx_t_3 = __Pyx_Import(__pyx_n_s_asyncpg_types, __pyx_t_1, 0); if (unlikely(!__pyx_t_3)) __PYX_ERR(11, 8, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_1 = __Pyx_ImportFrom(__pyx_t_3, __pyx_n_s_Box); if (unlikely(!__pyx_t_1)) __PYX_ERR(11, 8, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_Box, __pyx_t_1) < 0) __PYX_ERR(11, 8, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_1 = __Pyx_ImportFrom(__pyx_t_3, __pyx_n_s_Line); if (unlikely(!__pyx_t_1)) __PYX_ERR(11, 8, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_Line, __pyx_t_1) < 0) __PYX_ERR(11, 8, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_1 = __Pyx_ImportFrom(__pyx_t_3, __pyx_n_s_LineSegment); if (unlikely(!__pyx_t_1)) __PYX_ERR(11, 8, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_LineSegment, __pyx_t_1) < 0) __PYX_ERR(11, 8, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_1 = __Pyx_ImportFrom(__pyx_t_3, __pyx_n_s_Path); if (unlikely(!__pyx_t_1)) __PYX_ERR(11, 8, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_Path, __pyx_t_1) < 0) __PYX_ERR(11, 8, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_1 = __Pyx_ImportFrom(__pyx_t_3, __pyx_n_s_Point); if (unlikely(!__pyx_t_1)) __PYX_ERR(11, 8, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_Point, __pyx_t_1) < 0) __PYX_ERR(11, 8, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_1 = __Pyx_ImportFrom(__pyx_t_3, __pyx_n_s_Polygon); if (unlikely(!__pyx_t_1)) __PYX_ERR(11, 8, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_Polygon, __pyx_t_1) < 0) __PYX_ERR(11, 8, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_1 = __Pyx_ImportFrom(__pyx_t_3, __pyx_n_s_Circle); if (unlikely(!__pyx_t_1)) __PYX_ERR(11, 8, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_Circle, __pyx_t_1) < 0) __PYX_ERR(11, 8, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + + /* "asyncpg/protocol/codecs/geometry.pyx":205 + * + * + * init_geometry_codecs() # <<<<<<<<<<<<<< + */ + __pyx_t_3 = __pyx_f_7asyncpg_8protocol_8protocol_init_geometry_codecs(); if (unlikely(!__pyx_t_3)) __PYX_ERR(11, 205, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + + /* "asyncpg/protocol/codecs/int.pyx":79 + * + * + * init_int_codecs() # <<<<<<<<<<<<<< + */ + __pyx_t_3 = __pyx_f_7asyncpg_8protocol_8protocol_init_int_codecs(); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 79, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + + /* "asyncpg/protocol/codecs/json.pyx":42 + * PG_FORMAT_BINARY) + * + * init_json_codecs() # <<<<<<<<<<<<<< + */ + __pyx_t_3 = __pyx_f_7asyncpg_8protocol_8protocol_init_json_codecs(); if (unlikely(!__pyx_t_3)) __PYX_ERR(12, 42, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + + /* "asyncpg/protocol/codecs/money.pyx":20 + * + * + * init_monetary_codecs() # <<<<<<<<<<<<<< + */ + __pyx_t_3 = __pyx_f_7asyncpg_8protocol_8protocol_init_monetary_codecs(); if (unlikely(!__pyx_t_3)) __PYX_ERR(13, 20, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + + /* "asyncpg/protocol/codecs/network.pyx":8 + * + * + * import ipaddress # <<<<<<<<<<<<<< + * + * + */ + __pyx_t_3 = __Pyx_Import(__pyx_n_s_ipaddress, 0, 0); if (unlikely(!__pyx_t_3)) __PYX_ERR(14, 8, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_ipaddress, __pyx_t_3) < 0) __PYX_ERR(14, 8, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + + /* "asyncpg/protocol/codecs/network.pyx":17 + * + * + * _ipaddr = ipaddress.ip_address # <<<<<<<<<<<<<< + * _ipnet = ipaddress.ip_network + * + */ + __pyx_t_3 = __Pyx_GetModuleGlobalName(__pyx_n_s_ipaddress); if (unlikely(!__pyx_t_3)) __PYX_ERR(14, 17, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_ip_address); if (unlikely(!__pyx_t_1)) __PYX_ERR(14, 17, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (PyDict_SetItem(__pyx_d, __pyx_n_s_ipaddr, __pyx_t_1) < 0) __PYX_ERR(14, 17, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "asyncpg/protocol/codecs/network.pyx":18 + * + * _ipaddr = ipaddress.ip_address + * _ipnet = ipaddress.ip_network # <<<<<<<<<<<<<< + * + * + */ + __pyx_t_1 = __Pyx_GetModuleGlobalName(__pyx_n_s_ipaddress); if (unlikely(!__pyx_t_1)) __PYX_ERR(14, 18, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_ip_network); if (unlikely(!__pyx_t_3)) __PYX_ERR(14, 18, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + if (PyDict_SetItem(__pyx_d, __pyx_n_s_ipnet, __pyx_t_3) < 0) __PYX_ERR(14, 18, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + + /* "asyncpg/protocol/codecs/network.pyx":111 + * + * + * init_network_codecs() # <<<<<<<<<<<<<< + */ + __pyx_t_3 = __pyx_f_7asyncpg_8protocol_8protocol_init_network_codecs(); if (unlikely(!__pyx_t_3)) __PYX_ERR(14, 111, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + + /* "asyncpg/protocol/codecs/numeric.pyx":8 + * + * + * import decimal # <<<<<<<<<<<<<< + * + * + */ + __pyx_t_3 = __Pyx_Import(__pyx_n_s_decimal, 0, 0); if (unlikely(!__pyx_t_3)) __PYX_ERR(15, 8, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_decimal, __pyx_t_3) < 0) __PYX_ERR(15, 8, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + + /* "asyncpg/protocol/codecs/numeric.pyx":11 + * + * + * _Dec = decimal.Decimal # <<<<<<<<<<<<<< + * + * + */ + __pyx_t_3 = __Pyx_GetModuleGlobalName(__pyx_n_s_decimal); if (unlikely(!__pyx_t_3)) __PYX_ERR(15, 11, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_Decimal); if (unlikely(!__pyx_t_1)) __PYX_ERR(15, 11, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (PyDict_SetItem(__pyx_d, __pyx_n_s_Dec, __pyx_t_1) < 0) __PYX_ERR(15, 11, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "asyncpg/protocol/codecs/numeric.pyx":28 + * PG_FORMAT_TEXT) + * + * init_numeric_codecs() # <<<<<<<<<<<<<< + */ + __pyx_t_1 = __pyx_f_7asyncpg_8protocol_8protocol_init_numeric_codecs(); if (unlikely(!__pyx_t_1)) __PYX_ERR(15, 28, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "asyncpg/protocol/codecs/tsearch.pyx":26 + * + * + * init_tsearch_codecs() # <<<<<<<<<<<<<< + */ + __pyx_t_1 = __pyx_f_7asyncpg_8protocol_8protocol_init_tsearch_codecs(); if (unlikely(!__pyx_t_1)) __PYX_ERR(16, 26, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "asyncpg/protocol/codecs/txid.pyx":71 + * + * + * init_txid_codecs() # <<<<<<<<<<<<<< + */ + __pyx_t_1 = __pyx_f_7asyncpg_8protocol_8protocol_init_txid_codecs(); if (unlikely(!__pyx_t_1)) __PYX_ERR(17, 71, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "asyncpg/protocol/codecs/uuid.pyx":8 + * + * + * import uuid # <<<<<<<<<<<<<< + * + * + */ + __pyx_t_1 = __Pyx_Import(__pyx_n_s_uuid, 0, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(18, 8, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_uuid, __pyx_t_1) < 0) __PYX_ERR(18, 8, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "asyncpg/protocol/codecs/uuid.pyx":11 + * + * + * _UUID = uuid.UUID # <<<<<<<<<<<<<< + * + * + */ + __pyx_t_1 = __Pyx_GetModuleGlobalName(__pyx_n_s_uuid); if (unlikely(!__pyx_t_1)) __PYX_ERR(18, 11, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_UUID_2); if (unlikely(!__pyx_t_3)) __PYX_ERR(18, 11, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + if (PyDict_SetItem(__pyx_d, __pyx_n_s_UUID, __pyx_t_3) < 0) __PYX_ERR(18, 11, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + + /* "asyncpg/protocol/codecs/uuid.pyx":31 + * PG_FORMAT_BINARY) + * + * init_uuid_codecs() # <<<<<<<<<<<<<< + */ + __pyx_t_3 = __pyx_f_7asyncpg_8protocol_8protocol_init_uuid_codecs(); if (unlikely(!__pyx_t_3)) __PYX_ERR(18, 31, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + + /* "asyncpg/protocol/codecs/misc.pyx":108 + * + * + * init_pseudo_codecs() # <<<<<<<<<<<<<< + */ + __pyx_t_3 = __pyx_f_7asyncpg_8protocol_8protocol_init_pseudo_codecs(); if (unlikely(!__pyx_t_3)) __PYX_ERR(19, 108, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + + /* "asyncpg/protocol/codecs/array.pyx":8 + * + * + * from collections.abc import Container as ContainerABC # <<<<<<<<<<<<<< + * + * + */ + __pyx_t_3 = PyList_New(1); if (unlikely(!__pyx_t_3)) __PYX_ERR(20, 8, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_INCREF(__pyx_n_s_Container); + __Pyx_GIVEREF(__pyx_n_s_Container); + PyList_SET_ITEM(__pyx_t_3, 0, __pyx_n_s_Container); + __pyx_t_1 = __Pyx_Import(__pyx_n_s_collections_abc, __pyx_t_3, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(20, 8, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_3 = __Pyx_ImportFrom(__pyx_t_1, __pyx_n_s_Container); if (unlikely(!__pyx_t_3)) __PYX_ERR(20, 8, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_ContainerABC, __pyx_t_3) < 0) __PYX_ERR(20, 8, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "asyncpg/protocol/codecs/array.pyx":14 + * + * # "NULL" + * cdef Py_UCS4 *APG_NULL = [0x004E, 0x0055, 0x004C, 0x004C, 0x0000] # <<<<<<<<<<<<<< + * + * + */ + __pyx_t_8[0] = 0x004E; + __pyx_t_8[1] = 0x0055; + __pyx_t_8[2] = 0x004C; + __pyx_t_8[3] = 0x004C; + __pyx_t_8[4] = 0x0000; + __pyx_v_7asyncpg_8protocol_8protocol_APG_NULL = __pyx_t_8; + + /* "asyncpg/protocol/codecs/array.pyx":789 + * PG_FORMAT_BINARY) + * + * init_array_codecs() # <<<<<<<<<<<<<< + */ + __pyx_t_1 = __pyx_f_7asyncpg_8protocol_8protocol_init_array_codecs(); if (unlikely(!__pyx_t_1)) __PYX_ERR(20, 789, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "asyncpg/protocol/codecs/range.pyx":8 + * + * + * from asyncpg import types as apg_types # <<<<<<<<<<<<<< + * + * # defined in postgresql/src/include/utils/rangetypes.h + */ + __pyx_t_1 = PyList_New(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(21, 8, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_INCREF(__pyx_n_s_types); + __Pyx_GIVEREF(__pyx_n_s_types); + PyList_SET_ITEM(__pyx_t_1, 0, __pyx_n_s_types); + __pyx_t_3 = __Pyx_Import(__pyx_n_s_asyncpg, __pyx_t_1, 0); if (unlikely(!__pyx_t_3)) __PYX_ERR(21, 8, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_1 = __Pyx_ImportFrom(__pyx_t_3, __pyx_n_s_types); if (unlikely(!__pyx_t_1)) __PYX_ERR(21, 8, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_apg_types, __pyx_t_1) < 0) __PYX_ERR(21, 8, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + + /* "asyncpg/protocol/codecs/range.pyx":149 + * + * + * init_range_codecs() # <<<<<<<<<<<<<< + */ + __pyx_t_3 = __pyx_f_7asyncpg_8protocol_8protocol_init_range_codecs(); if (unlikely(!__pyx_t_3)) __PYX_ERR(21, 149, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + + /* "asyncpg/protocol/codecs/record.pyx":57 + * PG_FORMAT_BINARY) + * + * init_record_codecs() # <<<<<<<<<<<<<< + */ + __pyx_t_3 = __pyx_f_7asyncpg_8protocol_8protocol_init_record_codecs(); if (unlikely(!__pyx_t_3)) __PYX_ERR(22, 57, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + + /* "asyncpg/protocol/codecs/hstore.pyx":82 + * PG_FORMAT_BINARY) + * + * init_hstore_codecs() # <<<<<<<<<<<<<< + */ + __pyx_t_3 = __pyx_f_7asyncpg_8protocol_8protocol_init_hstore_codecs(); if (unlikely(!__pyx_t_3)) __PYX_ERR(23, 82, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + + /* "asyncpg/protocol/coreproto.pyx":8 + * + * + * from hashlib import md5 as hashlib_md5 # for MD5 authentication # <<<<<<<<<<<<<< + * + * + */ + __pyx_t_3 = PyList_New(1); if (unlikely(!__pyx_t_3)) __PYX_ERR(4, 8, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_INCREF(__pyx_n_s_md5); + __Pyx_GIVEREF(__pyx_n_s_md5); + PyList_SET_ITEM(__pyx_t_3, 0, __pyx_n_s_md5); + __pyx_t_1 = __Pyx_Import(__pyx_n_s_hashlib, __pyx_t_3, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 8, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_3 = __Pyx_ImportFrom(__pyx_t_1, __pyx_n_s_md5); if (unlikely(!__pyx_t_3)) __PYX_ERR(4, 8, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_hashlib_md5, __pyx_t_3) < 0) __PYX_ERR(4, 8, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "asyncpg/protocol/coreproto.pyx":756 + * + * + * cdef bytes SYNC_MESSAGE = bytes(WriteBuffer.new_message(b'S').end_message()) # <<<<<<<<<<<<<< + */ + __pyx_t_1 = ((PyObject *)__pyx_f_7asyncpg_8protocol_8protocol_11WriteBuffer_new_message('S')); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 756, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_3 = __pyx_f_7asyncpg_8protocol_8protocol_11WriteBuffer_end_message(((struct __pyx_obj_7asyncpg_8protocol_8protocol_WriteBuffer *)__pyx_t_1)); if (unlikely(!__pyx_t_3)) __PYX_ERR(4, 756, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_1 = PyTuple_New(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 756, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_GIVEREF(__pyx_t_3); + PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_t_3); + __pyx_t_3 = 0; + __pyx_t_3 = __Pyx_PyObject_Call(((PyObject *)(&PyBytes_Type)), __pyx_t_1, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(4, 756, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_XGOTREF(__pyx_v_7asyncpg_8protocol_8protocol_SYNC_MESSAGE); + __Pyx_DECREF_SET(__pyx_v_7asyncpg_8protocol_8protocol_SYNC_MESSAGE, ((PyObject*)__pyx_t_3)); + __Pyx_GIVEREF(__pyx_t_3); + __pyx_t_3 = 0; + + /* "asyncpg/protocol/protocol.pyx":507 + * + * + * class Protocol(BaseProtocol, asyncio.Protocol): # <<<<<<<<<<<<<< + * pass + * + */ + __pyx_t_3 = __Pyx_GetModuleGlobalName(__pyx_n_s_asyncio); if (unlikely(!__pyx_t_3)) __PYX_ERR(27, 507, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_Protocol); if (unlikely(!__pyx_t_1)) __PYX_ERR(27, 507, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_3 = PyTuple_New(2); if (unlikely(!__pyx_t_3)) __PYX_ERR(27, 507, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_INCREF(((PyObject *)__pyx_ptype_7asyncpg_8protocol_8protocol_BaseProtocol)); + __Pyx_GIVEREF(((PyObject *)__pyx_ptype_7asyncpg_8protocol_8protocol_BaseProtocol)); + PyTuple_SET_ITEM(__pyx_t_3, 0, ((PyObject *)__pyx_ptype_7asyncpg_8protocol_8protocol_BaseProtocol)); + __Pyx_GIVEREF(__pyx_t_1); + PyTuple_SET_ITEM(__pyx_t_3, 1, __pyx_t_1); + __pyx_t_1 = 0; + __pyx_t_1 = __Pyx_CalculateMetaclass(NULL, __pyx_t_3); if (unlikely(!__pyx_t_1)) __PYX_ERR(27, 507, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = __Pyx_Py3MetaclassPrepare(__pyx_t_1, __pyx_t_3, __pyx_n_s_Protocol, __pyx_n_s_Protocol, (PyObject *) NULL, __pyx_n_s_asyncpg_protocol_protocol, (PyObject *) NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(27, 507, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_4 = __Pyx_Py3ClassCreate(__pyx_t_1, __pyx_n_s_Protocol, __pyx_t_3, __pyx_t_2, NULL, 0, 0); if (unlikely(!__pyx_t_4)) __PYX_ERR(27, 507, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_Protocol, __pyx_t_4) < 0) __PYX_ERR(27, 507, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + + /* "asyncpg/protocol/protocol.pyx":511 + * + * + * def _create_record(object mapping, tuple elems): # <<<<<<<<<<<<<< + * # Exposed only for testing purposes. + * + */ + __pyx_t_3 = PyCFunction_NewEx(&__pyx_mdef_7asyncpg_8protocol_8protocol_1_create_record, NULL, __pyx_n_s_asyncpg_protocol_protocol); if (unlikely(!__pyx_t_3)) __PYX_ERR(27, 511, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_create_record, __pyx_t_3) < 0) __PYX_ERR(27, 511, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + + /* "asyncpg/protocol/protocol.pyx":532 + * + * + * record.ApgRecord_InitTypes() # <<<<<<<<<<<<<< + */ + __pyx_t_6 = ApgRecord_InitTypes(); if (unlikely(__pyx_t_6 == -1)) __PYX_ERR(27, 532, __pyx_L1_error) + + /* "asyncpg/protocol/protocol.pyx":1 + * # Copyright (C) 2016-present the ayncpg authors and contributors # <<<<<<<<<<<<<< + * # + * # + */ + __pyx_t_3 = PyDict_New(); if (unlikely(!__pyx_t_3)) __PYX_ERR(27, 1, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_test, __pyx_t_3) < 0) __PYX_ERR(27, 1, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + + /* "hton.pxd":81 + * + * + * cdef inline double unpack_double(const char* buf): # <<<<<<<<<<<<<< + * cdef _doubleconv v + * v.i = unpack_int64(buf) + */ + + /*--- Wrapped vars code ---*/ + + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_XDECREF(__pyx_t_7); + if (__pyx_m) { + if (__pyx_d) { + __Pyx_AddTraceback("init asyncpg.protocol.protocol", __pyx_clineno, __pyx_lineno, __pyx_filename); + } + Py_DECREF(__pyx_m); __pyx_m = 0; + } else if (!PyErr_Occurred()) { + PyErr_SetString(PyExc_ImportError, "init asyncpg.protocol.protocol"); + } + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + #if PY_MAJOR_VERSION < 3 + return; + #else + return __pyx_m; + #endif +} + +/* --- Runtime support code --- */ +/* Refnanny */ +#if CYTHON_REFNANNY +static __Pyx_RefNannyAPIStruct *__Pyx_RefNannyImportAPI(const char *modname) { + PyObject *m = NULL, *p = NULL; + void *r = NULL; + m = PyImport_ImportModule((char *)modname); + if (!m) goto end; + p = PyObject_GetAttrString(m, (char *)"RefNannyAPI"); + if (!p) goto end; + r = PyLong_AsVoidPtr(p); +end: + Py_XDECREF(p); + Py_XDECREF(m); + return (__Pyx_RefNannyAPIStruct *)r; +} +#endif + +/* GetBuiltinName */ +static PyObject *__Pyx_GetBuiltinName(PyObject *name) { + PyObject* result = __Pyx_PyObject_GetAttrStr(__pyx_b, name); + if (unlikely(!result)) { + PyErr_Format(PyExc_NameError, +#if PY_MAJOR_VERSION >= 3 + "name '%U' is not defined", name); +#else + "name '%.200s' is not defined", PyString_AS_STRING(name)); +#endif + } + return result; +} + +/* dict_getitem_default */ +static PyObject* __Pyx_PyDict_GetItemDefault(PyObject* d, PyObject* key, PyObject* default_value) { + PyObject* value; +#if PY_MAJOR_VERSION >= 3 && !CYTHON_COMPILING_IN_PYPY + value = PyDict_GetItemWithError(d, key); + if (unlikely(!value)) { + if (unlikely(PyErr_Occurred())) + return NULL; + value = default_value; + } + Py_INCREF(value); +#else + if (PyString_CheckExact(key) || PyUnicode_CheckExact(key) || PyInt_CheckExact(key)) { + value = PyDict_GetItem(d, key); + if (unlikely(!value)) { + value = default_value; + } + Py_INCREF(value); + } else { + if (default_value == Py_None) + default_value = NULL; + value = PyObject_CallMethodObjArgs( + d, __pyx_n_s_get, key, default_value, NULL); + } +#endif + return value; +} + +/* PyCFunctionFastCall */ +#if CYTHON_FAST_PYCCALL +static CYTHON_INLINE PyObject * __Pyx_PyCFunction_FastCall(PyObject *func_obj, PyObject **args, Py_ssize_t nargs) { + PyCFunctionObject *func = (PyCFunctionObject*)func_obj; + PyCFunction meth = PyCFunction_GET_FUNCTION(func); + PyObject *self = PyCFunction_GET_SELF(func); + assert(PyCFunction_Check(func)); + assert(METH_FASTCALL == (PyCFunction_GET_FLAGS(func) & ~(METH_CLASS | METH_STATIC | METH_COEXIST))); + assert(nargs >= 0); + assert(nargs == 0 || args != NULL); + /* _PyCFunction_FastCallDict() must not be called with an exception set, + because it may clear it (directly or indirectly) and so the + caller loses its exception */ + assert(!PyErr_Occurred()); + return (*((__Pyx_PyCFunctionFast)meth)) (self, args, nargs, NULL); +} +#endif // CYTHON_FAST_PYCCALL + +/* PyFunctionFastCall */ +#if CYTHON_FAST_PYCALL +#include "frameobject.h" +static PyObject* __Pyx_PyFunction_FastCallNoKw(PyCodeObject *co, PyObject **args, Py_ssize_t na, + PyObject *globals) { + PyFrameObject *f; + PyThreadState *tstate = PyThreadState_GET(); + PyObject **fastlocals; + Py_ssize_t i; + PyObject *result; + assert(globals != NULL); + /* XXX Perhaps we should create a specialized + PyFrame_New() that doesn't take locals, but does + take builtins without sanity checking them. + */ + assert(tstate != NULL); + f = PyFrame_New(tstate, co, globals, NULL); + if (f == NULL) { + return NULL; + } + fastlocals = f->f_localsplus; + for (i = 0; i < na; i++) { + Py_INCREF(*args); + fastlocals[i] = *args++; + } + result = PyEval_EvalFrameEx(f,0); + ++tstate->recursion_depth; + Py_DECREF(f); + --tstate->recursion_depth; + return result; +} +#if 1 || PY_VERSION_HEX < 0x030600B1 +static PyObject *__Pyx_PyFunction_FastCallDict(PyObject *func, PyObject **args, int nargs, PyObject *kwargs) { + PyCodeObject *co = (PyCodeObject *)PyFunction_GET_CODE(func); + PyObject *globals = PyFunction_GET_GLOBALS(func); + PyObject *argdefs = PyFunction_GET_DEFAULTS(func); + PyObject *closure; +#if PY_MAJOR_VERSION >= 3 + PyObject *kwdefs; +#endif + PyObject *kwtuple, **k; + PyObject **d; + Py_ssize_t nd; + Py_ssize_t nk; + PyObject *result; + assert(kwargs == NULL || PyDict_Check(kwargs)); + nk = kwargs ? PyDict_Size(kwargs) : 0; + if (Py_EnterRecursiveCall((char*)" while calling a Python object")) { + return NULL; + } + if ( +#if PY_MAJOR_VERSION >= 3 + co->co_kwonlyargcount == 0 && +#endif + likely(kwargs == NULL || nk == 0) && + co->co_flags == (CO_OPTIMIZED | CO_NEWLOCALS | CO_NOFREE)) { + if (argdefs == NULL && co->co_argcount == nargs) { + result = __Pyx_PyFunction_FastCallNoKw(co, args, nargs, globals); + goto done; + } + else if (nargs == 0 && argdefs != NULL + && co->co_argcount == Py_SIZE(argdefs)) { + /* function called with no arguments, but all parameters have + a default value: use default values as arguments .*/ + args = &PyTuple_GET_ITEM(argdefs, 0); + result =__Pyx_PyFunction_FastCallNoKw(co, args, Py_SIZE(argdefs), globals); + goto done; + } + } + if (kwargs != NULL) { + Py_ssize_t pos, i; + kwtuple = PyTuple_New(2 * nk); + if (kwtuple == NULL) { + result = NULL; + goto done; + } + k = &PyTuple_GET_ITEM(kwtuple, 0); + pos = i = 0; + while (PyDict_Next(kwargs, &pos, &k[i], &k[i+1])) { + Py_INCREF(k[i]); + Py_INCREF(k[i+1]); + i += 2; + } + nk = i / 2; + } + else { + kwtuple = NULL; + k = NULL; + } + closure = PyFunction_GET_CLOSURE(func); +#if PY_MAJOR_VERSION >= 3 + kwdefs = PyFunction_GET_KW_DEFAULTS(func); +#endif + if (argdefs != NULL) { + d = &PyTuple_GET_ITEM(argdefs, 0); + nd = Py_SIZE(argdefs); + } + else { + d = NULL; + nd = 0; + } +#if PY_MAJOR_VERSION >= 3 + result = PyEval_EvalCodeEx((PyObject*)co, globals, (PyObject *)NULL, + args, nargs, + k, (int)nk, + d, (int)nd, kwdefs, closure); +#else + result = PyEval_EvalCodeEx(co, globals, (PyObject *)NULL, + args, nargs, + k, (int)nk, + d, (int)nd, closure); +#endif + Py_XDECREF(kwtuple); +done: + Py_LeaveRecursiveCall(); + return result; +} +#endif // CPython < 3.6 +#endif // CYTHON_FAST_PYCALL + +/* PyObjectCall */ +#if CYTHON_COMPILING_IN_CPYTHON +static CYTHON_INLINE PyObject* __Pyx_PyObject_Call(PyObject *func, PyObject *arg, PyObject *kw) { + PyObject *result; + ternaryfunc call = func->ob_type->tp_call; + if (unlikely(!call)) + return PyObject_Call(func, arg, kw); + if (unlikely(Py_EnterRecursiveCall((char*)" while calling a Python object"))) + return NULL; + result = (*call)(func, arg, kw); + Py_LeaveRecursiveCall(); + if (unlikely(!result) && unlikely(!PyErr_Occurred())) { + PyErr_SetString( + PyExc_SystemError, + "NULL result without error in PyObject_Call"); + } + return result; +} +#endif + +/* PyObjectCallMethO */ +#if CYTHON_COMPILING_IN_CPYTHON +static CYTHON_INLINE PyObject* __Pyx_PyObject_CallMethO(PyObject *func, PyObject *arg) { + PyObject *self, *result; + PyCFunction cfunc; + cfunc = PyCFunction_GET_FUNCTION(func); + self = PyCFunction_GET_SELF(func); + if (unlikely(Py_EnterRecursiveCall((char*)" while calling a Python object"))) + return NULL; + result = cfunc(self, arg); + Py_LeaveRecursiveCall(); + if (unlikely(!result) && unlikely(!PyErr_Occurred())) { + PyErr_SetString( + PyExc_SystemError, + "NULL result without error in PyObject_Call"); + } + return result; +} +#endif + +/* PyObjectCallOneArg */ +#if CYTHON_COMPILING_IN_CPYTHON +static PyObject* __Pyx__PyObject_CallOneArg(PyObject *func, PyObject *arg) { + PyObject *result; + PyObject *args = PyTuple_New(1); + if (unlikely(!args)) return NULL; + Py_INCREF(arg); + PyTuple_SET_ITEM(args, 0, arg); + result = __Pyx_PyObject_Call(func, args, NULL); + Py_DECREF(args); + return result; +} +static CYTHON_INLINE PyObject* __Pyx_PyObject_CallOneArg(PyObject *func, PyObject *arg) { +#if CYTHON_FAST_PYCALL + if (PyFunction_Check(func)) { + return __Pyx_PyFunction_FastCall(func, &arg, 1); + } +#endif +#ifdef __Pyx_CyFunction_USED + if (likely(PyCFunction_Check(func) || PyObject_TypeCheck(func, __pyx_CyFunctionType))) { +#else + if (likely(PyCFunction_Check(func))) { +#endif + if (likely(PyCFunction_GET_FLAGS(func) & METH_O)) { + return __Pyx_PyObject_CallMethO(func, arg); +#if CYTHON_FAST_PYCCALL + } else if (PyCFunction_GET_FLAGS(func) & METH_FASTCALL) { + return __Pyx_PyCFunction_FastCall(func, &arg, 1); +#endif + } + } + return __Pyx__PyObject_CallOneArg(func, arg); +} +#else +static CYTHON_INLINE PyObject* __Pyx_PyObject_CallOneArg(PyObject *func, PyObject *arg) { + PyObject *result; + PyObject *args = PyTuple_Pack(1, arg); + if (unlikely(!args)) return NULL; + result = __Pyx_PyObject_Call(func, args, NULL); + Py_DECREF(args); + return result; +} +#endif + +/* PyObjectCallNoArg */ + #if CYTHON_COMPILING_IN_CPYTHON +static CYTHON_INLINE PyObject* __Pyx_PyObject_CallNoArg(PyObject *func) { +#if CYTHON_FAST_PYCALL + if (PyFunction_Check(func)) { + return __Pyx_PyFunction_FastCall(func, NULL, 0); + } +#endif +#ifdef __Pyx_CyFunction_USED + if (likely(PyCFunction_Check(func) || PyObject_TypeCheck(func, __pyx_CyFunctionType))) { +#else + if (likely(PyCFunction_Check(func))) { +#endif + if (likely(PyCFunction_GET_FLAGS(func) & METH_NOARGS)) { + return __Pyx_PyObject_CallMethO(func, NULL); + } + } + return __Pyx_PyObject_Call(func, __pyx_empty_tuple, NULL); +} +#endif + +/* RaiseDoubleKeywords */ + static void __Pyx_RaiseDoubleKeywordsError( + const char* func_name, + PyObject* kw_name) +{ + PyErr_Format(PyExc_TypeError, + #if PY_MAJOR_VERSION >= 3 + "%s() got multiple values for keyword argument '%U'", func_name, kw_name); + #else + "%s() got multiple values for keyword argument '%s'", func_name, + PyString_AsString(kw_name)); + #endif +} + +/* ParseKeywords */ + static int __Pyx_ParseOptionalKeywords( + PyObject *kwds, + PyObject **argnames[], + PyObject *kwds2, + PyObject *values[], + Py_ssize_t num_pos_args, + const char* function_name) +{ + PyObject *key = 0, *value = 0; + Py_ssize_t pos = 0; + PyObject*** name; + PyObject*** first_kw_arg = argnames + num_pos_args; + while (PyDict_Next(kwds, &pos, &key, &value)) { + name = first_kw_arg; + while (*name && (**name != key)) name++; + if (*name) { + values[name-argnames] = value; + continue; + } + name = first_kw_arg; + #if PY_MAJOR_VERSION < 3 + if (likely(PyString_CheckExact(key)) || likely(PyString_Check(key))) { + while (*name) { + if ((CYTHON_COMPILING_IN_PYPY || PyString_GET_SIZE(**name) == PyString_GET_SIZE(key)) + && _PyString_Eq(**name, key)) { + values[name-argnames] = value; + break; + } + name++; + } + if (*name) continue; + else { + PyObject*** argname = argnames; + while (argname != first_kw_arg) { + if ((**argname == key) || ( + (CYTHON_COMPILING_IN_PYPY || PyString_GET_SIZE(**argname) == PyString_GET_SIZE(key)) + && _PyString_Eq(**argname, key))) { + goto arg_passed_twice; + } + argname++; + } + } + } else + #endif + if (likely(PyUnicode_Check(key))) { + while (*name) { + int cmp = (**name == key) ? 0 : + #if !CYTHON_COMPILING_IN_PYPY && PY_MAJOR_VERSION >= 3 + (PyUnicode_GET_SIZE(**name) != PyUnicode_GET_SIZE(key)) ? 1 : + #endif + PyUnicode_Compare(**name, key); + if (cmp < 0 && unlikely(PyErr_Occurred())) goto bad; + if (cmp == 0) { + values[name-argnames] = value; + break; + } + name++; + } + if (*name) continue; + else { + PyObject*** argname = argnames; + while (argname != first_kw_arg) { + int cmp = (**argname == key) ? 0 : + #if !CYTHON_COMPILING_IN_PYPY && PY_MAJOR_VERSION >= 3 + (PyUnicode_GET_SIZE(**argname) != PyUnicode_GET_SIZE(key)) ? 1 : + #endif + PyUnicode_Compare(**argname, key); + if (cmp < 0 && unlikely(PyErr_Occurred())) goto bad; + if (cmp == 0) goto arg_passed_twice; + argname++; + } + } + } else + goto invalid_keyword_type; + if (kwds2) { + if (unlikely(PyDict_SetItem(kwds2, key, value))) goto bad; + } else { + goto invalid_keyword; + } + } + return 0; +arg_passed_twice: + __Pyx_RaiseDoubleKeywordsError(function_name, key); + goto bad; +invalid_keyword_type: + PyErr_Format(PyExc_TypeError, + "%.200s() keywords must be strings", function_name); + goto bad; +invalid_keyword: + PyErr_Format(PyExc_TypeError, + #if PY_MAJOR_VERSION < 3 + "%.200s() got an unexpected keyword argument '%.200s'", + function_name, PyString_AsString(key)); + #else + "%s() got an unexpected keyword argument '%U'", + function_name, key); + #endif +bad: + return -1; +} + +/* RaiseArgTupleInvalid */ + static void __Pyx_RaiseArgtupleInvalid( + const char* func_name, + int exact, + Py_ssize_t num_min, + Py_ssize_t num_max, + Py_ssize_t num_found) +{ + Py_ssize_t num_expected; + const char *more_or_less; + if (num_found < num_min) { + num_expected = num_min; + more_or_less = "at least"; + } else { + num_expected = num_max; + more_or_less = "at most"; + } + if (exact) { + more_or_less = "exactly"; + } + PyErr_Format(PyExc_TypeError, + "%.200s() takes %.8s %" CYTHON_FORMAT_SSIZE_T "d positional argument%.1s (%" CYTHON_FORMAT_SSIZE_T "d given)", + func_name, more_or_less, num_expected, + (num_expected == 1) ? "" : "s", num_found); +} + +/* GetModuleGlobalName */ + static CYTHON_INLINE PyObject *__Pyx_GetModuleGlobalName(PyObject *name) { + PyObject *result; +#if !CYTHON_AVOID_BORROWED_REFS + result = PyDict_GetItem(__pyx_d, name); + if (likely(result)) { + Py_INCREF(result); + } else { +#else + result = PyObject_GetItem(__pyx_d, name); + if (!result) { + PyErr_Clear(); +#endif + result = __Pyx_GetBuiltinName(name); + } + return result; +} + +/* BytesEquals */ + static CYTHON_INLINE int __Pyx_PyBytes_Equals(PyObject* s1, PyObject* s2, int equals) { +#if CYTHON_COMPILING_IN_PYPY + return PyObject_RichCompareBool(s1, s2, equals); +#else + if (s1 == s2) { + return (equals == Py_EQ); + } else if (PyBytes_CheckExact(s1) & PyBytes_CheckExact(s2)) { + const char *ps1, *ps2; + Py_ssize_t length = PyBytes_GET_SIZE(s1); + if (length != PyBytes_GET_SIZE(s2)) + return (equals == Py_NE); + ps1 = PyBytes_AS_STRING(s1); + ps2 = PyBytes_AS_STRING(s2); + if (ps1[0] != ps2[0]) { + return (equals == Py_NE); + } else if (length == 1) { + return (equals == Py_EQ); + } else { + int result = memcmp(ps1, ps2, (size_t)length); + return (equals == Py_EQ) ? (result == 0) : (result != 0); + } + } else if ((s1 == Py_None) & PyBytes_CheckExact(s2)) { + return (equals == Py_NE); + } else if ((s2 == Py_None) & PyBytes_CheckExact(s1)) { + return (equals == Py_NE); + } else { + int result; + PyObject* py_result = PyObject_RichCompare(s1, s2, equals); + if (!py_result) + return -1; + result = __Pyx_PyObject_IsTrue(py_result); + Py_DECREF(py_result); + return result; + } +#endif +} + +/* UnicodeEquals */ + static CYTHON_INLINE int __Pyx_PyUnicode_Equals(PyObject* s1, PyObject* s2, int equals) { +#if CYTHON_COMPILING_IN_PYPY + return PyObject_RichCompareBool(s1, s2, equals); +#else +#if PY_MAJOR_VERSION < 3 + PyObject* owned_ref = NULL; +#endif + int s1_is_unicode, s2_is_unicode; + if (s1 == s2) { + goto return_eq; + } + s1_is_unicode = PyUnicode_CheckExact(s1); + s2_is_unicode = PyUnicode_CheckExact(s2); +#if PY_MAJOR_VERSION < 3 + if ((s1_is_unicode & (!s2_is_unicode)) && PyString_CheckExact(s2)) { + owned_ref = PyUnicode_FromObject(s2); + if (unlikely(!owned_ref)) + return -1; + s2 = owned_ref; + s2_is_unicode = 1; + } else if ((s2_is_unicode & (!s1_is_unicode)) && PyString_CheckExact(s1)) { + owned_ref = PyUnicode_FromObject(s1); + if (unlikely(!owned_ref)) + return -1; + s1 = owned_ref; + s1_is_unicode = 1; + } else if (((!s2_is_unicode) & (!s1_is_unicode))) { + return __Pyx_PyBytes_Equals(s1, s2, equals); + } +#endif + if (s1_is_unicode & s2_is_unicode) { + Py_ssize_t length; + int kind; + void *data1, *data2; + if (unlikely(__Pyx_PyUnicode_READY(s1) < 0) || unlikely(__Pyx_PyUnicode_READY(s2) < 0)) + return -1; + length = __Pyx_PyUnicode_GET_LENGTH(s1); + if (length != __Pyx_PyUnicode_GET_LENGTH(s2)) { + goto return_ne; + } + kind = __Pyx_PyUnicode_KIND(s1); + if (kind != __Pyx_PyUnicode_KIND(s2)) { + goto return_ne; + } + data1 = __Pyx_PyUnicode_DATA(s1); + data2 = __Pyx_PyUnicode_DATA(s2); + if (__Pyx_PyUnicode_READ(kind, data1, 0) != __Pyx_PyUnicode_READ(kind, data2, 0)) { + goto return_ne; + } else if (length == 1) { + goto return_eq; + } else { + int result = memcmp(data1, data2, (size_t)(length * kind)); + #if PY_MAJOR_VERSION < 3 + Py_XDECREF(owned_ref); + #endif + return (equals == Py_EQ) ? (result == 0) : (result != 0); + } + } else if ((s1 == Py_None) & s2_is_unicode) { + goto return_ne; + } else if ((s2 == Py_None) & s1_is_unicode) { + goto return_ne; + } else { + int result; + PyObject* py_result = PyObject_RichCompare(s1, s2, equals); + if (!py_result) + return -1; + result = __Pyx_PyObject_IsTrue(py_result); + Py_DECREF(py_result); + return result; + } +return_eq: + #if PY_MAJOR_VERSION < 3 + Py_XDECREF(owned_ref); + #endif + return (equals == Py_EQ); +return_ne: + #if PY_MAJOR_VERSION < 3 + Py_XDECREF(owned_ref); + #endif + return (equals == Py_NE); +#endif +} + +/* SaveResetException */ + #if CYTHON_FAST_THREAD_STATE +static CYTHON_INLINE void __Pyx__ExceptionSave(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb) { + *type = tstate->exc_type; + *value = tstate->exc_value; + *tb = tstate->exc_traceback; + Py_XINCREF(*type); + Py_XINCREF(*value); + Py_XINCREF(*tb); +} +static CYTHON_INLINE void __Pyx__ExceptionReset(PyThreadState *tstate, PyObject *type, PyObject *value, PyObject *tb) { + PyObject *tmp_type, *tmp_value, *tmp_tb; + tmp_type = tstate->exc_type; + tmp_value = tstate->exc_value; + tmp_tb = tstate->exc_traceback; + tstate->exc_type = type; + tstate->exc_value = value; + tstate->exc_traceback = tb; + Py_XDECREF(tmp_type); + Py_XDECREF(tmp_value); + Py_XDECREF(tmp_tb); +} +#endif + +/* PyErrExceptionMatches */ + #if CYTHON_FAST_THREAD_STATE +static CYTHON_INLINE int __Pyx_PyErr_ExceptionMatchesInState(PyThreadState* tstate, PyObject* err) { + PyObject *exc_type = tstate->curexc_type; + if (exc_type == err) return 1; + if (unlikely(!exc_type)) return 0; + return PyErr_GivenExceptionMatches(exc_type, err); +} +#endif + +/* GetException */ + #if CYTHON_FAST_THREAD_STATE +static int __Pyx__GetException(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb) { +#else +static int __Pyx_GetException(PyObject **type, PyObject **value, PyObject **tb) { +#endif + PyObject *local_type, *local_value, *local_tb; +#if CYTHON_FAST_THREAD_STATE + PyObject *tmp_type, *tmp_value, *tmp_tb; + local_type = tstate->curexc_type; + local_value = tstate->curexc_value; + local_tb = tstate->curexc_traceback; + tstate->curexc_type = 0; + tstate->curexc_value = 0; + tstate->curexc_traceback = 0; +#else + PyErr_Fetch(&local_type, &local_value, &local_tb); +#endif + PyErr_NormalizeException(&local_type, &local_value, &local_tb); +#if CYTHON_FAST_THREAD_STATE + if (unlikely(tstate->curexc_type)) +#else + if (unlikely(PyErr_Occurred())) +#endif + goto bad; + #if PY_MAJOR_VERSION >= 3 + if (local_tb) { + if (unlikely(PyException_SetTraceback(local_value, local_tb) < 0)) + goto bad; + } + #endif + Py_XINCREF(local_tb); + Py_XINCREF(local_type); + Py_XINCREF(local_value); + *type = local_type; + *value = local_value; + *tb = local_tb; +#if CYTHON_FAST_THREAD_STATE + tmp_type = tstate->exc_type; + tmp_value = tstate->exc_value; + tmp_tb = tstate->exc_traceback; + tstate->exc_type = local_type; + tstate->exc_value = local_value; + tstate->exc_traceback = local_tb; + Py_XDECREF(tmp_type); + Py_XDECREF(tmp_value); + Py_XDECREF(tmp_tb); +#else + PyErr_SetExcInfo(local_type, local_value, local_tb); +#endif + return 0; +bad: + *type = 0; + *value = 0; + *tb = 0; + Py_XDECREF(local_type); + Py_XDECREF(local_value); + Py_XDECREF(local_tb); + return -1; +} + +/* PyErrFetchRestore */ + #if CYTHON_FAST_THREAD_STATE +static CYTHON_INLINE void __Pyx_ErrRestoreInState(PyThreadState *tstate, PyObject *type, PyObject *value, PyObject *tb) { + PyObject *tmp_type, *tmp_value, *tmp_tb; + tmp_type = tstate->curexc_type; + tmp_value = tstate->curexc_value; + tmp_tb = tstate->curexc_traceback; + tstate->curexc_type = type; + tstate->curexc_value = value; + tstate->curexc_traceback = tb; + Py_XDECREF(tmp_type); + Py_XDECREF(tmp_value); + Py_XDECREF(tmp_tb); +} +static CYTHON_INLINE void __Pyx_ErrFetchInState(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb) { + *type = tstate->curexc_type; + *value = tstate->curexc_value; + *tb = tstate->curexc_traceback; + tstate->curexc_type = 0; + tstate->curexc_value = 0; + tstate->curexc_traceback = 0; +} +#endif + +/* RaiseException */ + #if PY_MAJOR_VERSION < 3 +static void __Pyx_Raise(PyObject *type, PyObject *value, PyObject *tb, + CYTHON_UNUSED PyObject *cause) { + __Pyx_PyThreadState_declare + Py_XINCREF(type); + if (!value || value == Py_None) + value = NULL; + else + Py_INCREF(value); + if (!tb || tb == Py_None) + tb = NULL; + else { + Py_INCREF(tb); + if (!PyTraceBack_Check(tb)) { + PyErr_SetString(PyExc_TypeError, + "raise: arg 3 must be a traceback or None"); + goto raise_error; + } + } + if (PyType_Check(type)) { +#if CYTHON_COMPILING_IN_PYPY + if (!value) { + Py_INCREF(Py_None); + value = Py_None; + } +#endif + PyErr_NormalizeException(&type, &value, &tb); + } else { + if (value) { + PyErr_SetString(PyExc_TypeError, + "instance exception may not have a separate value"); + goto raise_error; + } + value = type; + type = (PyObject*) Py_TYPE(type); + Py_INCREF(type); + if (!PyType_IsSubtype((PyTypeObject *)type, (PyTypeObject *)PyExc_BaseException)) { + PyErr_SetString(PyExc_TypeError, + "raise: exception class must be a subclass of BaseException"); + goto raise_error; + } + } + __Pyx_PyThreadState_assign + __Pyx_ErrRestore(type, value, tb); + return; +raise_error: + Py_XDECREF(value); + Py_XDECREF(type); + Py_XDECREF(tb); + return; +} +#else +static void __Pyx_Raise(PyObject *type, PyObject *value, PyObject *tb, PyObject *cause) { + PyObject* owned_instance = NULL; + if (tb == Py_None) { + tb = 0; + } else if (tb && !PyTraceBack_Check(tb)) { + PyErr_SetString(PyExc_TypeError, + "raise: arg 3 must be a traceback or None"); + goto bad; + } + if (value == Py_None) + value = 0; + if (PyExceptionInstance_Check(type)) { + if (value) { + PyErr_SetString(PyExc_TypeError, + "instance exception may not have a separate value"); + goto bad; + } + value = type; + type = (PyObject*) Py_TYPE(value); + } else if (PyExceptionClass_Check(type)) { + PyObject *instance_class = NULL; + if (value && PyExceptionInstance_Check(value)) { + instance_class = (PyObject*) Py_TYPE(value); + if (instance_class != type) { + int is_subclass = PyObject_IsSubclass(instance_class, type); + if (!is_subclass) { + instance_class = NULL; + } else if (unlikely(is_subclass == -1)) { + goto bad; + } else { + type = instance_class; + } + } + } + if (!instance_class) { + PyObject *args; + if (!value) + args = PyTuple_New(0); + else if (PyTuple_Check(value)) { + Py_INCREF(value); + args = value; + } else + args = PyTuple_Pack(1, value); + if (!args) + goto bad; + owned_instance = PyObject_Call(type, args, NULL); + Py_DECREF(args); + if (!owned_instance) + goto bad; + value = owned_instance; + if (!PyExceptionInstance_Check(value)) { + PyErr_Format(PyExc_TypeError, + "calling %R should have returned an instance of " + "BaseException, not %R", + type, Py_TYPE(value)); + goto bad; + } + } + } else { + PyErr_SetString(PyExc_TypeError, + "raise: exception class must be a subclass of BaseException"); + goto bad; + } +#if PY_VERSION_HEX >= 0x03030000 + if (cause) { +#else + if (cause && cause != Py_None) { +#endif + PyObject *fixed_cause; + if (cause == Py_None) { + fixed_cause = NULL; + } else if (PyExceptionClass_Check(cause)) { + fixed_cause = PyObject_CallObject(cause, NULL); + if (fixed_cause == NULL) + goto bad; + } else if (PyExceptionInstance_Check(cause)) { + fixed_cause = cause; + Py_INCREF(fixed_cause); + } else { + PyErr_SetString(PyExc_TypeError, + "exception causes must derive from " + "BaseException"); + goto bad; + } + PyException_SetCause(value, fixed_cause); + } + PyErr_SetObject(type, value); + if (tb) { +#if CYTHON_COMPILING_IN_PYPY + PyObject *tmp_type, *tmp_value, *tmp_tb; + PyErr_Fetch(&tmp_type, &tmp_value, &tmp_tb); + Py_INCREF(tb); + PyErr_Restore(tmp_type, tmp_value, tb); + Py_XDECREF(tmp_tb); +#else + PyThreadState *tstate = PyThreadState_GET(); + PyObject* tmp_tb = tstate->curexc_traceback; + if (tb != tmp_tb) { + Py_INCREF(tb); + tstate->curexc_traceback = tb; + Py_XDECREF(tmp_tb); + } +#endif + } +bad: + Py_XDECREF(owned_instance); + return; +} +#endif + +/* ExtTypeTest */ + static CYTHON_INLINE int __Pyx_TypeTest(PyObject *obj, PyTypeObject *type) { + if (unlikely(!type)) { + PyErr_SetString(PyExc_SystemError, "Missing type object"); + return 0; + } + if (likely(PyObject_TypeCheck(obj, type))) + return 1; + PyErr_Format(PyExc_TypeError, "Cannot convert %.200s to %.200s", + Py_TYPE(obj)->tp_name, type->tp_name); + return 0; +} + +/* KeywordStringCheck */ + static CYTHON_INLINE int __Pyx_CheckKeywordStrings( + PyObject *kwdict, + const char* function_name, + int kw_allowed) +{ + PyObject* key = 0; + Py_ssize_t pos = 0; +#if CYTHON_COMPILING_IN_PYPY + if (!kw_allowed && PyDict_Next(kwdict, &pos, &key, 0)) + goto invalid_keyword; + return 1; +#else + while (PyDict_Next(kwdict, &pos, &key, 0)) { + #if PY_MAJOR_VERSION < 3 + if (unlikely(!PyString_CheckExact(key)) && unlikely(!PyString_Check(key))) + #endif + if (unlikely(!PyUnicode_Check(key))) + goto invalid_keyword_type; + } + if ((!kw_allowed) && unlikely(key)) + goto invalid_keyword; + return 1; +invalid_keyword_type: + PyErr_Format(PyExc_TypeError, + "%.200s() keywords must be strings", function_name); + return 0; +#endif +invalid_keyword: + PyErr_Format(PyExc_TypeError, + #if PY_MAJOR_VERSION < 3 + "%.200s() got an unexpected keyword argument '%.200s'", + function_name, PyString_AsString(key)); + #else + "%s() got an unexpected keyword argument '%U'", + function_name, key); + #endif + return 0; +} + +/* WriteUnraisableException */ + static void __Pyx_WriteUnraisable(const char *name, CYTHON_UNUSED int clineno, + CYTHON_UNUSED int lineno, CYTHON_UNUSED const char *filename, + int full_traceback, CYTHON_UNUSED int nogil) { + PyObject *old_exc, *old_val, *old_tb; + PyObject *ctx; + __Pyx_PyThreadState_declare +#ifdef WITH_THREAD + PyGILState_STATE state; + if (nogil) + state = PyGILState_Ensure(); +#ifdef _MSC_VER + else state = (PyGILState_STATE)-1; +#endif +#endif + __Pyx_PyThreadState_assign + __Pyx_ErrFetch(&old_exc, &old_val, &old_tb); + if (full_traceback) { + Py_XINCREF(old_exc); + Py_XINCREF(old_val); + Py_XINCREF(old_tb); + __Pyx_ErrRestore(old_exc, old_val, old_tb); + PyErr_PrintEx(1); + } + #if PY_MAJOR_VERSION < 3 + ctx = PyString_FromString(name); + #else + ctx = PyUnicode_FromString(name); + #endif + __Pyx_ErrRestore(old_exc, old_val, old_tb); + if (!ctx) { + PyErr_WriteUnraisable(Py_None); + } else { + PyErr_WriteUnraisable(ctx); + Py_DECREF(ctx); + } +#ifdef WITH_THREAD + if (nogil) + PyGILState_Release(state); +#endif +} + +/* GetItemInt */ + static CYTHON_INLINE PyObject *__Pyx_GetItemInt_Generic(PyObject *o, PyObject* j) { + PyObject *r; + if (!j) return NULL; + r = PyObject_GetItem(o, j); + Py_DECREF(j); + return r; +} +static CYTHON_INLINE PyObject *__Pyx_GetItemInt_List_Fast(PyObject *o, Py_ssize_t i, + CYTHON_NCP_UNUSED int wraparound, + CYTHON_NCP_UNUSED int boundscheck) { +#if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + if (wraparound & unlikely(i < 0)) i += PyList_GET_SIZE(o); + if ((!boundscheck) || likely((0 <= i) & (i < PyList_GET_SIZE(o)))) { + PyObject *r = PyList_GET_ITEM(o, i); + Py_INCREF(r); + return r; + } + return __Pyx_GetItemInt_Generic(o, PyInt_FromSsize_t(i)); +#else + return PySequence_GetItem(o, i); +#endif +} +static CYTHON_INLINE PyObject *__Pyx_GetItemInt_Tuple_Fast(PyObject *o, Py_ssize_t i, + CYTHON_NCP_UNUSED int wraparound, + CYTHON_NCP_UNUSED int boundscheck) { +#if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + if (wraparound & unlikely(i < 0)) i += PyTuple_GET_SIZE(o); + if ((!boundscheck) || likely((0 <= i) & (i < PyTuple_GET_SIZE(o)))) { + PyObject *r = PyTuple_GET_ITEM(o, i); + Py_INCREF(r); + return r; + } + return __Pyx_GetItemInt_Generic(o, PyInt_FromSsize_t(i)); +#else + return PySequence_GetItem(o, i); +#endif +} +static CYTHON_INLINE PyObject *__Pyx_GetItemInt_Fast(PyObject *o, Py_ssize_t i, int is_list, + CYTHON_NCP_UNUSED int wraparound, + CYTHON_NCP_UNUSED int boundscheck) { +#if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS && CYTHON_USE_TYPE_SLOTS + if (is_list || PyList_CheckExact(o)) { + Py_ssize_t n = ((!wraparound) | likely(i >= 0)) ? i : i + PyList_GET_SIZE(o); + if ((!boundscheck) || (likely((n >= 0) & (n < PyList_GET_SIZE(o))))) { + PyObject *r = PyList_GET_ITEM(o, n); + Py_INCREF(r); + return r; + } + } + else if (PyTuple_CheckExact(o)) { + Py_ssize_t n = ((!wraparound) | likely(i >= 0)) ? i : i + PyTuple_GET_SIZE(o); + if ((!boundscheck) || likely((n >= 0) & (n < PyTuple_GET_SIZE(o)))) { + PyObject *r = PyTuple_GET_ITEM(o, n); + Py_INCREF(r); + return r; + } + } else { + PySequenceMethods *m = Py_TYPE(o)->tp_as_sequence; + if (likely(m && m->sq_item)) { + if (wraparound && unlikely(i < 0) && likely(m->sq_length)) { + Py_ssize_t l = m->sq_length(o); + if (likely(l >= 0)) { + i += l; + } else { + if (!PyErr_ExceptionMatches(PyExc_OverflowError)) + return NULL; + PyErr_Clear(); + } + } + return m->sq_item(o, i); + } + } +#else + if (is_list || PySequence_Check(o)) { + return PySequence_GetItem(o, i); + } +#endif + return __Pyx_GetItemInt_Generic(o, PyInt_FromSsize_t(i)); +} + +/* None */ + static CYTHON_INLINE void __Pyx_RaiseUnboundLocalError(const char *varname) { + PyErr_Format(PyExc_UnboundLocalError, "local variable '%s' referenced before assignment", varname); +} + +/* SliceObject */ + static CYTHON_INLINE PyObject* __Pyx_PyObject_GetSlice(PyObject* obj, + Py_ssize_t cstart, Py_ssize_t cstop, + PyObject** _py_start, PyObject** _py_stop, PyObject** _py_slice, + int has_cstart, int has_cstop, CYTHON_UNUSED int wraparound) { +#if CYTHON_USE_TYPE_SLOTS + PyMappingMethods* mp; +#if PY_MAJOR_VERSION < 3 + PySequenceMethods* ms = Py_TYPE(obj)->tp_as_sequence; + if (likely(ms && ms->sq_slice)) { + if (!has_cstart) { + if (_py_start && (*_py_start != Py_None)) { + cstart = __Pyx_PyIndex_AsSsize_t(*_py_start); + if ((cstart == (Py_ssize_t)-1) && PyErr_Occurred()) goto bad; + } else + cstart = 0; + } + if (!has_cstop) { + if (_py_stop && (*_py_stop != Py_None)) { + cstop = __Pyx_PyIndex_AsSsize_t(*_py_stop); + if ((cstop == (Py_ssize_t)-1) && PyErr_Occurred()) goto bad; + } else + cstop = PY_SSIZE_T_MAX; + } + if (wraparound && unlikely((cstart < 0) | (cstop < 0)) && likely(ms->sq_length)) { + Py_ssize_t l = ms->sq_length(obj); + if (likely(l >= 0)) { + if (cstop < 0) { + cstop += l; + if (cstop < 0) cstop = 0; + } + if (cstart < 0) { + cstart += l; + if (cstart < 0) cstart = 0; + } + } else { + if (!PyErr_ExceptionMatches(PyExc_OverflowError)) + goto bad; + PyErr_Clear(); + } + } + return ms->sq_slice(obj, cstart, cstop); + } +#endif + mp = Py_TYPE(obj)->tp_as_mapping; + if (likely(mp && mp->mp_subscript)) +#endif + { + PyObject* result; + PyObject *py_slice, *py_start, *py_stop; + if (_py_slice) { + py_slice = *_py_slice; + } else { + PyObject* owned_start = NULL; + PyObject* owned_stop = NULL; + if (_py_start) { + py_start = *_py_start; + } else { + if (has_cstart) { + owned_start = py_start = PyInt_FromSsize_t(cstart); + if (unlikely(!py_start)) goto bad; + } else + py_start = Py_None; + } + if (_py_stop) { + py_stop = *_py_stop; + } else { + if (has_cstop) { + owned_stop = py_stop = PyInt_FromSsize_t(cstop); + if (unlikely(!py_stop)) { + Py_XDECREF(owned_start); + goto bad; + } + } else + py_stop = Py_None; + } + py_slice = PySlice_New(py_start, py_stop, Py_None); + Py_XDECREF(owned_start); + Py_XDECREF(owned_stop); + if (unlikely(!py_slice)) goto bad; + } +#if CYTHON_USE_TYPE_SLOTS + result = mp->mp_subscript(obj, py_slice); +#else + result = PyObject_GetItem(obj, py_slice); +#endif + if (!_py_slice) { + Py_DECREF(py_slice); + } + return result; + } + PyErr_Format(PyExc_TypeError, + "'%.200s' object is unsliceable", Py_TYPE(obj)->tp_name); +bad: + return NULL; +} + +/* PyIntBinop */ + #if !CYTHON_COMPILING_IN_PYPY +static PyObject* __Pyx_PyInt_AddObjC(PyObject *op1, PyObject *op2, CYTHON_UNUSED long intval, CYTHON_UNUSED int inplace) { + #if PY_MAJOR_VERSION < 3 + if (likely(PyInt_CheckExact(op1))) { + const long b = intval; + long x; + long a = PyInt_AS_LONG(op1); + x = (long)((unsigned long)a + b); + if (likely((x^a) >= 0 || (x^b) >= 0)) + return PyInt_FromLong(x); + return PyLong_Type.tp_as_number->nb_add(op1, op2); + } + #endif + #if CYTHON_USE_PYLONG_INTERNALS + if (likely(PyLong_CheckExact(op1))) { + const long b = intval; + long a, x; +#ifdef HAVE_LONG_LONG + const PY_LONG_LONG llb = intval; + PY_LONG_LONG lla, llx; +#endif + const digit* digits = ((PyLongObject*)op1)->ob_digit; + const Py_ssize_t size = Py_SIZE(op1); + if (likely(__Pyx_sst_abs(size) <= 1)) { + a = likely(size) ? digits[0] : 0; + if (size == -1) a = -a; + } else { + switch (size) { + case -2: + if (8 * sizeof(long) - 1 > 2 * PyLong_SHIFT) { + a = -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])); + break; +#ifdef HAVE_LONG_LONG + } else if (8 * sizeof(PY_LONG_LONG) - 1 > 2 * PyLong_SHIFT) { + lla = -(PY_LONG_LONG) (((((unsigned PY_LONG_LONG)digits[1]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[0])); + goto long_long; +#endif + } + case 2: + if (8 * sizeof(long) - 1 > 2 * PyLong_SHIFT) { + a = (long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])); + break; +#ifdef HAVE_LONG_LONG + } else if (8 * sizeof(PY_LONG_LONG) - 1 > 2 * PyLong_SHIFT) { + lla = (PY_LONG_LONG) (((((unsigned PY_LONG_LONG)digits[1]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[0])); + goto long_long; +#endif + } + case -3: + if (8 * sizeof(long) - 1 > 3 * PyLong_SHIFT) { + a = -(long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])); + break; +#ifdef HAVE_LONG_LONG + } else if (8 * sizeof(PY_LONG_LONG) - 1 > 3 * PyLong_SHIFT) { + lla = -(PY_LONG_LONG) (((((((unsigned PY_LONG_LONG)digits[2]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[1]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[0])); + goto long_long; +#endif + } + case 3: + if (8 * sizeof(long) - 1 > 3 * PyLong_SHIFT) { + a = (long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])); + break; +#ifdef HAVE_LONG_LONG + } else if (8 * sizeof(PY_LONG_LONG) - 1 > 3 * PyLong_SHIFT) { + lla = (PY_LONG_LONG) (((((((unsigned PY_LONG_LONG)digits[2]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[1]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[0])); + goto long_long; +#endif + } + case -4: + if (8 * sizeof(long) - 1 > 4 * PyLong_SHIFT) { + a = -(long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])); + break; +#ifdef HAVE_LONG_LONG + } else if (8 * sizeof(PY_LONG_LONG) - 1 > 4 * PyLong_SHIFT) { + lla = -(PY_LONG_LONG) (((((((((unsigned PY_LONG_LONG)digits[3]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[2]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[1]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[0])); + goto long_long; +#endif + } + case 4: + if (8 * sizeof(long) - 1 > 4 * PyLong_SHIFT) { + a = (long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])); + break; +#ifdef HAVE_LONG_LONG + } else if (8 * sizeof(PY_LONG_LONG) - 1 > 4 * PyLong_SHIFT) { + lla = (PY_LONG_LONG) (((((((((unsigned PY_LONG_LONG)digits[3]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[2]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[1]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[0])); + goto long_long; +#endif + } + default: return PyLong_Type.tp_as_number->nb_add(op1, op2); + } + } + x = a + b; + return PyLong_FromLong(x); +#ifdef HAVE_LONG_LONG + long_long: + llx = lla + llb; + return PyLong_FromLongLong(llx); +#endif + + + } + #endif + if (PyFloat_CheckExact(op1)) { + const long b = intval; + double a = PyFloat_AS_DOUBLE(op1); + double result; + PyFPE_START_PROTECT("add", return NULL) + result = ((double)a) + (double)b; + PyFPE_END_PROTECT(result) + return PyFloat_FromDouble(result); + } + return (inplace ? PyNumber_InPlaceAdd : PyNumber_Add)(op1, op2); +} +#endif + +/* SwapException */ + #if CYTHON_FAST_THREAD_STATE +static CYTHON_INLINE void __Pyx__ExceptionSwap(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb) { + PyObject *tmp_type, *tmp_value, *tmp_tb; + tmp_type = tstate->exc_type; + tmp_value = tstate->exc_value; + tmp_tb = tstate->exc_traceback; + tstate->exc_type = *type; + tstate->exc_value = *value; + tstate->exc_traceback = *tb; + *type = tmp_type; + *value = tmp_value; + *tb = tmp_tb; +} +#else +static CYTHON_INLINE void __Pyx_ExceptionSwap(PyObject **type, PyObject **value, PyObject **tb) { + PyObject *tmp_type, *tmp_value, *tmp_tb; + PyErr_GetExcInfo(&tmp_type, &tmp_value, &tmp_tb); + PyErr_SetExcInfo(*type, *value, *tb); + *type = tmp_type; + *value = tmp_value; + *tb = tmp_tb; +} +#endif + +/* None */ + static CYTHON_INLINE int64_t __Pyx_mod_int64_t(int64_t a, int64_t b) { + int64_t r = a % b; + r += ((r != 0) & ((r ^ b) < 0)) * b; + return r; +} + +/* PyIntBinop */ + #if !CYTHON_COMPILING_IN_PYPY +static PyObject* __Pyx_PyInt_AddCObj(PyObject *op1, PyObject *op2, CYTHON_UNUSED long intval, CYTHON_UNUSED int inplace) { + #if PY_MAJOR_VERSION < 3 + if (likely(PyInt_CheckExact(op2))) { + const long a = intval; + long x; + long b = PyInt_AS_LONG(op2); + x = (long)((unsigned long)a + b); + if (likely((x^a) >= 0 || (x^b) >= 0)) + return PyInt_FromLong(x); + return PyLong_Type.tp_as_number->nb_add(op1, op2); + } + #endif + #if CYTHON_USE_PYLONG_INTERNALS + if (likely(PyLong_CheckExact(op2))) { + const long a = intval; + long b, x; +#ifdef HAVE_LONG_LONG + const PY_LONG_LONG lla = intval; + PY_LONG_LONG llb, llx; +#endif + const digit* digits = ((PyLongObject*)op2)->ob_digit; + const Py_ssize_t size = Py_SIZE(op2); + if (likely(__Pyx_sst_abs(size) <= 1)) { + b = likely(size) ? digits[0] : 0; + if (size == -1) b = -b; + } else { + switch (size) { + case -2: + if (8 * sizeof(long) - 1 > 2 * PyLong_SHIFT) { + b = -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])); + break; +#ifdef HAVE_LONG_LONG + } else if (8 * sizeof(PY_LONG_LONG) - 1 > 2 * PyLong_SHIFT) { + llb = -(PY_LONG_LONG) (((((unsigned PY_LONG_LONG)digits[1]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[0])); + goto long_long; +#endif + } + case 2: + if (8 * sizeof(long) - 1 > 2 * PyLong_SHIFT) { + b = (long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])); + break; +#ifdef HAVE_LONG_LONG + } else if (8 * sizeof(PY_LONG_LONG) - 1 > 2 * PyLong_SHIFT) { + llb = (PY_LONG_LONG) (((((unsigned PY_LONG_LONG)digits[1]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[0])); + goto long_long; +#endif + } + case -3: + if (8 * sizeof(long) - 1 > 3 * PyLong_SHIFT) { + b = -(long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])); + break; +#ifdef HAVE_LONG_LONG + } else if (8 * sizeof(PY_LONG_LONG) - 1 > 3 * PyLong_SHIFT) { + llb = -(PY_LONG_LONG) (((((((unsigned PY_LONG_LONG)digits[2]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[1]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[0])); + goto long_long; +#endif + } + case 3: + if (8 * sizeof(long) - 1 > 3 * PyLong_SHIFT) { + b = (long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])); + break; +#ifdef HAVE_LONG_LONG + } else if (8 * sizeof(PY_LONG_LONG) - 1 > 3 * PyLong_SHIFT) { + llb = (PY_LONG_LONG) (((((((unsigned PY_LONG_LONG)digits[2]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[1]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[0])); + goto long_long; +#endif + } + case -4: + if (8 * sizeof(long) - 1 > 4 * PyLong_SHIFT) { + b = -(long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])); + break; +#ifdef HAVE_LONG_LONG + } else if (8 * sizeof(PY_LONG_LONG) - 1 > 4 * PyLong_SHIFT) { + llb = -(PY_LONG_LONG) (((((((((unsigned PY_LONG_LONG)digits[3]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[2]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[1]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[0])); + goto long_long; +#endif + } + case 4: + if (8 * sizeof(long) - 1 > 4 * PyLong_SHIFT) { + b = (long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])); + break; +#ifdef HAVE_LONG_LONG + } else if (8 * sizeof(PY_LONG_LONG) - 1 > 4 * PyLong_SHIFT) { + llb = (PY_LONG_LONG) (((((((((unsigned PY_LONG_LONG)digits[3]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[2]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[1]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[0])); + goto long_long; +#endif + } + default: return PyLong_Type.tp_as_number->nb_add(op1, op2); + } + } + x = a + b; + return PyLong_FromLong(x); +#ifdef HAVE_LONG_LONG + long_long: + llx = lla + llb; + return PyLong_FromLongLong(llx); +#endif + + + } + #endif + if (PyFloat_CheckExact(op2)) { + const long a = intval; + double b = PyFloat_AS_DOUBLE(op2); + double result; + PyFPE_START_PROTECT("add", return NULL) + result = ((double)a) + (double)b; + PyFPE_END_PROTECT(result) + return PyFloat_FromDouble(result); + } + return (inplace ? PyNumber_InPlaceAdd : PyNumber_Add)(op1, op2); +} +#endif + +/* RaiseTooManyValuesToUnpack */ + static CYTHON_INLINE void __Pyx_RaiseTooManyValuesError(Py_ssize_t expected) { + PyErr_Format(PyExc_ValueError, + "too many values to unpack (expected %" CYTHON_FORMAT_SSIZE_T "d)", expected); +} + +/* RaiseNeedMoreValuesToUnpack */ + static CYTHON_INLINE void __Pyx_RaiseNeedMoreValuesError(Py_ssize_t index) { + PyErr_Format(PyExc_ValueError, + "need more than %" CYTHON_FORMAT_SSIZE_T "d value%.1s to unpack", + index, (index == 1) ? "" : "s"); +} + +/* IterFinish */ + static CYTHON_INLINE int __Pyx_IterFinish(void) { +#if CYTHON_FAST_THREAD_STATE + PyThreadState *tstate = PyThreadState_GET(); + PyObject* exc_type = tstate->curexc_type; + if (unlikely(exc_type)) { + if (likely(exc_type == PyExc_StopIteration) || PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration)) { + PyObject *exc_value, *exc_tb; + exc_value = tstate->curexc_value; + exc_tb = tstate->curexc_traceback; + tstate->curexc_type = 0; + tstate->curexc_value = 0; + tstate->curexc_traceback = 0; + Py_DECREF(exc_type); + Py_XDECREF(exc_value); + Py_XDECREF(exc_tb); + return 0; + } else { + return -1; + } + } + return 0; +#else + if (unlikely(PyErr_Occurred())) { + if (likely(PyErr_ExceptionMatches(PyExc_StopIteration))) { + PyErr_Clear(); + return 0; + } else { + return -1; + } + } + return 0; +#endif +} + +/* UnpackItemEndCheck */ + static int __Pyx_IternextUnpackEndCheck(PyObject *retval, Py_ssize_t expected) { + if (unlikely(retval)) { + Py_DECREF(retval); + __Pyx_RaiseTooManyValuesError(expected); + return -1; + } else { + return __Pyx_IterFinish(); + } + return 0; +} + +/* IterNext */ + static CYTHON_INLINE PyObject *__Pyx_PyIter_Next2(PyObject* iterator, PyObject* defval) { + PyObject* next; + iternextfunc iternext = Py_TYPE(iterator)->tp_iternext; +#if CYTHON_USE_TYPE_SLOTS + if (unlikely(!iternext)) { +#else + if (unlikely(!iternext) || unlikely(!PyIter_Check(iterator))) { +#endif + PyErr_Format(PyExc_TypeError, + "%.200s object is not an iterator", Py_TYPE(iterator)->tp_name); + return NULL; + } + next = iternext(iterator); + if (likely(next)) + return next; +#if CYTHON_USE_TYPE_SLOTS +#if PY_VERSION_HEX >= 0x02070000 + if (unlikely(iternext == &_PyObject_NextNotImplemented)) + return NULL; +#endif +#endif + if (defval) { + PyObject* exc_type = PyErr_Occurred(); + if (exc_type) { + if (unlikely(exc_type != PyExc_StopIteration) && + !PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration)) + return NULL; + PyErr_Clear(); + } + Py_INCREF(defval); + return defval; + } + if (!PyErr_Occurred()) + PyErr_SetNone(PyExc_StopIteration); + return NULL; +} + +/* decode_c_bytes */ + static CYTHON_INLINE PyObject* __Pyx_decode_c_bytes( + const char* cstring, Py_ssize_t length, Py_ssize_t start, Py_ssize_t stop, + const char* encoding, const char* errors, + PyObject* (*decode_func)(const char *s, Py_ssize_t size, const char *errors)) { + if (unlikely((start < 0) | (stop < 0))) { + if (start < 0) { + start += length; + if (start < 0) + start = 0; + } + if (stop < 0) + stop += length; + } + if (stop > length) + stop = length; + length = stop - start; + if (unlikely(length <= 0)) + return PyUnicode_FromUnicode(NULL, 0); + cstring += start; + if (decode_func) { + return decode_func(cstring, length, errors); + } else { + return PyUnicode_Decode(cstring, length, encoding, errors); + } +} + +/* PyObjectCallMethod0 */ + static PyObject* __Pyx_PyObject_CallMethod0(PyObject* obj, PyObject* method_name) { + PyObject *method, *result = NULL; + method = __Pyx_PyObject_GetAttrStr(obj, method_name); + if (unlikely(!method)) goto bad; +#if CYTHON_UNPACK_METHODS + if (likely(PyMethod_Check(method))) { + PyObject *self = PyMethod_GET_SELF(method); + if (likely(self)) { + PyObject *function = PyMethod_GET_FUNCTION(method); + result = __Pyx_PyObject_CallOneArg(function, self); + Py_DECREF(method); + return result; + } + } +#endif + result = __Pyx_PyObject_CallNoArg(method); + Py_DECREF(method); +bad: + return result; +} + +/* RaiseNoneIterError */ + static CYTHON_INLINE void __Pyx_RaiseNoneNotIterableError(void) { + PyErr_SetString(PyExc_TypeError, "'NoneType' object is not iterable"); +} + +/* UnpackTupleError */ + static void __Pyx_UnpackTupleError(PyObject *t, Py_ssize_t index) { + if (t == Py_None) { + __Pyx_RaiseNoneNotIterableError(); + } else if (PyTuple_GET_SIZE(t) < index) { + __Pyx_RaiseNeedMoreValuesError(PyTuple_GET_SIZE(t)); + } else { + __Pyx_RaiseTooManyValuesError(index); + } +} + +/* UnpackTuple2 */ + static CYTHON_INLINE int __Pyx_unpack_tuple2(PyObject* tuple, PyObject** pvalue1, PyObject** pvalue2, + int is_tuple, int has_known_size, int decref_tuple) { + Py_ssize_t index; + PyObject *value1 = NULL, *value2 = NULL, *iter = NULL; + if (!is_tuple && unlikely(!PyTuple_Check(tuple))) { + iternextfunc iternext; + iter = PyObject_GetIter(tuple); + if (unlikely(!iter)) goto bad; + if (decref_tuple) { Py_DECREF(tuple); tuple = NULL; } + iternext = Py_TYPE(iter)->tp_iternext; + value1 = iternext(iter); if (unlikely(!value1)) { index = 0; goto unpacking_failed; } + value2 = iternext(iter); if (unlikely(!value2)) { index = 1; goto unpacking_failed; } + if (!has_known_size && unlikely(__Pyx_IternextUnpackEndCheck(iternext(iter), 2))) goto bad; + Py_DECREF(iter); + } else { + if (!has_known_size && unlikely(PyTuple_GET_SIZE(tuple) != 2)) { + __Pyx_UnpackTupleError(tuple, 2); + goto bad; + } +#if CYTHON_COMPILING_IN_PYPY + value1 = PySequence_ITEM(tuple, 0); + if (unlikely(!value1)) goto bad; + value2 = PySequence_ITEM(tuple, 1); + if (unlikely(!value2)) goto bad; +#else + value1 = PyTuple_GET_ITEM(tuple, 0); + value2 = PyTuple_GET_ITEM(tuple, 1); + Py_INCREF(value1); + Py_INCREF(value2); +#endif + if (decref_tuple) { Py_DECREF(tuple); } + } + *pvalue1 = value1; + *pvalue2 = value2; + return 0; +unpacking_failed: + if (!has_known_size && __Pyx_IterFinish() == 0) + __Pyx_RaiseNeedMoreValuesError(index); +bad: + Py_XDECREF(iter); + Py_XDECREF(value1); + Py_XDECREF(value2); + if (decref_tuple) { Py_XDECREF(tuple); } + return -1; +} + +/* dict_iter */ + static CYTHON_INLINE PyObject* __Pyx_dict_iterator(PyObject* iterable, int is_dict, PyObject* method_name, + Py_ssize_t* p_orig_length, int* p_source_is_dict) { + is_dict = is_dict || likely(PyDict_CheckExact(iterable)); + *p_source_is_dict = is_dict; +#if !CYTHON_COMPILING_IN_PYPY + if (is_dict) { + *p_orig_length = PyDict_Size(iterable); + Py_INCREF(iterable); + return iterable; + } +#endif + *p_orig_length = 0; + if (method_name) { + PyObject* iter; + iterable = __Pyx_PyObject_CallMethod0(iterable, method_name); + if (!iterable) + return NULL; +#if !CYTHON_COMPILING_IN_PYPY + if (PyTuple_CheckExact(iterable) || PyList_CheckExact(iterable)) + return iterable; +#endif + iter = PyObject_GetIter(iterable); + Py_DECREF(iterable); + return iter; + } + return PyObject_GetIter(iterable); +} +static CYTHON_INLINE int __Pyx_dict_iter_next( + PyObject* iter_obj, CYTHON_NCP_UNUSED Py_ssize_t orig_length, CYTHON_NCP_UNUSED Py_ssize_t* ppos, + PyObject** pkey, PyObject** pvalue, PyObject** pitem, int source_is_dict) { + PyObject* next_item; +#if !CYTHON_COMPILING_IN_PYPY + if (source_is_dict) { + PyObject *key, *value; + if (unlikely(orig_length != PyDict_Size(iter_obj))) { + PyErr_SetString(PyExc_RuntimeError, "dictionary changed size during iteration"); + return -1; + } + if (unlikely(!PyDict_Next(iter_obj, ppos, &key, &value))) { + return 0; + } + if (pitem) { + PyObject* tuple = PyTuple_New(2); + if (unlikely(!tuple)) { + return -1; + } + Py_INCREF(key); + Py_INCREF(value); + PyTuple_SET_ITEM(tuple, 0, key); + PyTuple_SET_ITEM(tuple, 1, value); + *pitem = tuple; + } else { + if (pkey) { + Py_INCREF(key); + *pkey = key; + } + if (pvalue) { + Py_INCREF(value); + *pvalue = value; + } + } + return 1; + } else if (PyTuple_CheckExact(iter_obj)) { + Py_ssize_t pos = *ppos; + if (unlikely(pos >= PyTuple_GET_SIZE(iter_obj))) return 0; + *ppos = pos + 1; + next_item = PyTuple_GET_ITEM(iter_obj, pos); + Py_INCREF(next_item); + } else if (PyList_CheckExact(iter_obj)) { + Py_ssize_t pos = *ppos; + if (unlikely(pos >= PyList_GET_SIZE(iter_obj))) return 0; + *ppos = pos + 1; + next_item = PyList_GET_ITEM(iter_obj, pos); + Py_INCREF(next_item); + } else +#endif + { + next_item = PyIter_Next(iter_obj); + if (unlikely(!next_item)) { + return __Pyx_IterFinish(); + } + } + if (pitem) { + *pitem = next_item; + } else if (pkey && pvalue) { + if (__Pyx_unpack_tuple2(next_item, pkey, pvalue, source_is_dict, source_is_dict, 1)) + return -1; + } else if (pkey) { + *pkey = next_item; + } else { + *pvalue = next_item; + } + return 1; +} + +/* ArgTypeTest */ + static void __Pyx_RaiseArgumentTypeInvalid(const char* name, PyObject *obj, PyTypeObject *type) { + PyErr_Format(PyExc_TypeError, + "Argument '%.200s' has incorrect type (expected %.200s, got %.200s)", + name, type->tp_name, Py_TYPE(obj)->tp_name); +} +static CYTHON_INLINE int __Pyx_ArgTypeTest(PyObject *obj, PyTypeObject *type, int none_allowed, + const char *name, int exact) +{ + if (unlikely(!type)) { + PyErr_SetString(PyExc_SystemError, "Missing type object"); + return 0; + } + if (none_allowed && obj == Py_None) return 1; + else if (exact) { + if (likely(Py_TYPE(obj) == type)) return 1; + #if PY_MAJOR_VERSION == 2 + else if ((type == &PyBaseString_Type) && likely(__Pyx_PyBaseString_CheckExact(obj))) return 1; + #endif + } + else { + if (likely(PyObject_TypeCheck(obj, type))) return 1; + } + __Pyx_RaiseArgumentTypeInvalid(name, obj, type); + return 0; +} + +/* FetchCommonType */ + static PyTypeObject* __Pyx_FetchCommonType(PyTypeObject* type) { + PyObject* fake_module; + PyTypeObject* cached_type = NULL; + fake_module = PyImport_AddModule((char*) "_cython_" CYTHON_ABI); + if (!fake_module) return NULL; + Py_INCREF(fake_module); + cached_type = (PyTypeObject*) PyObject_GetAttrString(fake_module, type->tp_name); + if (cached_type) { + if (!PyType_Check((PyObject*)cached_type)) { + PyErr_Format(PyExc_TypeError, + "Shared Cython type %.200s is not a type object", + type->tp_name); + goto bad; + } + if (cached_type->tp_basicsize != type->tp_basicsize) { + PyErr_Format(PyExc_TypeError, + "Shared Cython type %.200s has the wrong size, try recompiling", + type->tp_name); + goto bad; + } + } else { + if (!PyErr_ExceptionMatches(PyExc_AttributeError)) goto bad; + PyErr_Clear(); + if (PyType_Ready(type) < 0) goto bad; + if (PyObject_SetAttrString(fake_module, type->tp_name, (PyObject*) type) < 0) + goto bad; + Py_INCREF(type); + cached_type = type; + } +done: + Py_DECREF(fake_module); + return cached_type; +bad: + Py_XDECREF(cached_type); + cached_type = NULL; + goto done; +} + +/* PyObjectCallMethod1 */ + static PyObject* __Pyx_PyObject_CallMethod1(PyObject* obj, PyObject* method_name, PyObject* arg) { + PyObject *method, *result = NULL; + method = __Pyx_PyObject_GetAttrStr(obj, method_name); + if (unlikely(!method)) goto done; +#if CYTHON_UNPACK_METHODS + if (likely(PyMethod_Check(method))) { + PyObject *self = PyMethod_GET_SELF(method); + if (likely(self)) { + PyObject *args; + PyObject *function = PyMethod_GET_FUNCTION(method); + #if CYTHON_FAST_PYCALL + if (PyFunction_Check(function)) { + PyObject *args[2] = {self, arg}; + result = __Pyx_PyFunction_FastCall(function, args, 2); + goto done; + } + #endif + #if CYTHON_FAST_PYCCALL + if (__Pyx_PyFastCFunction_Check(function)) { + PyObject *args[2] = {self, arg}; + result = __Pyx_PyCFunction_FastCall(function, args, 2); + goto done; + } + #endif + args = PyTuple_New(2); + if (unlikely(!args)) goto done; + Py_INCREF(self); + PyTuple_SET_ITEM(args, 0, self); + Py_INCREF(arg); + PyTuple_SET_ITEM(args, 1, arg); + Py_INCREF(function); + Py_DECREF(method); method = NULL; + result = __Pyx_PyObject_Call(function, args, NULL); + Py_DECREF(args); + Py_DECREF(function); + return result; + } + } +#endif + result = __Pyx_PyObject_CallOneArg(method, arg); +done: + Py_XDECREF(method); + return result; +} + +/* CoroutineBase */ + #include +#include +static PyObject *__Pyx_Coroutine_Send(PyObject *self, PyObject *value); +static PyObject *__Pyx_Coroutine_Close(PyObject *self); +static PyObject *__Pyx_Coroutine_Throw(PyObject *gen, PyObject *args); +#define __Pyx_Coroutine_Undelegate(gen) Py_CLEAR((gen)->yieldfrom) +#if 1 || PY_VERSION_HEX < 0x030300B0 +static int __Pyx_PyGen_FetchStopIterationValue(PyObject **pvalue) { + PyObject *et, *ev, *tb; + PyObject *value = NULL; + __Pyx_PyThreadState_declare + __Pyx_PyThreadState_assign + __Pyx_ErrFetch(&et, &ev, &tb); + if (!et) { + Py_XDECREF(tb); + Py_XDECREF(ev); + Py_INCREF(Py_None); + *pvalue = Py_None; + return 0; + } + if (likely(et == PyExc_StopIteration)) { + if (!ev) { + Py_INCREF(Py_None); + value = Py_None; + } +#if PY_VERSION_HEX >= 0x030300A0 + else if (Py_TYPE(ev) == (PyTypeObject*)PyExc_StopIteration) { + value = ((PyStopIterationObject *)ev)->value; + Py_INCREF(value); + Py_DECREF(ev); + } +#endif + else if (unlikely(PyTuple_Check(ev))) { + if (PyTuple_GET_SIZE(ev) >= 1) { +#if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + value = PyTuple_GET_ITEM(ev, 0); + Py_INCREF(value); +#else + value = PySequence_ITEM(ev, 0); +#endif + } else { + Py_INCREF(Py_None); + value = Py_None; + } + Py_DECREF(ev); + } + else if (!PyObject_TypeCheck(ev, (PyTypeObject*)PyExc_StopIteration)) { + value = ev; + } + if (likely(value)) { + Py_XDECREF(tb); + Py_DECREF(et); + *pvalue = value; + return 0; + } + } else if (!PyErr_GivenExceptionMatches(et, PyExc_StopIteration)) { + __Pyx_ErrRestore(et, ev, tb); + return -1; + } + PyErr_NormalizeException(&et, &ev, &tb); + if (unlikely(!PyObject_TypeCheck(ev, (PyTypeObject*)PyExc_StopIteration))) { + __Pyx_ErrRestore(et, ev, tb); + return -1; + } + Py_XDECREF(tb); + Py_DECREF(et); +#if PY_VERSION_HEX >= 0x030300A0 + value = ((PyStopIterationObject *)ev)->value; + Py_INCREF(value); + Py_DECREF(ev); +#else + { + PyObject* args = __Pyx_PyObject_GetAttrStr(ev, __pyx_n_s_args); + Py_DECREF(ev); + if (likely(args)) { + value = PySequence_GetItem(args, 0); + Py_DECREF(args); + } + if (unlikely(!value)) { + __Pyx_ErrRestore(NULL, NULL, NULL); + Py_INCREF(Py_None); + value = Py_None; + } + } +#endif + *pvalue = value; + return 0; +} +#endif +static CYTHON_INLINE +void __Pyx_Coroutine_ExceptionClear(__pyx_CoroutineObject *self) { + PyObject *exc_type = self->exc_type; + PyObject *exc_value = self->exc_value; + PyObject *exc_traceback = self->exc_traceback; + self->exc_type = NULL; + self->exc_value = NULL; + self->exc_traceback = NULL; + Py_XDECREF(exc_type); + Py_XDECREF(exc_value); + Py_XDECREF(exc_traceback); +} +static CYTHON_INLINE +int __Pyx_Coroutine_CheckRunning(__pyx_CoroutineObject *gen) { + if (unlikely(gen->is_running)) { + PyErr_SetString(PyExc_ValueError, + "generator already executing"); + return 1; + } + return 0; +} +static CYTHON_INLINE +PyObject *__Pyx_Coroutine_SendEx(__pyx_CoroutineObject *self, PyObject *value) { + PyObject *retval; + __Pyx_PyThreadState_declare + assert(!self->is_running); + if (unlikely(self->resume_label == 0)) { + if (unlikely(value && value != Py_None)) { + PyErr_SetString(PyExc_TypeError, + "can't send non-None value to a " + "just-started generator"); + return NULL; + } + } + if (unlikely(self->resume_label == -1)) { + PyErr_SetNone(PyExc_StopIteration); + return NULL; + } + __Pyx_PyThreadState_assign + if (value) { +#if CYTHON_COMPILING_IN_PYPY || CYTHON_COMPILING_IN_PYSTON +#else + if (self->exc_traceback) { + PyTracebackObject *tb = (PyTracebackObject *) self->exc_traceback; + PyFrameObject *f = tb->tb_frame; + Py_XINCREF(__pyx_tstate->frame); + assert(f->f_back == NULL); + f->f_back = __pyx_tstate->frame; + } +#endif + __Pyx_ExceptionSwap(&self->exc_type, &self->exc_value, + &self->exc_traceback); + } else { + __Pyx_Coroutine_ExceptionClear(self); + } + self->is_running = 1; + retval = self->body((PyObject *) self, value); + self->is_running = 0; + if (retval) { + __Pyx_ExceptionSwap(&self->exc_type, &self->exc_value, + &self->exc_traceback); +#if CYTHON_COMPILING_IN_PYPY || CYTHON_COMPILING_IN_PYSTON +#else + if (self->exc_traceback) { + PyTracebackObject *tb = (PyTracebackObject *) self->exc_traceback; + PyFrameObject *f = tb->tb_frame; + Py_CLEAR(f->f_back); + } +#endif + } else { + __Pyx_Coroutine_ExceptionClear(self); + } + return retval; +} +static CYTHON_INLINE +PyObject *__Pyx_Coroutine_MethodReturn(PyObject *retval) { + if (unlikely(!retval && !PyErr_Occurred())) { + PyErr_SetNone(PyExc_StopIteration); + } + return retval; +} +static CYTHON_INLINE +PyObject *__Pyx_Coroutine_FinishDelegation(__pyx_CoroutineObject *gen) { + PyObject *ret; + PyObject *val = NULL; + __Pyx_Coroutine_Undelegate(gen); + __Pyx_PyGen_FetchStopIterationValue(&val); + ret = __Pyx_Coroutine_SendEx(gen, val); + Py_XDECREF(val); + return ret; +} +static PyObject *__Pyx_Coroutine_Send(PyObject *self, PyObject *value) { + PyObject *retval; + __pyx_CoroutineObject *gen = (__pyx_CoroutineObject*) self; + PyObject *yf = gen->yieldfrom; + if (unlikely(__Pyx_Coroutine_CheckRunning(gen))) + return NULL; + if (yf) { + PyObject *ret; + gen->is_running = 1; + #ifdef __Pyx_Generator_USED + if (__Pyx_Generator_CheckExact(yf)) { + ret = __Pyx_Coroutine_Send(yf, value); + } else + #endif + #ifdef __Pyx_Coroutine_USED + if (__Pyx_Coroutine_CheckExact(yf)) { + ret = __Pyx_Coroutine_Send(yf, value); + } else + #endif + { + if (value == Py_None) + ret = Py_TYPE(yf)->tp_iternext(yf); + else + ret = __Pyx_PyObject_CallMethod1(yf, __pyx_n_s_send, value); + } + gen->is_running = 0; + if (likely(ret)) { + return ret; + } + retval = __Pyx_Coroutine_FinishDelegation(gen); + } else { + retval = __Pyx_Coroutine_SendEx(gen, value); + } + return __Pyx_Coroutine_MethodReturn(retval); +} +static int __Pyx_Coroutine_CloseIter(__pyx_CoroutineObject *gen, PyObject *yf) { + PyObject *retval = NULL; + int err = 0; + #ifdef __Pyx_Generator_USED + if (__Pyx_Generator_CheckExact(yf)) { + retval = __Pyx_Coroutine_Close(yf); + if (!retval) + return -1; + } else + #endif + #ifdef __Pyx_Coroutine_USED + if (__Pyx_Coroutine_CheckExact(yf)) { + retval = __Pyx_Coroutine_Close(yf); + if (!retval) + return -1; + } else + #endif + { + PyObject *meth; + gen->is_running = 1; + meth = __Pyx_PyObject_GetAttrStr(yf, __pyx_n_s_close); + if (unlikely(!meth)) { + if (!PyErr_ExceptionMatches(PyExc_AttributeError)) { + PyErr_WriteUnraisable(yf); + } + PyErr_Clear(); + } else { + retval = PyObject_CallFunction(meth, NULL); + Py_DECREF(meth); + if (!retval) + err = -1; + } + gen->is_running = 0; + } + Py_XDECREF(retval); + return err; +} +static PyObject *__Pyx_Generator_Next(PyObject *self) { + __pyx_CoroutineObject *gen = (__pyx_CoroutineObject*) self; + PyObject *yf = gen->yieldfrom; + if (unlikely(__Pyx_Coroutine_CheckRunning(gen))) + return NULL; + if (yf) { + PyObject *ret; + gen->is_running = 1; + #ifdef __Pyx_Generator_USED + if (__Pyx_Generator_CheckExact(yf)) { + ret = __Pyx_Generator_Next(yf); + } else + #endif + ret = Py_TYPE(yf)->tp_iternext(yf); + gen->is_running = 0; + if (likely(ret)) { + return ret; + } + return __Pyx_Coroutine_FinishDelegation(gen); + } + return __Pyx_Coroutine_SendEx(gen, Py_None); +} +static PyObject *__Pyx_Coroutine_Close(PyObject *self) { + __pyx_CoroutineObject *gen = (__pyx_CoroutineObject *) self; + PyObject *retval, *raised_exception; + PyObject *yf = gen->yieldfrom; + int err = 0; + if (unlikely(__Pyx_Coroutine_CheckRunning(gen))) + return NULL; + if (yf) { + Py_INCREF(yf); + err = __Pyx_Coroutine_CloseIter(gen, yf); + __Pyx_Coroutine_Undelegate(gen); + Py_DECREF(yf); + } + if (err == 0) + PyErr_SetNone(PyExc_GeneratorExit); + retval = __Pyx_Coroutine_SendEx(gen, NULL); + if (retval) { + Py_DECREF(retval); + PyErr_SetString(PyExc_RuntimeError, + "generator ignored GeneratorExit"); + return NULL; + } + raised_exception = PyErr_Occurred(); + if (!raised_exception + || raised_exception == PyExc_StopIteration + || raised_exception == PyExc_GeneratorExit + || PyErr_GivenExceptionMatches(raised_exception, PyExc_GeneratorExit) + || PyErr_GivenExceptionMatches(raised_exception, PyExc_StopIteration)) + { + if (raised_exception) PyErr_Clear(); + Py_INCREF(Py_None); + return Py_None; + } + return NULL; +} +static PyObject *__Pyx_Coroutine_Throw(PyObject *self, PyObject *args) { + __pyx_CoroutineObject *gen = (__pyx_CoroutineObject *) self; + PyObject *typ; + PyObject *tb = NULL; + PyObject *val = NULL; + PyObject *yf = gen->yieldfrom; + if (!PyArg_UnpackTuple(args, (char *)"throw", 1, 3, &typ, &val, &tb)) + return NULL; + if (unlikely(__Pyx_Coroutine_CheckRunning(gen))) + return NULL; + if (yf) { + PyObject *ret; + Py_INCREF(yf); + if (PyErr_GivenExceptionMatches(typ, PyExc_GeneratorExit)) { + int err = __Pyx_Coroutine_CloseIter(gen, yf); + Py_DECREF(yf); + __Pyx_Coroutine_Undelegate(gen); + if (err < 0) + return __Pyx_Coroutine_MethodReturn(__Pyx_Coroutine_SendEx(gen, NULL)); + goto throw_here; + } + gen->is_running = 1; + #ifdef __Pyx_Generator_USED + if (__Pyx_Generator_CheckExact(yf)) { + ret = __Pyx_Coroutine_Throw(yf, args); + } else + #endif + #ifdef __Pyx_Coroutine_USED + if (__Pyx_Coroutine_CheckExact(yf)) { + ret = __Pyx_Coroutine_Throw(yf, args); + } else + #endif + { + PyObject *meth = __Pyx_PyObject_GetAttrStr(yf, __pyx_n_s_throw); + if (unlikely(!meth)) { + Py_DECREF(yf); + if (!PyErr_ExceptionMatches(PyExc_AttributeError)) { + gen->is_running = 0; + return NULL; + } + PyErr_Clear(); + __Pyx_Coroutine_Undelegate(gen); + gen->is_running = 0; + goto throw_here; + } + ret = PyObject_CallObject(meth, args); + Py_DECREF(meth); + } + gen->is_running = 0; + Py_DECREF(yf); + if (!ret) { + ret = __Pyx_Coroutine_FinishDelegation(gen); + } + return __Pyx_Coroutine_MethodReturn(ret); + } +throw_here: + __Pyx_Raise(typ, val, tb, NULL); + return __Pyx_Coroutine_MethodReturn(__Pyx_Coroutine_SendEx(gen, NULL)); +} +static int __Pyx_Coroutine_traverse(PyObject *self, visitproc visit, void *arg) { + __pyx_CoroutineObject *gen = (__pyx_CoroutineObject *) self; + Py_VISIT(gen->closure); + Py_VISIT(gen->classobj); + Py_VISIT(gen->yieldfrom); + Py_VISIT(gen->exc_type); + Py_VISIT(gen->exc_value); + Py_VISIT(gen->exc_traceback); + return 0; +} +static int __Pyx_Coroutine_clear(PyObject *self) { + __pyx_CoroutineObject *gen = (__pyx_CoroutineObject *) self; + Py_CLEAR(gen->closure); + Py_CLEAR(gen->classobj); + Py_CLEAR(gen->yieldfrom); + Py_CLEAR(gen->exc_type); + Py_CLEAR(gen->exc_value); + Py_CLEAR(gen->exc_traceback); + Py_CLEAR(gen->gi_name); + Py_CLEAR(gen->gi_qualname); + return 0; +} +static void __Pyx_Coroutine_dealloc(PyObject *self) { + __pyx_CoroutineObject *gen = (__pyx_CoroutineObject *) self; + PyObject_GC_UnTrack(gen); + if (gen->gi_weakreflist != NULL) + PyObject_ClearWeakRefs(self); + if (gen->resume_label > 0) { + PyObject_GC_Track(self); +#if PY_VERSION_HEX >= 0x030400a1 + if (PyObject_CallFinalizerFromDealloc(self)) +#else + Py_TYPE(gen)->tp_del(self); + if (self->ob_refcnt > 0) +#endif + { + return; + } + PyObject_GC_UnTrack(self); + } + __Pyx_Coroutine_clear(self); + PyObject_GC_Del(gen); +} +static void __Pyx_Coroutine_del(PyObject *self) { + PyObject *res; + PyObject *error_type, *error_value, *error_traceback; + __pyx_CoroutineObject *gen = (__pyx_CoroutineObject *) self; + __Pyx_PyThreadState_declare + if (gen->resume_label <= 0) + return ; +#if PY_VERSION_HEX < 0x030400a1 + assert(self->ob_refcnt == 0); + self->ob_refcnt = 1; +#endif + __Pyx_PyThreadState_assign + __Pyx_ErrFetch(&error_type, &error_value, &error_traceback); + res = __Pyx_Coroutine_Close(self); + if (res == NULL) + PyErr_WriteUnraisable(self); + else + Py_DECREF(res); + __Pyx_ErrRestore(error_type, error_value, error_traceback); +#if PY_VERSION_HEX < 0x030400a1 + assert(self->ob_refcnt > 0); + if (--self->ob_refcnt == 0) { + return; + } + { + Py_ssize_t refcnt = self->ob_refcnt; + _Py_NewReference(self); + self->ob_refcnt = refcnt; + } +#if CYTHON_COMPILING_IN_CPYTHON + assert(PyType_IS_GC(self->ob_type) && + _Py_AS_GC(self)->gc.gc_refs != _PyGC_REFS_UNTRACKED); + _Py_DEC_REFTOTAL; +#endif +#ifdef COUNT_ALLOCS + --Py_TYPE(self)->tp_frees; + --Py_TYPE(self)->tp_allocs; +#endif +#endif +} +static PyObject * +__Pyx_Coroutine_get_name(__pyx_CoroutineObject *self) +{ + PyObject *name = self->gi_name; + if (unlikely(!name)) name = Py_None; + Py_INCREF(name); + return name; +} +static int +__Pyx_Coroutine_set_name(__pyx_CoroutineObject *self, PyObject *value) +{ + PyObject *tmp; +#if PY_MAJOR_VERSION >= 3 + if (unlikely(value == NULL || !PyUnicode_Check(value))) { +#else + if (unlikely(value == NULL || !PyString_Check(value))) { +#endif + PyErr_SetString(PyExc_TypeError, + "__name__ must be set to a string object"); + return -1; + } + tmp = self->gi_name; + Py_INCREF(value); + self->gi_name = value; + Py_XDECREF(tmp); + return 0; +} +static PyObject * +__Pyx_Coroutine_get_qualname(__pyx_CoroutineObject *self) +{ + PyObject *name = self->gi_qualname; + if (unlikely(!name)) name = Py_None; + Py_INCREF(name); + return name; +} +static int +__Pyx_Coroutine_set_qualname(__pyx_CoroutineObject *self, PyObject *value) +{ + PyObject *tmp; +#if PY_MAJOR_VERSION >= 3 + if (unlikely(value == NULL || !PyUnicode_Check(value))) { +#else + if (unlikely(value == NULL || !PyString_Check(value))) { +#endif + PyErr_SetString(PyExc_TypeError, + "__qualname__ must be set to a string object"); + return -1; + } + tmp = self->gi_qualname; + Py_INCREF(value); + self->gi_qualname = value; + Py_XDECREF(tmp); + return 0; +} +static __pyx_CoroutineObject *__Pyx__Coroutine_New( + PyTypeObject* type, __pyx_coroutine_body_t body, PyObject *closure, + PyObject *name, PyObject *qualname, PyObject *module_name) { + __pyx_CoroutineObject *gen = PyObject_GC_New(__pyx_CoroutineObject, type); + if (gen == NULL) + return NULL; + gen->body = body; + gen->closure = closure; + Py_XINCREF(closure); + gen->is_running = 0; + gen->resume_label = 0; + gen->classobj = NULL; + gen->yieldfrom = NULL; + gen->exc_type = NULL; + gen->exc_value = NULL; + gen->exc_traceback = NULL; + gen->gi_weakreflist = NULL; + Py_XINCREF(qualname); + gen->gi_qualname = qualname; + Py_XINCREF(name); + gen->gi_name = name; + Py_XINCREF(module_name); + gen->gi_modulename = module_name; + PyObject_GC_Track(gen); + return gen; +} + +/* PatchModuleWithCoroutine */ + static PyObject* __Pyx_Coroutine_patch_module(PyObject* module, const char* py_code) { +#if defined(__Pyx_Generator_USED) || defined(__Pyx_Coroutine_USED) + int result; + PyObject *globals, *result_obj; + globals = PyDict_New(); if (unlikely(!globals)) goto ignore; + result = PyDict_SetItemString(globals, "_cython_coroutine_type", + #ifdef __Pyx_Coroutine_USED + (PyObject*)__pyx_CoroutineType); + #else + Py_None); + #endif + if (unlikely(result < 0)) goto ignore; + result = PyDict_SetItemString(globals, "_cython_generator_type", + #ifdef __Pyx_Generator_USED + (PyObject*)__pyx_GeneratorType); + #else + Py_None); + #endif + if (unlikely(result < 0)) goto ignore; + if (unlikely(PyDict_SetItemString(globals, "_module", module) < 0)) goto ignore; + if (unlikely(PyDict_SetItemString(globals, "__builtins__", __pyx_b) < 0)) goto ignore; + result_obj = PyRun_String(py_code, Py_file_input, globals, globals); + if (unlikely(!result_obj)) goto ignore; + Py_DECREF(result_obj); + Py_DECREF(globals); + return module; +ignore: + Py_XDECREF(globals); + PyErr_WriteUnraisable(module); + if (unlikely(PyErr_WarnEx(PyExc_RuntimeWarning, "Cython module failed to patch module with custom type", 1) < 0)) { + Py_DECREF(module); + module = NULL; + } +#else + py_code++; +#endif + return module; +} + +/* PatchGeneratorABC */ + #if defined(__Pyx_Generator_USED) || defined(__Pyx_Coroutine_USED) +static PyObject* __Pyx_patch_abc_module(PyObject *module); +static PyObject* __Pyx_patch_abc_module(PyObject *module) { + module = __Pyx_Coroutine_patch_module( + module, "" +"if _cython_generator_type is not None:\n" +" try: Generator = _module.Generator\n" +" except AttributeError: pass\n" +" else: Generator.register(_cython_generator_type)\n" +"if _cython_coroutine_type is not None:\n" +" try: Coroutine = _module.Coroutine\n" +" except AttributeError: pass\n" +" else: Coroutine.register(_cython_coroutine_type)\n" + ); + return module; +} +#endif +static int __Pyx_patch_abc(void) { +#if defined(__Pyx_Generator_USED) || defined(__Pyx_Coroutine_USED) + static int abc_patched = 0; + if (!abc_patched) { + PyObject *module; + module = PyImport_ImportModule((PY_VERSION_HEX >= 0x03030000) ? "collections.abc" : "collections"); + if (!module) { + PyErr_WriteUnraisable(NULL); + if (unlikely(PyErr_WarnEx(PyExc_RuntimeWarning, + ((PY_VERSION_HEX >= 0x03030000) ? + "Cython module failed to register with collections.abc module" : + "Cython module failed to register with collections module"), 1) < 0)) { + return -1; + } + } else { + module = __Pyx_patch_abc_module(module); + abc_patched = 1; + if (unlikely(!module)) + return -1; + Py_DECREF(module); + } + module = PyImport_ImportModule("backports_abc"); + if (module) { + module = __Pyx_patch_abc_module(module); + Py_XDECREF(module); + } + if (!module) { + PyErr_Clear(); + } + } +#else + if (0) __Pyx_Coroutine_patch_module(NULL, NULL); +#endif + return 0; +} + +/* Coroutine */ + typedef struct { + PyObject_HEAD + PyObject *coroutine; +} __pyx_CoroutineAwaitObject; +static void __Pyx_CoroutineAwait_dealloc(PyObject *self) { + PyObject_GC_UnTrack(self); + Py_CLEAR(((__pyx_CoroutineAwaitObject*)self)->coroutine); + PyObject_GC_Del(self); +} +static int __Pyx_CoroutineAwait_traverse(__pyx_CoroutineAwaitObject *self, visitproc visit, void *arg) { + Py_VISIT(self->coroutine); + return 0; +} +static int __Pyx_CoroutineAwait_clear(__pyx_CoroutineAwaitObject *self) { + Py_CLEAR(self->coroutine); + return 0; +} +static PyObject *__Pyx_CoroutineAwait_Next(__pyx_CoroutineAwaitObject *self) { + return __Pyx_Generator_Next(self->coroutine); +} +static PyObject *__Pyx_CoroutineAwait_Send(__pyx_CoroutineAwaitObject *self, PyObject *value) { + return __Pyx_Coroutine_Send(self->coroutine, value); +} +static PyObject *__Pyx_CoroutineAwait_Throw(__pyx_CoroutineAwaitObject *self, PyObject *args) { + return __Pyx_Coroutine_Throw(self->coroutine, args); +} +static PyObject *__Pyx_CoroutineAwait_Close(__pyx_CoroutineAwaitObject *self) { + return __Pyx_Coroutine_Close(self->coroutine); +} +static PyObject *__Pyx_CoroutineAwait_self(PyObject *self) { + Py_INCREF(self); + return self; +} +#if !CYTHON_COMPILING_IN_PYPY +static PyObject *__Pyx_CoroutineAwait_no_new(CYTHON_UNUSED PyTypeObject *type, CYTHON_UNUSED PyObject *args, CYTHON_UNUSED PyObject *kwargs) { + PyErr_SetString(PyExc_TypeError, "cannot instantiate type, use 'await coroutine' instead"); + return NULL; +} +#endif +static PyMethodDef __pyx_CoroutineAwait_methods[] = { + {"send", (PyCFunction) __Pyx_CoroutineAwait_Send, METH_O, + (char*) PyDoc_STR("send(arg) -> send 'arg' into coroutine,\nreturn next yielded value or raise StopIteration.")}, + {"throw", (PyCFunction) __Pyx_CoroutineAwait_Throw, METH_VARARGS, + (char*) PyDoc_STR("throw(typ[,val[,tb]]) -> raise exception in coroutine,\nreturn next yielded value or raise StopIteration.")}, + {"close", (PyCFunction) __Pyx_CoroutineAwait_Close, METH_NOARGS, + (char*) PyDoc_STR("close() -> raise GeneratorExit inside coroutine.")}, + {0, 0, 0, 0} +}; +static PyTypeObject __pyx_CoroutineAwaitType_type = { + PyVarObject_HEAD_INIT(0, 0) + "coroutine_wrapper", + sizeof(__pyx_CoroutineAwaitObject), + 0, + (destructor) __Pyx_CoroutineAwait_dealloc, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC, + PyDoc_STR("A wrapper object implementing __await__ for coroutines."), + (traverseproc) __Pyx_CoroutineAwait_traverse, + (inquiry) __Pyx_CoroutineAwait_clear, + 0, + 0, + __Pyx_CoroutineAwait_self, + (iternextfunc) __Pyx_CoroutineAwait_Next, + __pyx_CoroutineAwait_methods, + 0 , + 0 , + 0, + 0, + 0, + 0, + 0, + 0, + 0, +#if !CYTHON_COMPILING_IN_PYPY + __Pyx_CoroutineAwait_no_new, +#else + 0, +#endif + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, +#if PY_VERSION_HEX >= 0x030400a1 + 0, +#endif +}; +static CYTHON_INLINE PyObject *__Pyx__Coroutine_await(PyObject *coroutine) { +#if CYTHON_COMPILING_IN_CPYTHON + __pyx_CoroutineAwaitObject *await = PyObject_GC_New(__pyx_CoroutineAwaitObject, __pyx_CoroutineAwaitType); +#else + __pyx_CoroutineAwaitObject *await = (__pyx_CoroutineAwaitObject*) + __pyx_CoroutineAwaitType->tp_new(__pyx_CoroutineAwaitType, __pyx_empty_tuple, NULL); +#endif + if (unlikely(!await)) return NULL; + Py_INCREF(coroutine); + await->coroutine = coroutine; +#if CYTHON_COMPILING_IN_CPYTHON + PyObject_GC_Track(await); +#endif + return (PyObject*)await; +} +static PyObject *__Pyx_Coroutine_await(PyObject *coroutine) { + if (unlikely(!coroutine || !__Pyx_Coroutine_CheckExact(coroutine))) { + PyErr_SetString(PyExc_TypeError, "invalid input, expected coroutine"); + return NULL; + } + return __Pyx__Coroutine_await(coroutine); +} +static void __Pyx_Coroutine_check_and_dealloc(PyObject *self) { + __pyx_CoroutineObject *gen = (__pyx_CoroutineObject *) self; + if (gen->resume_label == 0 && !PyErr_Occurred()) { + PyObject_GC_UnTrack(self); +#if PY_VERSION_HEX >= 0x03030000 || defined(PyErr_WarnFormat) + PyErr_WarnFormat(PyExc_RuntimeWarning, 1, "coroutine '%.50S' was never awaited", gen->gi_qualname); + PyErr_Clear(); +#else + {PyObject *msg; + char *cmsg; + #if CYTHON_COMPILING_IN_PYPY + msg = NULL; + cmsg = (char*) "coroutine was never awaited"; + #else + char *cname; + PyObject *qualname; + #if PY_MAJOR_VERSION >= 3 + qualname = PyUnicode_AsUTF8String(gen->gi_qualname); + if (likely(qualname)) { + cname = PyBytes_AS_STRING(qualname); + } else { + PyErr_Clear(); + cname = (char*) "?"; + } + msg = PyBytes_FromFormat( + #else + qualname = gen->gi_qualname; + cname = PyString_AS_STRING(qualname); + msg = PyString_FromFormat( + #endif + "coroutine '%.50s' was never awaited", cname); + #if PY_MAJOR_VERSION >= 3 + Py_XDECREF(qualname); + #endif + if (unlikely(!msg)) { + PyErr_Clear(); + cmsg = (char*) "coroutine was never awaited"; + } else { + #if PY_MAJOR_VERSION >= 3 + cmsg = PyBytes_AS_STRING(msg); + #else + cmsg = PyString_AS_STRING(msg); + #endif + } + #endif + if (unlikely(PyErr_WarnEx(PyExc_RuntimeWarning, cmsg, 1) < 0)) + PyErr_WriteUnraisable(self); + Py_XDECREF(msg);} +#endif + PyObject_GC_Track(self); + } + __Pyx_Coroutine_dealloc(self); +} +#if CYTHON_COMPILING_IN_CPYTHON && PY_MAJOR_VERSION >= 3 && PY_VERSION_HEX < 0x030500B1 +static PyObject *__Pyx_Coroutine_compare(PyObject *obj, PyObject *other, int op) { + PyObject* result; + switch (op) { + case Py_EQ: result = (other == obj) ? Py_True : Py_False; break; + case Py_NE: result = (other != obj) ? Py_True : Py_False; break; + default: + result = Py_NotImplemented; + } + Py_INCREF(result); + return result; +} +#endif +static PyMethodDef __pyx_Coroutine_methods[] = { + {"send", (PyCFunction) __Pyx_Coroutine_Send, METH_O, + (char*) PyDoc_STR("send(arg) -> send 'arg' into coroutine,\nreturn next iterated value or raise StopIteration.")}, + {"throw", (PyCFunction) __Pyx_Coroutine_Throw, METH_VARARGS, + (char*) PyDoc_STR("throw(typ[,val[,tb]]) -> raise exception in coroutine,\nreturn next iterated value or raise StopIteration.")}, + {"close", (PyCFunction) __Pyx_Coroutine_Close, METH_NOARGS, + (char*) PyDoc_STR("close() -> raise GeneratorExit inside coroutine.")}, +#if PY_VERSION_HEX < 0x030500B1 + {"__await__", (PyCFunction) __Pyx_Coroutine_await, METH_NOARGS, + (char*) PyDoc_STR("__await__() -> return an iterator to be used in await expression.")}, +#endif + {0, 0, 0, 0} +}; +static PyMemberDef __pyx_Coroutine_memberlist[] = { + {(char *) "cr_running", T_BOOL, offsetof(__pyx_CoroutineObject, is_running), READONLY, NULL}, + {(char*) "cr_await", T_OBJECT, offsetof(__pyx_CoroutineObject, yieldfrom), READONLY, + (char*) PyDoc_STR("object being awaited, or None")}, + {(char *) "__module__", T_OBJECT, offsetof(__pyx_CoroutineObject, gi_modulename), PY_WRITE_RESTRICTED, 0}, + {0, 0, 0, 0, 0} +}; +static PyGetSetDef __pyx_Coroutine_getsets[] = { + {(char *) "__name__", (getter)__Pyx_Coroutine_get_name, (setter)__Pyx_Coroutine_set_name, + (char*) PyDoc_STR("name of the coroutine"), 0}, + {(char *) "__qualname__", (getter)__Pyx_Coroutine_get_qualname, (setter)__Pyx_Coroutine_set_qualname, + (char*) PyDoc_STR("qualified name of the coroutine"), 0}, + {0, 0, 0, 0, 0} +}; +#if CYTHON_USE_ASYNC_SLOTS +static __Pyx_PyAsyncMethodsStruct __pyx_Coroutine_as_async = { + __Pyx_Coroutine_await, + 0, + 0, +}; +#endif +static PyTypeObject __pyx_CoroutineType_type = { + PyVarObject_HEAD_INIT(0, 0) + "coroutine", + sizeof(__pyx_CoroutineObject), + 0, + (destructor) __Pyx_Coroutine_check_and_dealloc, + 0, + 0, + 0, +#if CYTHON_USE_ASYNC_SLOTS + &__pyx_Coroutine_as_async, +#else + 0, +#endif + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC | Py_TPFLAGS_HAVE_FINALIZE, + 0, + (traverseproc) __Pyx_Coroutine_traverse, + 0, +#if CYTHON_COMPILING_IN_CPYTHON && PY_MAJOR_VERSION >= 3 && PY_VERSION_HEX < 0x030500B1 + __Pyx_Coroutine_compare, +#else + 0, +#endif + offsetof(__pyx_CoroutineObject, gi_weakreflist), + __Pyx_Coroutine_await, /* tp_iter */ + (iternextfunc) __Pyx_Generator_Next, /* tp_iternext */ + __pyx_Coroutine_methods, + __pyx_Coroutine_memberlist, + __pyx_Coroutine_getsets, + + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, +#if PY_VERSION_HEX >= 0x030400a1 + 0, +#else + __Pyx_Coroutine_del, +#endif + 0, +#if PY_VERSION_HEX >= 0x030400a1 + __Pyx_Coroutine_del, +#endif +}; +static int __pyx_Coroutine_init(void) { + __pyx_CoroutineType_type.tp_getattro = PyObject_GenericGetAttr; + __pyx_CoroutineType = __Pyx_FetchCommonType(&__pyx_CoroutineType_type); + if (unlikely(!__pyx_CoroutineType)) + return -1; + __pyx_CoroutineAwaitType = __Pyx_FetchCommonType(&__pyx_CoroutineAwaitType_type); + if (unlikely(!__pyx_CoroutineAwaitType)) + return -1; + return 0; +} + +/* GetAwaitIter */ + static CYTHON_INLINE PyObject *__Pyx_Coroutine_GetAwaitableIter(PyObject *o) { +#ifdef __Pyx_Coroutine_USED + if (__Pyx_Coroutine_CheckExact(o)) { + Py_INCREF(o); + return o; + } +#endif + return __Pyx__Coroutine_GetAwaitableIter(o); +} +static PyObject *__Pyx__Coroutine_GetAwaitableIter(PyObject *obj) { + PyObject *res; +#if CYTHON_USE_ASYNC_SLOTS + __Pyx_PyAsyncMethodsStruct* am = __Pyx_PyType_AsAsync(obj); + if (likely(am && am->am_await)) { + res = (*am->am_await)(obj); + } else +#endif +#if PY_VERSION_HEX >= 0x030500B2 || defined(PyCoro_CheckExact) + if (PyCoro_CheckExact(obj)) { + Py_INCREF(obj); + return obj; + } else +#endif +#if CYTHON_COMPILING_IN_CPYTHON && defined(CO_ITERABLE_COROUTINE) + if (PyGen_CheckExact(obj) && ((PyGenObject*)obj)->gi_code && ((PyCodeObject *)((PyGenObject*)obj)->gi_code)->co_flags & CO_ITERABLE_COROUTINE) { + Py_INCREF(obj); + return obj; + } else +#endif + { + PyObject *method = __Pyx_PyObject_GetAttrStr(obj, __pyx_n_s_await); + if (unlikely(!method)) goto slot_error; + #if CYTHON_UNPACK_METHODS + if (likely(PyMethod_Check(method))) { + PyObject *self = PyMethod_GET_SELF(method); + if (likely(self)) { + PyObject *function = PyMethod_GET_FUNCTION(method); + res = __Pyx_PyObject_CallOneArg(function, self); + } else + res = __Pyx_PyObject_CallNoArg(method); + } else + #endif + res = __Pyx_PyObject_CallNoArg(method); + Py_DECREF(method); + } + if (unlikely(!res)) goto bad; + if (!PyIter_Check(res)) { + PyErr_Format(PyExc_TypeError, + "__await__() returned non-iterator of type '%.100s'", + Py_TYPE(res)->tp_name); + Py_CLEAR(res); + } else { + int is_coroutine = 0; + #ifdef __Pyx_Coroutine_USED + is_coroutine |= __Pyx_Coroutine_CheckExact(res); + #endif + #if PY_VERSION_HEX >= 0x030500B2 || defined(PyCoro_CheckExact) + is_coroutine |= PyCoro_CheckExact(res); + #endif + if (unlikely(is_coroutine)) { + /* __await__ must return an *iterator*, not + a coroutine or another awaitable (see PEP 492) */ + PyErr_SetString(PyExc_TypeError, + "__await__() returned a coroutine"); + Py_CLEAR(res); + } + } + return res; +slot_error: + PyErr_Format(PyExc_TypeError, + "object %.100s can't be used in 'await' expression", + Py_TYPE(obj)->tp_name); +bad: + return NULL; +} + +/* CoroutineYieldFrom */ + static int __Pyx_WarnAIterDeprecation(PyObject *aiter) { + int result; +#if PY_MAJOR_VERSION >= 3 + result = PyErr_WarnFormat( + PyExc_PendingDeprecationWarning, 1, + "'%.100s' implements legacy __aiter__ protocol; " + "__aiter__ should return an asynchronous " + "iterator, not awaitable", + Py_TYPE(aiter)->tp_name); +#else + result = PyErr_WarnEx( + PyExc_PendingDeprecationWarning, + "object implements legacy __aiter__ protocol; " + "__aiter__ should return an asynchronous " + "iterator, not awaitable", + 1); +#endif + return result != 0; +} +static CYTHON_INLINE PyObject* __Pyx__Coroutine_Yield_From(__pyx_CoroutineObject *gen, PyObject *source, int warn) { + PyObject *retval; + if (__Pyx_Coroutine_CheckExact(source)) { + if (warn && unlikely(__Pyx_WarnAIterDeprecation(source))) { + return NULL; + } + retval = __Pyx_Generator_Next(source); + if (retval) { + Py_INCREF(source); + gen->yieldfrom = source; + return retval; + } + } else { + PyObject *source_gen = __Pyx__Coroutine_GetAwaitableIter(source); + if (unlikely(!source_gen)) + return NULL; + if (warn && unlikely(__Pyx_WarnAIterDeprecation(source))) { + Py_DECREF(source_gen); + return NULL; + } + if (__Pyx_Coroutine_CheckExact(source_gen)) { + retval = __Pyx_Generator_Next(source_gen); + } else { + retval = Py_TYPE(source_gen)->tp_iternext(source_gen); + } + if (retval) { + gen->yieldfrom = source_gen; + return retval; + } + Py_DECREF(source_gen); + } + return NULL; +} + +/* ReturnWithStopIteration */ + static void __Pyx__ReturnWithStopIteration(PyObject* value) { + PyObject *exc, *args; +#if CYTHON_COMPILING_IN_CPYTHON || CYTHON_COMPILING_IN_PYSTON + __Pyx_PyThreadState_declare + if ((PY_VERSION_HEX >= 0x03030000 && PY_VERSION_HEX < 0x030500B1) || unlikely(PyTuple_Check(value))) { + args = PyTuple_New(1); + if (unlikely(!args)) return; + Py_INCREF(value); + PyTuple_SET_ITEM(args, 0, value); + exc = PyType_Type.tp_call(PyExc_StopIteration, args, NULL); + Py_DECREF(args); + if (!exc) return; + } else { + Py_INCREF(value); + exc = value; + } + __Pyx_PyThreadState_assign + if (!__pyx_tstate->exc_type) { + Py_INCREF(PyExc_StopIteration); + __Pyx_ErrRestore(PyExc_StopIteration, exc, NULL); + return; + } +#else + args = PyTuple_Pack(1, value); + if (unlikely(!args)) return; + exc = PyObject_Call(PyExc_StopIteration, args, NULL); + Py_DECREF(args); + if (unlikely(!exc)) return; +#endif + PyErr_SetObject(PyExc_StopIteration, exc); + Py_DECREF(exc); +} + +/* None */ + static CYTHON_INLINE void __Pyx_RaiseClosureNameError(const char *varname) { + PyErr_Format(PyExc_NameError, "free variable '%s' referenced before assignment in enclosing scope", varname); +} + +/* SetVTable */ + static int __Pyx_SetVtable(PyObject *dict, void *vtable) { +#if PY_VERSION_HEX >= 0x02070000 + PyObject *ob = PyCapsule_New(vtable, 0, 0); +#else + PyObject *ob = PyCObject_FromVoidPtr(vtable, 0); +#endif + if (!ob) + goto bad; + if (PyDict_SetItem(dict, __pyx_n_s_pyx_vtable, ob) < 0) + goto bad; + Py_DECREF(ob); + return 0; +bad: + Py_XDECREF(ob); + return -1; +} + +/* Import */ + static PyObject *__Pyx_Import(PyObject *name, PyObject *from_list, int level) { + PyObject *empty_list = 0; + PyObject *module = 0; + PyObject *global_dict = 0; + PyObject *empty_dict = 0; + PyObject *list; + #if PY_VERSION_HEX < 0x03030000 + PyObject *py_import; + py_import = __Pyx_PyObject_GetAttrStr(__pyx_b, __pyx_n_s_import); + if (!py_import) + goto bad; + #endif + if (from_list) + list = from_list; + else { + empty_list = PyList_New(0); + if (!empty_list) + goto bad; + list = empty_list; + } + global_dict = PyModule_GetDict(__pyx_m); + if (!global_dict) + goto bad; + empty_dict = PyDict_New(); + if (!empty_dict) + goto bad; + { + #if PY_MAJOR_VERSION >= 3 + if (level == -1) { + if (strchr(__Pyx_MODULE_NAME, '.')) { + #if PY_VERSION_HEX < 0x03030000 + PyObject *py_level = PyInt_FromLong(1); + if (!py_level) + goto bad; + module = PyObject_CallFunctionObjArgs(py_import, + name, global_dict, empty_dict, list, py_level, NULL); + Py_DECREF(py_level); + #else + module = PyImport_ImportModuleLevelObject( + name, global_dict, empty_dict, list, 1); + #endif + if (!module) { + if (!PyErr_ExceptionMatches(PyExc_ImportError)) + goto bad; + PyErr_Clear(); + } + } + level = 0; + } + #endif + if (!module) { + #if PY_VERSION_HEX < 0x03030000 + PyObject *py_level = PyInt_FromLong(level); + if (!py_level) + goto bad; + module = PyObject_CallFunctionObjArgs(py_import, + name, global_dict, empty_dict, list, py_level, NULL); + Py_DECREF(py_level); + #else + module = PyImport_ImportModuleLevelObject( + name, global_dict, empty_dict, list, level); + #endif + } + } +bad: + #if PY_VERSION_HEX < 0x03030000 + Py_XDECREF(py_import); + #endif + Py_XDECREF(empty_list); + Py_XDECREF(empty_dict); + return module; +} + +/* PatchInspect */ + static PyObject* __Pyx_patch_inspect(PyObject* module) { +#if defined(__Pyx_Generator_USED) && (!defined(CYTHON_PATCH_INSPECT) || CYTHON_PATCH_INSPECT) + static int inspect_patched = 0; + if (unlikely((!inspect_patched) && module)) { + module = __Pyx_Coroutine_patch_module( + module, "" +"old_types = getattr(_module.isgenerator, '_cython_generator_types', None)\n" +"if old_types is None or not isinstance(old_types, set):\n" +" old_types = set()\n" +" def cy_wrap(orig_func, type=type, cython_generator_types=old_types):\n" +" def cy_isgenerator(obj): return type(obj) in cython_generator_types or orig_func(obj)\n" +" cy_isgenerator._cython_generator_types = cython_generator_types\n" +" return cy_isgenerator\n" +" _module.isgenerator = cy_wrap(_module.isgenerator)\n" +"old_types.add(_cython_generator_type)\n" + ); + inspect_patched = 1; + } +#else + if (0) return __Pyx_Coroutine_patch_module(module, NULL); +#endif + return module; +} + +/* PatchAsyncIO */ + static PyObject* __Pyx_patch_asyncio(PyObject* module) { +#if PY_VERSION_HEX < 0x030500B2 &&\ + (defined(__Pyx_Coroutine_USED) || defined(__Pyx_Generator_USED)) &&\ + (!defined(CYTHON_PATCH_ASYNCIO) || CYTHON_PATCH_ASYNCIO) + PyObject *patch_module = NULL; + static int asyncio_patched = 0; + if (unlikely((!asyncio_patched) && module)) { + PyObject *package; + package = __Pyx_Import(__pyx_n_s_asyncio_coroutines, NULL, 0); + if (package) { + patch_module = __Pyx_Coroutine_patch_module( + PyObject_GetAttrString(package, "coroutines"), "" +"try:\n" +" coro_types = _module._COROUTINE_TYPES\n" +"except AttributeError: pass\n" +"else:\n" +" if _cython_coroutine_type is not None and _cython_coroutine_type not in coro_types:\n" +" coro_types = tuple(coro_types) + (_cython_coroutine_type,)\n" +" if _cython_generator_type is not None and _cython_generator_type not in coro_types:\n" +" coro_types = tuple(coro_types) + (_cython_generator_type,)\n" +"_module._COROUTINE_TYPES = coro_types\n" + ); + } else { + PyErr_Clear(); +#if PY_VERSION_HEX < 0x03040200 + package = __Pyx_Import(__pyx_n_s_asyncio_tasks, NULL, 0); + if (unlikely(!package)) goto asyncio_done; + patch_module = __Pyx_Coroutine_patch_module( + PyObject_GetAttrString(package, "tasks"), "" +"if hasattr(_module, 'iscoroutine'):\n" +" old_types = getattr(_module.iscoroutine, '_cython_coroutine_types', None)\n" +" if old_types is None or not isinstance(old_types, set):\n" +" old_types = set()\n" +" def cy_wrap(orig_func, type=type, cython_coroutine_types=old_types):\n" +" def cy_iscoroutine(obj): return type(obj) in cython_coroutine_types or orig_func(obj)\n" +" cy_iscoroutine._cython_coroutine_types = cython_coroutine_types\n" +" return cy_iscoroutine\n" +" _module.iscoroutine = cy_wrap(_module.iscoroutine)\n" +" if _cython_coroutine_type is not None:\n" +" old_types.add(_cython_coroutine_type)\n" +" if _cython_generator_type is not None:\n" +" old_types.add(_cython_generator_type)\n" + ); +#endif + } + Py_DECREF(package); + if (unlikely(!patch_module)) goto ignore; +#if PY_VERSION_HEX < 0x03040200 +asyncio_done: + PyErr_Clear(); +#endif + asyncio_patched = 1; +#ifdef __Pyx_Generator_USED + { + PyObject *inspect_module; + if (patch_module) { + inspect_module = PyObject_GetAttr(patch_module, __pyx_n_s_inspect); + Py_DECREF(patch_module); + } else { + inspect_module = __Pyx_Import(__pyx_n_s_inspect, NULL, 0); + } + if (unlikely(!inspect_module)) goto ignore; + inspect_module = __Pyx_patch_inspect(inspect_module); + if (unlikely(!inspect_module)) { + Py_DECREF(module); + module = NULL; + } + Py_XDECREF(inspect_module); + } +#else + if (0) return __Pyx_patch_inspect(module); +#endif + } + return module; +ignore: + PyErr_WriteUnraisable(module); + if (unlikely(PyErr_WarnEx(PyExc_RuntimeWarning, "Cython module failed to patch asyncio package with custom generator type", 1) < 0)) { + Py_DECREF(module); + module = NULL; + } +#else + if (0) return __Pyx_patch_inspect(__Pyx_Coroutine_patch_module(module, NULL)); +#endif + return module; +} + +/* ImportFrom */ + static PyObject* __Pyx_ImportFrom(PyObject* module, PyObject* name) { + PyObject* value = __Pyx_PyObject_GetAttrStr(module, name); + if (unlikely(!value) && PyErr_ExceptionMatches(PyExc_AttributeError)) { + PyErr_Format(PyExc_ImportError, + #if PY_MAJOR_VERSION < 3 + "cannot import name %.230s", PyString_AS_STRING(name)); + #else + "cannot import name %S", name); + #endif + } + return value; +} + +/* CalculateMetaclass */ + static PyObject *__Pyx_CalculateMetaclass(PyTypeObject *metaclass, PyObject *bases) { + Py_ssize_t i, nbases = PyTuple_GET_SIZE(bases); + for (i=0; i < nbases; i++) { + PyTypeObject *tmptype; + PyObject *tmp = PyTuple_GET_ITEM(bases, i); + tmptype = Py_TYPE(tmp); +#if PY_MAJOR_VERSION < 3 + if (tmptype == &PyClass_Type) + continue; +#endif + if (!metaclass) { + metaclass = tmptype; + continue; + } + if (PyType_IsSubtype(metaclass, tmptype)) + continue; + if (PyType_IsSubtype(tmptype, metaclass)) { + metaclass = tmptype; + continue; + } + PyErr_SetString(PyExc_TypeError, + "metaclass conflict: " + "the metaclass of a derived class " + "must be a (non-strict) subclass " + "of the metaclasses of all its bases"); + return NULL; + } + if (!metaclass) { +#if PY_MAJOR_VERSION < 3 + metaclass = &PyClass_Type; +#else + metaclass = &PyType_Type; +#endif + } + Py_INCREF((PyObject*) metaclass); + return (PyObject*) metaclass; +} + +/* Py3ClassCreate */ + static PyObject *__Pyx_Py3MetaclassPrepare(PyObject *metaclass, PyObject *bases, PyObject *name, + PyObject *qualname, PyObject *mkw, PyObject *modname, PyObject *doc) { + PyObject *ns; + if (metaclass) { + PyObject *prep = __Pyx_PyObject_GetAttrStr(metaclass, __pyx_n_s_prepare_2); + if (prep) { + PyObject *pargs = PyTuple_Pack(2, name, bases); + if (unlikely(!pargs)) { + Py_DECREF(prep); + return NULL; + } + ns = PyObject_Call(prep, pargs, mkw); + Py_DECREF(prep); + Py_DECREF(pargs); + } else { + if (unlikely(!PyErr_ExceptionMatches(PyExc_AttributeError))) + return NULL; + PyErr_Clear(); + ns = PyDict_New(); + } + } else { + ns = PyDict_New(); + } + if (unlikely(!ns)) + return NULL; + if (unlikely(PyObject_SetItem(ns, __pyx_n_s_module, modname) < 0)) goto bad; + if (unlikely(PyObject_SetItem(ns, __pyx_n_s_qualname, qualname) < 0)) goto bad; + if (unlikely(doc && PyObject_SetItem(ns, __pyx_n_s_doc, doc) < 0)) goto bad; + return ns; +bad: + Py_DECREF(ns); + return NULL; +} +static PyObject *__Pyx_Py3ClassCreate(PyObject *metaclass, PyObject *name, PyObject *bases, + PyObject *dict, PyObject *mkw, + int calculate_metaclass, int allow_py2_metaclass) { + PyObject *result, *margs; + PyObject *owned_metaclass = NULL; + if (allow_py2_metaclass) { + owned_metaclass = PyObject_GetItem(dict, __pyx_n_s_metaclass); + if (owned_metaclass) { + metaclass = owned_metaclass; + } else if (likely(PyErr_ExceptionMatches(PyExc_KeyError))) { + PyErr_Clear(); + } else { + return NULL; + } + } + if (calculate_metaclass && (!metaclass || PyType_Check(metaclass))) { + metaclass = __Pyx_CalculateMetaclass((PyTypeObject*) metaclass, bases); + Py_XDECREF(owned_metaclass); + if (unlikely(!metaclass)) + return NULL; + owned_metaclass = metaclass; + } + margs = PyTuple_Pack(3, name, bases, dict); + if (unlikely(!margs)) { + result = NULL; + } else { + result = PyObject_Call(metaclass, margs, mkw); + Py_DECREF(margs); + } + Py_XDECREF(owned_metaclass); + return result; +} + +/* CodeObjectCache */ + static int __pyx_bisect_code_objects(__Pyx_CodeObjectCacheEntry* entries, int count, int code_line) { + int start = 0, mid = 0, end = count - 1; + if (end >= 0 && code_line > entries[end].code_line) { + return count; + } + while (start < end) { + mid = start + (end - start) / 2; + if (code_line < entries[mid].code_line) { + end = mid; + } else if (code_line > entries[mid].code_line) { + start = mid + 1; + } else { + return mid; + } + } + if (code_line <= entries[mid].code_line) { + return mid; + } else { + return mid + 1; + } +} +static PyCodeObject *__pyx_find_code_object(int code_line) { + PyCodeObject* code_object; + int pos; + if (unlikely(!code_line) || unlikely(!__pyx_code_cache.entries)) { + return NULL; + } + pos = __pyx_bisect_code_objects(__pyx_code_cache.entries, __pyx_code_cache.count, code_line); + if (unlikely(pos >= __pyx_code_cache.count) || unlikely(__pyx_code_cache.entries[pos].code_line != code_line)) { + return NULL; + } + code_object = __pyx_code_cache.entries[pos].code_object; + Py_INCREF(code_object); + return code_object; +} +static void __pyx_insert_code_object(int code_line, PyCodeObject* code_object) { + int pos, i; + __Pyx_CodeObjectCacheEntry* entries = __pyx_code_cache.entries; + if (unlikely(!code_line)) { + return; + } + if (unlikely(!entries)) { + entries = (__Pyx_CodeObjectCacheEntry*)PyMem_Malloc(64*sizeof(__Pyx_CodeObjectCacheEntry)); + if (likely(entries)) { + __pyx_code_cache.entries = entries; + __pyx_code_cache.max_count = 64; + __pyx_code_cache.count = 1; + entries[0].code_line = code_line; + entries[0].code_object = code_object; + Py_INCREF(code_object); + } + return; + } + pos = __pyx_bisect_code_objects(__pyx_code_cache.entries, __pyx_code_cache.count, code_line); + if ((pos < __pyx_code_cache.count) && unlikely(__pyx_code_cache.entries[pos].code_line == code_line)) { + PyCodeObject* tmp = entries[pos].code_object; + entries[pos].code_object = code_object; + Py_DECREF(tmp); + return; + } + if (__pyx_code_cache.count == __pyx_code_cache.max_count) { + int new_max = __pyx_code_cache.max_count + 64; + entries = (__Pyx_CodeObjectCacheEntry*)PyMem_Realloc( + __pyx_code_cache.entries, (size_t)new_max*sizeof(__Pyx_CodeObjectCacheEntry)); + if (unlikely(!entries)) { + return; + } + __pyx_code_cache.entries = entries; + __pyx_code_cache.max_count = new_max; + } + for (i=__pyx_code_cache.count; i>pos; i--) { + entries[i] = entries[i-1]; + } + entries[pos].code_line = code_line; + entries[pos].code_object = code_object; + __pyx_code_cache.count++; + Py_INCREF(code_object); +} + +/* AddTraceback */ + #include "compile.h" +#include "frameobject.h" +#include "traceback.h" +static PyCodeObject* __Pyx_CreateCodeObjectForTraceback( + const char *funcname, int c_line, + int py_line, const char *filename) { + PyCodeObject *py_code = 0; + PyObject *py_srcfile = 0; + PyObject *py_funcname = 0; + #if PY_MAJOR_VERSION < 3 + py_srcfile = PyString_FromString(filename); + #else + py_srcfile = PyUnicode_FromString(filename); + #endif + if (!py_srcfile) goto bad; + if (c_line) { + #if PY_MAJOR_VERSION < 3 + py_funcname = PyString_FromFormat( "%s (%s:%d)", funcname, __pyx_cfilenm, c_line); + #else + py_funcname = PyUnicode_FromFormat( "%s (%s:%d)", funcname, __pyx_cfilenm, c_line); + #endif + } + else { + #if PY_MAJOR_VERSION < 3 + py_funcname = PyString_FromString(funcname); + #else + py_funcname = PyUnicode_FromString(funcname); + #endif + } + if (!py_funcname) goto bad; + py_code = __Pyx_PyCode_New( + 0, + 0, + 0, + 0, + 0, + __pyx_empty_bytes, /*PyObject *code,*/ + __pyx_empty_tuple, /*PyObject *consts,*/ + __pyx_empty_tuple, /*PyObject *names,*/ + __pyx_empty_tuple, /*PyObject *varnames,*/ + __pyx_empty_tuple, /*PyObject *freevars,*/ + __pyx_empty_tuple, /*PyObject *cellvars,*/ + py_srcfile, /*PyObject *filename,*/ + py_funcname, /*PyObject *name,*/ + py_line, + __pyx_empty_bytes /*PyObject *lnotab*/ + ); + Py_DECREF(py_srcfile); + Py_DECREF(py_funcname); + return py_code; +bad: + Py_XDECREF(py_srcfile); + Py_XDECREF(py_funcname); + return NULL; +} +static void __Pyx_AddTraceback(const char *funcname, int c_line, + int py_line, const char *filename) { + PyCodeObject *py_code = 0; + PyFrameObject *py_frame = 0; + py_code = __pyx_find_code_object(c_line ? c_line : py_line); + if (!py_code) { + py_code = __Pyx_CreateCodeObjectForTraceback( + funcname, c_line, py_line, filename); + if (!py_code) goto bad; + __pyx_insert_code_object(c_line ? c_line : py_line, py_code); + } + py_frame = PyFrame_New( + PyThreadState_GET(), /*PyThreadState *tstate,*/ + py_code, /*PyCodeObject *code,*/ + __pyx_d, /*PyObject *globals,*/ + 0 /*PyObject *locals*/ + ); + if (!py_frame) goto bad; + __Pyx_PyFrame_SetLineNumber(py_frame, py_line); + PyTraceBack_Here(py_frame); +bad: + Py_XDECREF(py_code); + Py_XDECREF(py_frame); +} + +/* CIntToPy */ + static CYTHON_INLINE PyObject* __Pyx_PyInt_From_enum____pyx_t_7asyncpg_8protocol_8protocol_AuthenticationMessage(enum __pyx_t_7asyncpg_8protocol_8protocol_AuthenticationMessage value) { + const enum __pyx_t_7asyncpg_8protocol_8protocol_AuthenticationMessage neg_one = (enum __pyx_t_7asyncpg_8protocol_8protocol_AuthenticationMessage) -1, const_zero = (enum __pyx_t_7asyncpg_8protocol_8protocol_AuthenticationMessage) 0; + const int is_unsigned = neg_one > const_zero; + if (is_unsigned) { + if (sizeof(enum __pyx_t_7asyncpg_8protocol_8protocol_AuthenticationMessage) < sizeof(long)) { + return PyInt_FromLong((long) value); + } else if (sizeof(enum __pyx_t_7asyncpg_8protocol_8protocol_AuthenticationMessage) <= sizeof(unsigned long)) { + return PyLong_FromUnsignedLong((unsigned long) value); +#ifdef HAVE_LONG_LONG + } else if (sizeof(enum __pyx_t_7asyncpg_8protocol_8protocol_AuthenticationMessage) <= sizeof(unsigned PY_LONG_LONG)) { + return PyLong_FromUnsignedLongLong((unsigned PY_LONG_LONG) value); +#endif + } + } else { + if (sizeof(enum __pyx_t_7asyncpg_8protocol_8protocol_AuthenticationMessage) <= sizeof(long)) { + return PyInt_FromLong((long) value); +#ifdef HAVE_LONG_LONG + } else if (sizeof(enum __pyx_t_7asyncpg_8protocol_8protocol_AuthenticationMessage) <= sizeof(PY_LONG_LONG)) { + return PyLong_FromLongLong((PY_LONG_LONG) value); +#endif + } + } + { + int one = 1; int little = (int)*(unsigned char *)&one; + unsigned char *bytes = (unsigned char *)&value; + return _PyLong_FromByteArray(bytes, sizeof(enum __pyx_t_7asyncpg_8protocol_8protocol_AuthenticationMessage), + little, !is_unsigned); + } +} + +/* CIntFromPyVerify */ + #define __PYX_VERIFY_RETURN_INT(target_type, func_type, func_value)\ + __PYX__VERIFY_RETURN_INT(target_type, func_type, func_value, 0) +#define __PYX_VERIFY_RETURN_INT_EXC(target_type, func_type, func_value)\ + __PYX__VERIFY_RETURN_INT(target_type, func_type, func_value, 1) +#define __PYX__VERIFY_RETURN_INT(target_type, func_type, func_value, exc)\ + {\ + func_type value = func_value;\ + if (sizeof(target_type) < sizeof(func_type)) {\ + if (unlikely(value != (func_type) (target_type) value)) {\ + func_type zero = 0;\ + if (exc && unlikely(value == (func_type)-1 && PyErr_Occurred()))\ + return (target_type) -1;\ + if (is_unsigned && unlikely(value < zero))\ + goto raise_neg_overflow;\ + else\ + goto raise_overflow;\ + }\ + }\ + return (target_type) value;\ + } + +/* CIntToPy */ + static CYTHON_INLINE PyObject* __Pyx_PyInt_From_long(long value) { + const long neg_one = (long) -1, const_zero = (long) 0; + const int is_unsigned = neg_one > const_zero; + if (is_unsigned) { + if (sizeof(long) < sizeof(long)) { + return PyInt_FromLong((long) value); + } else if (sizeof(long) <= sizeof(unsigned long)) { + return PyLong_FromUnsignedLong((unsigned long) value); +#ifdef HAVE_LONG_LONG + } else if (sizeof(long) <= sizeof(unsigned PY_LONG_LONG)) { + return PyLong_FromUnsignedLongLong((unsigned PY_LONG_LONG) value); +#endif + } + } else { + if (sizeof(long) <= sizeof(long)) { + return PyInt_FromLong((long) value); +#ifdef HAVE_LONG_LONG + } else if (sizeof(long) <= sizeof(PY_LONG_LONG)) { + return PyLong_FromLongLong((PY_LONG_LONG) value); +#endif + } + } + { + int one = 1; int little = (int)*(unsigned char *)&one; + unsigned char *bytes = (unsigned char *)&value; + return _PyLong_FromByteArray(bytes, sizeof(long), + little, !is_unsigned); + } +} + +/* CIntToPy */ + static CYTHON_INLINE PyObject* __Pyx_PyInt_From_char(char value) { + const char neg_one = (char) -1, const_zero = (char) 0; + const int is_unsigned = neg_one > const_zero; + if (is_unsigned) { + if (sizeof(char) < sizeof(long)) { + return PyInt_FromLong((long) value); + } else if (sizeof(char) <= sizeof(unsigned long)) { + return PyLong_FromUnsignedLong((unsigned long) value); +#ifdef HAVE_LONG_LONG + } else if (sizeof(char) <= sizeof(unsigned PY_LONG_LONG)) { + return PyLong_FromUnsignedLongLong((unsigned PY_LONG_LONG) value); +#endif + } + } else { + if (sizeof(char) <= sizeof(long)) { + return PyInt_FromLong((long) value); +#ifdef HAVE_LONG_LONG + } else if (sizeof(char) <= sizeof(PY_LONG_LONG)) { + return PyLong_FromLongLong((PY_LONG_LONG) value); +#endif + } + } + { + int one = 1; int little = (int)*(unsigned char *)&one; + unsigned char *bytes = (unsigned char *)&value; + return _PyLong_FromByteArray(bytes, sizeof(char), + little, !is_unsigned); + } +} + +/* CIntToPy */ + static CYTHON_INLINE PyObject* __Pyx_PyInt_From_int32_t(int32_t value) { + const int32_t neg_one = (int32_t) -1, const_zero = (int32_t) 0; + const int is_unsigned = neg_one > const_zero; + if (is_unsigned) { + if (sizeof(int32_t) < sizeof(long)) { + return PyInt_FromLong((long) value); + } else if (sizeof(int32_t) <= sizeof(unsigned long)) { + return PyLong_FromUnsignedLong((unsigned long) value); +#ifdef HAVE_LONG_LONG + } else if (sizeof(int32_t) <= sizeof(unsigned PY_LONG_LONG)) { + return PyLong_FromUnsignedLongLong((unsigned PY_LONG_LONG) value); +#endif + } + } else { + if (sizeof(int32_t) <= sizeof(long)) { + return PyInt_FromLong((long) value); +#ifdef HAVE_LONG_LONG + } else if (sizeof(int32_t) <= sizeof(PY_LONG_LONG)) { + return PyLong_FromLongLong((PY_LONG_LONG) value); +#endif + } + } + { + int one = 1; int little = (int)*(unsigned char *)&one; + unsigned char *bytes = (unsigned char *)&value; + return _PyLong_FromByteArray(bytes, sizeof(int32_t), + little, !is_unsigned); + } +} + +/* CIntToPy */ + static CYTHON_INLINE PyObject* __Pyx_PyInt_From_int16_t(int16_t value) { + const int16_t neg_one = (int16_t) -1, const_zero = (int16_t) 0; + const int is_unsigned = neg_one > const_zero; + if (is_unsigned) { + if (sizeof(int16_t) < sizeof(long)) { + return PyInt_FromLong((long) value); + } else if (sizeof(int16_t) <= sizeof(unsigned long)) { + return PyLong_FromUnsignedLong((unsigned long) value); +#ifdef HAVE_LONG_LONG + } else if (sizeof(int16_t) <= sizeof(unsigned PY_LONG_LONG)) { + return PyLong_FromUnsignedLongLong((unsigned PY_LONG_LONG) value); +#endif + } + } else { + if (sizeof(int16_t) <= sizeof(long)) { + return PyInt_FromLong((long) value); +#ifdef HAVE_LONG_LONG + } else if (sizeof(int16_t) <= sizeof(PY_LONG_LONG)) { + return PyLong_FromLongLong((PY_LONG_LONG) value); +#endif + } + } + { + int one = 1; int little = (int)*(unsigned char *)&one; + unsigned char *bytes = (unsigned char *)&value; + return _PyLong_FromByteArray(bytes, sizeof(int16_t), + little, !is_unsigned); + } +} + +/* CIntToPy */ + static CYTHON_INLINE PyObject* __Pyx_PyInt_From_enum____pyx_t_7asyncpg_8protocol_8protocol_CodecType(enum __pyx_t_7asyncpg_8protocol_8protocol_CodecType value) { + const enum __pyx_t_7asyncpg_8protocol_8protocol_CodecType neg_one = (enum __pyx_t_7asyncpg_8protocol_8protocol_CodecType) -1, const_zero = (enum __pyx_t_7asyncpg_8protocol_8protocol_CodecType) 0; + const int is_unsigned = neg_one > const_zero; + if (is_unsigned) { + if (sizeof(enum __pyx_t_7asyncpg_8protocol_8protocol_CodecType) < sizeof(long)) { + return PyInt_FromLong((long) value); + } else if (sizeof(enum __pyx_t_7asyncpg_8protocol_8protocol_CodecType) <= sizeof(unsigned long)) { + return PyLong_FromUnsignedLong((unsigned long) value); +#ifdef HAVE_LONG_LONG + } else if (sizeof(enum __pyx_t_7asyncpg_8protocol_8protocol_CodecType) <= sizeof(unsigned PY_LONG_LONG)) { + return PyLong_FromUnsignedLongLong((unsigned PY_LONG_LONG) value); +#endif + } + } else { + if (sizeof(enum __pyx_t_7asyncpg_8protocol_8protocol_CodecType) <= sizeof(long)) { + return PyInt_FromLong((long) value); +#ifdef HAVE_LONG_LONG + } else if (sizeof(enum __pyx_t_7asyncpg_8protocol_8protocol_CodecType) <= sizeof(PY_LONG_LONG)) { + return PyLong_FromLongLong((PY_LONG_LONG) value); +#endif + } + } + { + int one = 1; int little = (int)*(unsigned char *)&one; + unsigned char *bytes = (unsigned char *)&value; + return _PyLong_FromByteArray(bytes, sizeof(enum __pyx_t_7asyncpg_8protocol_8protocol_CodecType), + little, !is_unsigned); + } +} + +/* CIntToPy */ + static CYTHON_INLINE PyObject* __Pyx_PyInt_From_uint32_t(uint32_t value) { + const uint32_t neg_one = (uint32_t) -1, const_zero = (uint32_t) 0; + const int is_unsigned = neg_one > const_zero; + if (is_unsigned) { + if (sizeof(uint32_t) < sizeof(long)) { + return PyInt_FromLong((long) value); + } else if (sizeof(uint32_t) <= sizeof(unsigned long)) { + return PyLong_FromUnsignedLong((unsigned long) value); +#ifdef HAVE_LONG_LONG + } else if (sizeof(uint32_t) <= sizeof(unsigned PY_LONG_LONG)) { + return PyLong_FromUnsignedLongLong((unsigned PY_LONG_LONG) value); +#endif + } + } else { + if (sizeof(uint32_t) <= sizeof(long)) { + return PyInt_FromLong((long) value); +#ifdef HAVE_LONG_LONG + } else if (sizeof(uint32_t) <= sizeof(PY_LONG_LONG)) { + return PyLong_FromLongLong((PY_LONG_LONG) value); +#endif + } + } + { + int one = 1; int little = (int)*(unsigned char *)&one; + unsigned char *bytes = (unsigned char *)&value; + return _PyLong_FromByteArray(bytes, sizeof(uint32_t), + little, !is_unsigned); + } +} + +/* CIntToPy */ + static CYTHON_INLINE PyObject* __Pyx_PyInt_From_int(int value) { + const int neg_one = (int) -1, const_zero = (int) 0; + const int is_unsigned = neg_one > const_zero; + if (is_unsigned) { + if (sizeof(int) < sizeof(long)) { + return PyInt_FromLong((long) value); + } else if (sizeof(int) <= sizeof(unsigned long)) { + return PyLong_FromUnsignedLong((unsigned long) value); +#ifdef HAVE_LONG_LONG + } else if (sizeof(int) <= sizeof(unsigned PY_LONG_LONG)) { + return PyLong_FromUnsignedLongLong((unsigned PY_LONG_LONG) value); +#endif + } + } else { + if (sizeof(int) <= sizeof(long)) { + return PyInt_FromLong((long) value); +#ifdef HAVE_LONG_LONG + } else if (sizeof(int) <= sizeof(PY_LONG_LONG)) { + return PyLong_FromLongLong((PY_LONG_LONG) value); +#endif + } + } + { + int one = 1; int little = (int)*(unsigned char *)&one; + unsigned char *bytes = (unsigned char *)&value; + return _PyLong_FromByteArray(bytes, sizeof(int), + little, !is_unsigned); + } +} + +/* UnicodeAsUCS4 */ + static CYTHON_INLINE Py_UCS4 __Pyx_PyUnicode_AsPy_UCS4(PyObject* x) { + Py_ssize_t length; + #if CYTHON_PEP393_ENABLED + length = PyUnicode_GET_LENGTH(x); + if (likely(length == 1)) { + return PyUnicode_READ_CHAR(x, 0); + } + #else + length = PyUnicode_GET_SIZE(x); + if (likely(length == 1)) { + return PyUnicode_AS_UNICODE(x)[0]; + } + #if Py_UNICODE_SIZE == 2 + else if (PyUnicode_GET_SIZE(x) == 2) { + Py_UCS4 high_val = PyUnicode_AS_UNICODE(x)[0]; + if (high_val >= 0xD800 && high_val <= 0xDBFF) { + Py_UCS4 low_val = PyUnicode_AS_UNICODE(x)[1]; + if (low_val >= 0xDC00 && low_val <= 0xDFFF) { + return 0x10000 + (((high_val & ((1<<10)-1)) << 10) | (low_val & ((1<<10)-1))); + } + } + } + #endif + #endif + PyErr_Format(PyExc_ValueError, + "only single character unicode strings can be converted to Py_UCS4, " + "got length %" CYTHON_FORMAT_SSIZE_T "d", length); + return (Py_UCS4)-1; +} + +/* CIntToPy */ + static CYTHON_INLINE PyObject* __Pyx_PyInt_From_enum____pyx_t_7asyncpg_8protocol_8protocol_CodecFormat(enum __pyx_t_7asyncpg_8protocol_8protocol_CodecFormat value) { + const enum __pyx_t_7asyncpg_8protocol_8protocol_CodecFormat neg_one = (enum __pyx_t_7asyncpg_8protocol_8protocol_CodecFormat) -1, const_zero = (enum __pyx_t_7asyncpg_8protocol_8protocol_CodecFormat) 0; + const int is_unsigned = neg_one > const_zero; + if (is_unsigned) { + if (sizeof(enum __pyx_t_7asyncpg_8protocol_8protocol_CodecFormat) < sizeof(long)) { + return PyInt_FromLong((long) value); + } else if (sizeof(enum __pyx_t_7asyncpg_8protocol_8protocol_CodecFormat) <= sizeof(unsigned long)) { + return PyLong_FromUnsignedLong((unsigned long) value); +#ifdef HAVE_LONG_LONG + } else if (sizeof(enum __pyx_t_7asyncpg_8protocol_8protocol_CodecFormat) <= sizeof(unsigned PY_LONG_LONG)) { + return PyLong_FromUnsignedLongLong((unsigned PY_LONG_LONG) value); +#endif + } + } else { + if (sizeof(enum __pyx_t_7asyncpg_8protocol_8protocol_CodecFormat) <= sizeof(long)) { + return PyInt_FromLong((long) value); +#ifdef HAVE_LONG_LONG + } else if (sizeof(enum __pyx_t_7asyncpg_8protocol_8protocol_CodecFormat) <= sizeof(PY_LONG_LONG)) { + return PyLong_FromLongLong((PY_LONG_LONG) value); +#endif + } + } + { + int one = 1; int little = (int)*(unsigned char *)&one; + unsigned char *bytes = (unsigned char *)&value; + return _PyLong_FromByteArray(bytes, sizeof(enum __pyx_t_7asyncpg_8protocol_8protocol_CodecFormat), + little, !is_unsigned); + } +} + +/* CIntToPy */ + static CYTHON_INLINE PyObject* __Pyx_PyInt_From_int64_t(int64_t value) { + const int64_t neg_one = (int64_t) -1, const_zero = (int64_t) 0; + const int is_unsigned = neg_one > const_zero; + if (is_unsigned) { + if (sizeof(int64_t) < sizeof(long)) { + return PyInt_FromLong((long) value); + } else if (sizeof(int64_t) <= sizeof(unsigned long)) { + return PyLong_FromUnsignedLong((unsigned long) value); +#ifdef HAVE_LONG_LONG + } else if (sizeof(int64_t) <= sizeof(unsigned PY_LONG_LONG)) { + return PyLong_FromUnsignedLongLong((unsigned PY_LONG_LONG) value); +#endif + } + } else { + if (sizeof(int64_t) <= sizeof(long)) { + return PyInt_FromLong((long) value); +#ifdef HAVE_LONG_LONG + } else if (sizeof(int64_t) <= sizeof(PY_LONG_LONG)) { + return PyLong_FromLongLong((PY_LONG_LONG) value); +#endif + } + } + { + int one = 1; int little = (int)*(unsigned char *)&one; + unsigned char *bytes = (unsigned char *)&value; + return _PyLong_FromByteArray(bytes, sizeof(int64_t), + little, !is_unsigned); + } +} + +/* CIntToPy */ + static CYTHON_INLINE PyObject* __Pyx_PyInt_From_uint8_t(uint8_t value) { + const uint8_t neg_one = (uint8_t) -1, const_zero = (uint8_t) 0; + const int is_unsigned = neg_one > const_zero; + if (is_unsigned) { + if (sizeof(uint8_t) < sizeof(long)) { + return PyInt_FromLong((long) value); + } else if (sizeof(uint8_t) <= sizeof(unsigned long)) { + return PyLong_FromUnsignedLong((unsigned long) value); +#ifdef HAVE_LONG_LONG + } else if (sizeof(uint8_t) <= sizeof(unsigned PY_LONG_LONG)) { + return PyLong_FromUnsignedLongLong((unsigned PY_LONG_LONG) value); +#endif + } + } else { + if (sizeof(uint8_t) <= sizeof(long)) { + return PyInt_FromLong((long) value); +#ifdef HAVE_LONG_LONG + } else if (sizeof(uint8_t) <= sizeof(PY_LONG_LONG)) { + return PyLong_FromLongLong((PY_LONG_LONG) value); +#endif + } + } + { + int one = 1; int little = (int)*(unsigned char *)&one; + unsigned char *bytes = (unsigned char *)&value; + return _PyLong_FromByteArray(bytes, sizeof(uint8_t), + little, !is_unsigned); + } +} + +/* CIntToPy */ + static CYTHON_INLINE PyObject* __Pyx_PyInt_From_ptrdiff_t(ptrdiff_t value) { + const ptrdiff_t neg_one = (ptrdiff_t) -1, const_zero = (ptrdiff_t) 0; + const int is_unsigned = neg_one > const_zero; + if (is_unsigned) { + if (sizeof(ptrdiff_t) < sizeof(long)) { + return PyInt_FromLong((long) value); + } else if (sizeof(ptrdiff_t) <= sizeof(unsigned long)) { + return PyLong_FromUnsignedLong((unsigned long) value); +#ifdef HAVE_LONG_LONG + } else if (sizeof(ptrdiff_t) <= sizeof(unsigned PY_LONG_LONG)) { + return PyLong_FromUnsignedLongLong((unsigned PY_LONG_LONG) value); +#endif + } + } else { + if (sizeof(ptrdiff_t) <= sizeof(long)) { + return PyInt_FromLong((long) value); +#ifdef HAVE_LONG_LONG + } else if (sizeof(ptrdiff_t) <= sizeof(PY_LONG_LONG)) { + return PyLong_FromLongLong((PY_LONG_LONG) value); +#endif + } + } + { + int one = 1; int little = (int)*(unsigned char *)&one; + unsigned char *bytes = (unsigned char *)&value; + return _PyLong_FromByteArray(bytes, sizeof(ptrdiff_t), + little, !is_unsigned); + } +} + +/* CIntToPy */ + static CYTHON_INLINE PyObject* __Pyx_PyInt_From_enum____pyx_t_7asyncpg_8protocol_8protocol_ProtocolState(enum __pyx_t_7asyncpg_8protocol_8protocol_ProtocolState value) { + const enum __pyx_t_7asyncpg_8protocol_8protocol_ProtocolState neg_one = (enum __pyx_t_7asyncpg_8protocol_8protocol_ProtocolState) -1, const_zero = (enum __pyx_t_7asyncpg_8protocol_8protocol_ProtocolState) 0; + const int is_unsigned = neg_one > const_zero; + if (is_unsigned) { + if (sizeof(enum __pyx_t_7asyncpg_8protocol_8protocol_ProtocolState) < sizeof(long)) { + return PyInt_FromLong((long) value); + } else if (sizeof(enum __pyx_t_7asyncpg_8protocol_8protocol_ProtocolState) <= sizeof(unsigned long)) { + return PyLong_FromUnsignedLong((unsigned long) value); +#ifdef HAVE_LONG_LONG + } else if (sizeof(enum __pyx_t_7asyncpg_8protocol_8protocol_ProtocolState) <= sizeof(unsigned PY_LONG_LONG)) { + return PyLong_FromUnsignedLongLong((unsigned PY_LONG_LONG) value); +#endif + } + } else { + if (sizeof(enum __pyx_t_7asyncpg_8protocol_8protocol_ProtocolState) <= sizeof(long)) { + return PyInt_FromLong((long) value); +#ifdef HAVE_LONG_LONG + } else if (sizeof(enum __pyx_t_7asyncpg_8protocol_8protocol_ProtocolState) <= sizeof(PY_LONG_LONG)) { + return PyLong_FromLongLong((PY_LONG_LONG) value); +#endif + } + } + { + int one = 1; int little = (int)*(unsigned char *)&one; + unsigned char *bytes = (unsigned char *)&value; + return _PyLong_FromByteArray(bytes, sizeof(enum __pyx_t_7asyncpg_8protocol_8protocol_ProtocolState), + little, !is_unsigned); + } +} + +/* CIntToPy */ + static CYTHON_INLINE PyObject* __Pyx_PyInt_From_uint64_t(uint64_t value) { + const uint64_t neg_one = (uint64_t) -1, const_zero = (uint64_t) 0; + const int is_unsigned = neg_one > const_zero; + if (is_unsigned) { + if (sizeof(uint64_t) < sizeof(long)) { + return PyInt_FromLong((long) value); + } else if (sizeof(uint64_t) <= sizeof(unsigned long)) { + return PyLong_FromUnsignedLong((unsigned long) value); +#ifdef HAVE_LONG_LONG + } else if (sizeof(uint64_t) <= sizeof(unsigned PY_LONG_LONG)) { + return PyLong_FromUnsignedLongLong((unsigned PY_LONG_LONG) value); +#endif + } + } else { + if (sizeof(uint64_t) <= sizeof(long)) { + return PyInt_FromLong((long) value); +#ifdef HAVE_LONG_LONG + } else if (sizeof(uint64_t) <= sizeof(PY_LONG_LONG)) { + return PyLong_FromLongLong((PY_LONG_LONG) value); +#endif + } + } + { + int one = 1; int little = (int)*(unsigned char *)&one; + unsigned char *bytes = (unsigned char *)&value; + return _PyLong_FromByteArray(bytes, sizeof(uint64_t), + little, !is_unsigned); + } +} + +/* CIntFromPy */ + static CYTHON_INLINE uint32_t __Pyx_PyInt_As_uint32_t(PyObject *x) { + const uint32_t neg_one = (uint32_t) -1, const_zero = (uint32_t) 0; + const int is_unsigned = neg_one > const_zero; +#if PY_MAJOR_VERSION < 3 + if (likely(PyInt_Check(x))) { + if (sizeof(uint32_t) < sizeof(long)) { + __PYX_VERIFY_RETURN_INT(uint32_t, long, PyInt_AS_LONG(x)) + } else { + long val = PyInt_AS_LONG(x); + if (is_unsigned && unlikely(val < 0)) { + goto raise_neg_overflow; + } + return (uint32_t) val; + } + } else +#endif + if (likely(PyLong_Check(x))) { + if (is_unsigned) { +#if CYTHON_USE_PYLONG_INTERNALS + const digit* digits = ((PyLongObject*)x)->ob_digit; + switch (Py_SIZE(x)) { + case 0: return (uint32_t) 0; + case 1: __PYX_VERIFY_RETURN_INT(uint32_t, digit, digits[0]) + case 2: + if (8 * sizeof(uint32_t) > 1 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(uint32_t, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(uint32_t) >= 2 * PyLong_SHIFT) { + return (uint32_t) (((((uint32_t)digits[1]) << PyLong_SHIFT) | (uint32_t)digits[0])); + } + } + break; + case 3: + if (8 * sizeof(uint32_t) > 2 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(uint32_t, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(uint32_t) >= 3 * PyLong_SHIFT) { + return (uint32_t) (((((((uint32_t)digits[2]) << PyLong_SHIFT) | (uint32_t)digits[1]) << PyLong_SHIFT) | (uint32_t)digits[0])); + } + } + break; + case 4: + if (8 * sizeof(uint32_t) > 3 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(uint32_t, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(uint32_t) >= 4 * PyLong_SHIFT) { + return (uint32_t) (((((((((uint32_t)digits[3]) << PyLong_SHIFT) | (uint32_t)digits[2]) << PyLong_SHIFT) | (uint32_t)digits[1]) << PyLong_SHIFT) | (uint32_t)digits[0])); + } + } + break; + } +#endif +#if CYTHON_COMPILING_IN_CPYTHON + if (unlikely(Py_SIZE(x) < 0)) { + goto raise_neg_overflow; + } +#else + { + int result = PyObject_RichCompareBool(x, Py_False, Py_LT); + if (unlikely(result < 0)) + return (uint32_t) -1; + if (unlikely(result == 1)) + goto raise_neg_overflow; + } +#endif + if (sizeof(uint32_t) <= sizeof(unsigned long)) { + __PYX_VERIFY_RETURN_INT_EXC(uint32_t, unsigned long, PyLong_AsUnsignedLong(x)) +#ifdef HAVE_LONG_LONG + } else if (sizeof(uint32_t) <= sizeof(unsigned PY_LONG_LONG)) { + __PYX_VERIFY_RETURN_INT_EXC(uint32_t, unsigned PY_LONG_LONG, PyLong_AsUnsignedLongLong(x)) +#endif + } + } else { +#if CYTHON_USE_PYLONG_INTERNALS + const digit* digits = ((PyLongObject*)x)->ob_digit; + switch (Py_SIZE(x)) { + case 0: return (uint32_t) 0; + case -1: __PYX_VERIFY_RETURN_INT(uint32_t, sdigit, (sdigit) (-(sdigit)digits[0])) + case 1: __PYX_VERIFY_RETURN_INT(uint32_t, digit, +digits[0]) + case -2: + if (8 * sizeof(uint32_t) - 1 > 1 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(uint32_t, long, -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(uint32_t) - 1 > 2 * PyLong_SHIFT) { + return (uint32_t) (((uint32_t)-1)*(((((uint32_t)digits[1]) << PyLong_SHIFT) | (uint32_t)digits[0]))); + } + } + break; + case 2: + if (8 * sizeof(uint32_t) > 1 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(uint32_t, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(uint32_t) - 1 > 2 * PyLong_SHIFT) { + return (uint32_t) ((((((uint32_t)digits[1]) << PyLong_SHIFT) | (uint32_t)digits[0]))); + } + } + break; + case -3: + if (8 * sizeof(uint32_t) - 1 > 2 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(uint32_t, long, -(long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(uint32_t) - 1 > 3 * PyLong_SHIFT) { + return (uint32_t) (((uint32_t)-1)*(((((((uint32_t)digits[2]) << PyLong_SHIFT) | (uint32_t)digits[1]) << PyLong_SHIFT) | (uint32_t)digits[0]))); + } + } + break; + case 3: + if (8 * sizeof(uint32_t) > 2 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(uint32_t, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(uint32_t) - 1 > 3 * PyLong_SHIFT) { + return (uint32_t) ((((((((uint32_t)digits[2]) << PyLong_SHIFT) | (uint32_t)digits[1]) << PyLong_SHIFT) | (uint32_t)digits[0]))); + } + } + break; + case -4: + if (8 * sizeof(uint32_t) - 1 > 3 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(uint32_t, long, -(long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(uint32_t) - 1 > 4 * PyLong_SHIFT) { + return (uint32_t) (((uint32_t)-1)*(((((((((uint32_t)digits[3]) << PyLong_SHIFT) | (uint32_t)digits[2]) << PyLong_SHIFT) | (uint32_t)digits[1]) << PyLong_SHIFT) | (uint32_t)digits[0]))); + } + } + break; + case 4: + if (8 * sizeof(uint32_t) > 3 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(uint32_t, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(uint32_t) - 1 > 4 * PyLong_SHIFT) { + return (uint32_t) ((((((((((uint32_t)digits[3]) << PyLong_SHIFT) | (uint32_t)digits[2]) << PyLong_SHIFT) | (uint32_t)digits[1]) << PyLong_SHIFT) | (uint32_t)digits[0]))); + } + } + break; + } +#endif + if (sizeof(uint32_t) <= sizeof(long)) { + __PYX_VERIFY_RETURN_INT_EXC(uint32_t, long, PyLong_AsLong(x)) +#ifdef HAVE_LONG_LONG + } else if (sizeof(uint32_t) <= sizeof(PY_LONG_LONG)) { + __PYX_VERIFY_RETURN_INT_EXC(uint32_t, PY_LONG_LONG, PyLong_AsLongLong(x)) +#endif + } + } + { +#if CYTHON_COMPILING_IN_PYPY && !defined(_PyLong_AsByteArray) + PyErr_SetString(PyExc_RuntimeError, + "_PyLong_AsByteArray() not available in PyPy, cannot convert large numbers"); +#else + uint32_t val; + PyObject *v = __Pyx_PyNumber_IntOrLong(x); + #if PY_MAJOR_VERSION < 3 + if (likely(v) && !PyLong_Check(v)) { + PyObject *tmp = v; + v = PyNumber_Long(tmp); + Py_DECREF(tmp); + } + #endif + if (likely(v)) { + int one = 1; int is_little = (int)*(unsigned char *)&one; + unsigned char *bytes = (unsigned char *)&val; + int ret = _PyLong_AsByteArray((PyLongObject *)v, + bytes, sizeof(val), + is_little, !is_unsigned); + Py_DECREF(v); + if (likely(!ret)) + return val; + } +#endif + return (uint32_t) -1; + } + } else { + uint32_t val; + PyObject *tmp = __Pyx_PyNumber_IntOrLong(x); + if (!tmp) return (uint32_t) -1; + val = __Pyx_PyInt_As_uint32_t(tmp); + Py_DECREF(tmp); + return val; + } +raise_overflow: + PyErr_SetString(PyExc_OverflowError, + "value too large to convert to uint32_t"); + return (uint32_t) -1; +raise_neg_overflow: + PyErr_SetString(PyExc_OverflowError, + "can't convert negative value to uint32_t"); + return (uint32_t) -1; +} + +/* CIntFromPy */ + static CYTHON_INLINE enum __pyx_t_7asyncpg_8protocol_8protocol_CodecFormat __Pyx_PyInt_As_enum____pyx_t_7asyncpg_8protocol_8protocol_CodecFormat(PyObject *x) { + const enum __pyx_t_7asyncpg_8protocol_8protocol_CodecFormat neg_one = (enum __pyx_t_7asyncpg_8protocol_8protocol_CodecFormat) -1, const_zero = (enum __pyx_t_7asyncpg_8protocol_8protocol_CodecFormat) 0; + const int is_unsigned = neg_one > const_zero; +#if PY_MAJOR_VERSION < 3 + if (likely(PyInt_Check(x))) { + if (sizeof(enum __pyx_t_7asyncpg_8protocol_8protocol_CodecFormat) < sizeof(long)) { + __PYX_VERIFY_RETURN_INT(enum __pyx_t_7asyncpg_8protocol_8protocol_CodecFormat, long, PyInt_AS_LONG(x)) + } else { + long val = PyInt_AS_LONG(x); + if (is_unsigned && unlikely(val < 0)) { + goto raise_neg_overflow; + } + return (enum __pyx_t_7asyncpg_8protocol_8protocol_CodecFormat) val; + } + } else +#endif + if (likely(PyLong_Check(x))) { + if (is_unsigned) { +#if CYTHON_USE_PYLONG_INTERNALS + const digit* digits = ((PyLongObject*)x)->ob_digit; + switch (Py_SIZE(x)) { + case 0: return (enum __pyx_t_7asyncpg_8protocol_8protocol_CodecFormat) 0; + case 1: __PYX_VERIFY_RETURN_INT(enum __pyx_t_7asyncpg_8protocol_8protocol_CodecFormat, digit, digits[0]) + case 2: + if (8 * sizeof(enum __pyx_t_7asyncpg_8protocol_8protocol_CodecFormat) > 1 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(enum __pyx_t_7asyncpg_8protocol_8protocol_CodecFormat, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(enum __pyx_t_7asyncpg_8protocol_8protocol_CodecFormat) >= 2 * PyLong_SHIFT) { + return (enum __pyx_t_7asyncpg_8protocol_8protocol_CodecFormat) (((((enum __pyx_t_7asyncpg_8protocol_8protocol_CodecFormat)digits[1]) << PyLong_SHIFT) | (enum __pyx_t_7asyncpg_8protocol_8protocol_CodecFormat)digits[0])); + } + } + break; + case 3: + if (8 * sizeof(enum __pyx_t_7asyncpg_8protocol_8protocol_CodecFormat) > 2 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(enum __pyx_t_7asyncpg_8protocol_8protocol_CodecFormat, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(enum __pyx_t_7asyncpg_8protocol_8protocol_CodecFormat) >= 3 * PyLong_SHIFT) { + return (enum __pyx_t_7asyncpg_8protocol_8protocol_CodecFormat) (((((((enum __pyx_t_7asyncpg_8protocol_8protocol_CodecFormat)digits[2]) << PyLong_SHIFT) | (enum __pyx_t_7asyncpg_8protocol_8protocol_CodecFormat)digits[1]) << PyLong_SHIFT) | (enum __pyx_t_7asyncpg_8protocol_8protocol_CodecFormat)digits[0])); + } + } + break; + case 4: + if (8 * sizeof(enum __pyx_t_7asyncpg_8protocol_8protocol_CodecFormat) > 3 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(enum __pyx_t_7asyncpg_8protocol_8protocol_CodecFormat, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(enum __pyx_t_7asyncpg_8protocol_8protocol_CodecFormat) >= 4 * PyLong_SHIFT) { + return (enum __pyx_t_7asyncpg_8protocol_8protocol_CodecFormat) (((((((((enum __pyx_t_7asyncpg_8protocol_8protocol_CodecFormat)digits[3]) << PyLong_SHIFT) | (enum __pyx_t_7asyncpg_8protocol_8protocol_CodecFormat)digits[2]) << PyLong_SHIFT) | (enum __pyx_t_7asyncpg_8protocol_8protocol_CodecFormat)digits[1]) << PyLong_SHIFT) | (enum __pyx_t_7asyncpg_8protocol_8protocol_CodecFormat)digits[0])); + } + } + break; + } +#endif +#if CYTHON_COMPILING_IN_CPYTHON + if (unlikely(Py_SIZE(x) < 0)) { + goto raise_neg_overflow; + } +#else + { + int result = PyObject_RichCompareBool(x, Py_False, Py_LT); + if (unlikely(result < 0)) + return (enum __pyx_t_7asyncpg_8protocol_8protocol_CodecFormat) -1; + if (unlikely(result == 1)) + goto raise_neg_overflow; + } +#endif + if (sizeof(enum __pyx_t_7asyncpg_8protocol_8protocol_CodecFormat) <= sizeof(unsigned long)) { + __PYX_VERIFY_RETURN_INT_EXC(enum __pyx_t_7asyncpg_8protocol_8protocol_CodecFormat, unsigned long, PyLong_AsUnsignedLong(x)) +#ifdef HAVE_LONG_LONG + } else if (sizeof(enum __pyx_t_7asyncpg_8protocol_8protocol_CodecFormat) <= sizeof(unsigned PY_LONG_LONG)) { + __PYX_VERIFY_RETURN_INT_EXC(enum __pyx_t_7asyncpg_8protocol_8protocol_CodecFormat, unsigned PY_LONG_LONG, PyLong_AsUnsignedLongLong(x)) +#endif + } + } else { +#if CYTHON_USE_PYLONG_INTERNALS + const digit* digits = ((PyLongObject*)x)->ob_digit; + switch (Py_SIZE(x)) { + case 0: return (enum __pyx_t_7asyncpg_8protocol_8protocol_CodecFormat) 0; + case -1: __PYX_VERIFY_RETURN_INT(enum __pyx_t_7asyncpg_8protocol_8protocol_CodecFormat, sdigit, (sdigit) (-(sdigit)digits[0])) + case 1: __PYX_VERIFY_RETURN_INT(enum __pyx_t_7asyncpg_8protocol_8protocol_CodecFormat, digit, +digits[0]) + case -2: + if (8 * sizeof(enum __pyx_t_7asyncpg_8protocol_8protocol_CodecFormat) - 1 > 1 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(enum __pyx_t_7asyncpg_8protocol_8protocol_CodecFormat, long, -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(enum __pyx_t_7asyncpg_8protocol_8protocol_CodecFormat) - 1 > 2 * PyLong_SHIFT) { + return (enum __pyx_t_7asyncpg_8protocol_8protocol_CodecFormat) (((enum __pyx_t_7asyncpg_8protocol_8protocol_CodecFormat)-1)*(((((enum __pyx_t_7asyncpg_8protocol_8protocol_CodecFormat)digits[1]) << PyLong_SHIFT) | (enum __pyx_t_7asyncpg_8protocol_8protocol_CodecFormat)digits[0]))); + } + } + break; + case 2: + if (8 * sizeof(enum __pyx_t_7asyncpg_8protocol_8protocol_CodecFormat) > 1 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(enum __pyx_t_7asyncpg_8protocol_8protocol_CodecFormat, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(enum __pyx_t_7asyncpg_8protocol_8protocol_CodecFormat) - 1 > 2 * PyLong_SHIFT) { + return (enum __pyx_t_7asyncpg_8protocol_8protocol_CodecFormat) ((((((enum __pyx_t_7asyncpg_8protocol_8protocol_CodecFormat)digits[1]) << PyLong_SHIFT) | (enum __pyx_t_7asyncpg_8protocol_8protocol_CodecFormat)digits[0]))); + } + } + break; + case -3: + if (8 * sizeof(enum __pyx_t_7asyncpg_8protocol_8protocol_CodecFormat) - 1 > 2 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(enum __pyx_t_7asyncpg_8protocol_8protocol_CodecFormat, long, -(long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(enum __pyx_t_7asyncpg_8protocol_8protocol_CodecFormat) - 1 > 3 * PyLong_SHIFT) { + return (enum __pyx_t_7asyncpg_8protocol_8protocol_CodecFormat) (((enum __pyx_t_7asyncpg_8protocol_8protocol_CodecFormat)-1)*(((((((enum __pyx_t_7asyncpg_8protocol_8protocol_CodecFormat)digits[2]) << PyLong_SHIFT) | (enum __pyx_t_7asyncpg_8protocol_8protocol_CodecFormat)digits[1]) << PyLong_SHIFT) | (enum __pyx_t_7asyncpg_8protocol_8protocol_CodecFormat)digits[0]))); + } + } + break; + case 3: + if (8 * sizeof(enum __pyx_t_7asyncpg_8protocol_8protocol_CodecFormat) > 2 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(enum __pyx_t_7asyncpg_8protocol_8protocol_CodecFormat, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(enum __pyx_t_7asyncpg_8protocol_8protocol_CodecFormat) - 1 > 3 * PyLong_SHIFT) { + return (enum __pyx_t_7asyncpg_8protocol_8protocol_CodecFormat) ((((((((enum __pyx_t_7asyncpg_8protocol_8protocol_CodecFormat)digits[2]) << PyLong_SHIFT) | (enum __pyx_t_7asyncpg_8protocol_8protocol_CodecFormat)digits[1]) << PyLong_SHIFT) | (enum __pyx_t_7asyncpg_8protocol_8protocol_CodecFormat)digits[0]))); + } + } + break; + case -4: + if (8 * sizeof(enum __pyx_t_7asyncpg_8protocol_8protocol_CodecFormat) - 1 > 3 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(enum __pyx_t_7asyncpg_8protocol_8protocol_CodecFormat, long, -(long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(enum __pyx_t_7asyncpg_8protocol_8protocol_CodecFormat) - 1 > 4 * PyLong_SHIFT) { + return (enum __pyx_t_7asyncpg_8protocol_8protocol_CodecFormat) (((enum __pyx_t_7asyncpg_8protocol_8protocol_CodecFormat)-1)*(((((((((enum __pyx_t_7asyncpg_8protocol_8protocol_CodecFormat)digits[3]) << PyLong_SHIFT) | (enum __pyx_t_7asyncpg_8protocol_8protocol_CodecFormat)digits[2]) << PyLong_SHIFT) | (enum __pyx_t_7asyncpg_8protocol_8protocol_CodecFormat)digits[1]) << PyLong_SHIFT) | (enum __pyx_t_7asyncpg_8protocol_8protocol_CodecFormat)digits[0]))); + } + } + break; + case 4: + if (8 * sizeof(enum __pyx_t_7asyncpg_8protocol_8protocol_CodecFormat) > 3 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(enum __pyx_t_7asyncpg_8protocol_8protocol_CodecFormat, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(enum __pyx_t_7asyncpg_8protocol_8protocol_CodecFormat) - 1 > 4 * PyLong_SHIFT) { + return (enum __pyx_t_7asyncpg_8protocol_8protocol_CodecFormat) ((((((((((enum __pyx_t_7asyncpg_8protocol_8protocol_CodecFormat)digits[3]) << PyLong_SHIFT) | (enum __pyx_t_7asyncpg_8protocol_8protocol_CodecFormat)digits[2]) << PyLong_SHIFT) | (enum __pyx_t_7asyncpg_8protocol_8protocol_CodecFormat)digits[1]) << PyLong_SHIFT) | (enum __pyx_t_7asyncpg_8protocol_8protocol_CodecFormat)digits[0]))); + } + } + break; + } +#endif + if (sizeof(enum __pyx_t_7asyncpg_8protocol_8protocol_CodecFormat) <= sizeof(long)) { + __PYX_VERIFY_RETURN_INT_EXC(enum __pyx_t_7asyncpg_8protocol_8protocol_CodecFormat, long, PyLong_AsLong(x)) +#ifdef HAVE_LONG_LONG + } else if (sizeof(enum __pyx_t_7asyncpg_8protocol_8protocol_CodecFormat) <= sizeof(PY_LONG_LONG)) { + __PYX_VERIFY_RETURN_INT_EXC(enum __pyx_t_7asyncpg_8protocol_8protocol_CodecFormat, PY_LONG_LONG, PyLong_AsLongLong(x)) +#endif + } + } + { +#if CYTHON_COMPILING_IN_PYPY && !defined(_PyLong_AsByteArray) + PyErr_SetString(PyExc_RuntimeError, + "_PyLong_AsByteArray() not available in PyPy, cannot convert large numbers"); +#else + enum __pyx_t_7asyncpg_8protocol_8protocol_CodecFormat val; + PyObject *v = __Pyx_PyNumber_IntOrLong(x); + #if PY_MAJOR_VERSION < 3 + if (likely(v) && !PyLong_Check(v)) { + PyObject *tmp = v; + v = PyNumber_Long(tmp); + Py_DECREF(tmp); + } + #endif + if (likely(v)) { + int one = 1; int is_little = (int)*(unsigned char *)&one; + unsigned char *bytes = (unsigned char *)&val; + int ret = _PyLong_AsByteArray((PyLongObject *)v, + bytes, sizeof(val), + is_little, !is_unsigned); + Py_DECREF(v); + if (likely(!ret)) + return val; + } +#endif + return (enum __pyx_t_7asyncpg_8protocol_8protocol_CodecFormat) -1; + } + } else { + enum __pyx_t_7asyncpg_8protocol_8protocol_CodecFormat val; + PyObject *tmp = __Pyx_PyNumber_IntOrLong(x); + if (!tmp) return (enum __pyx_t_7asyncpg_8protocol_8protocol_CodecFormat) -1; + val = __Pyx_PyInt_As_enum____pyx_t_7asyncpg_8protocol_8protocol_CodecFormat(tmp); + Py_DECREF(tmp); + return val; + } +raise_overflow: + PyErr_SetString(PyExc_OverflowError, + "value too large to convert to enum __pyx_t_7asyncpg_8protocol_8protocol_CodecFormat"); + return (enum __pyx_t_7asyncpg_8protocol_8protocol_CodecFormat) -1; +raise_neg_overflow: + PyErr_SetString(PyExc_OverflowError, + "can't convert negative value to enum __pyx_t_7asyncpg_8protocol_8protocol_CodecFormat"); + return (enum __pyx_t_7asyncpg_8protocol_8protocol_CodecFormat) -1; +} + +/* CIntFromPy */ + static CYTHON_INLINE int __Pyx_PyInt_As_int(PyObject *x) { + const int neg_one = (int) -1, const_zero = (int) 0; + const int is_unsigned = neg_one > const_zero; +#if PY_MAJOR_VERSION < 3 + if (likely(PyInt_Check(x))) { + if (sizeof(int) < sizeof(long)) { + __PYX_VERIFY_RETURN_INT(int, long, PyInt_AS_LONG(x)) + } else { + long val = PyInt_AS_LONG(x); + if (is_unsigned && unlikely(val < 0)) { + goto raise_neg_overflow; + } + return (int) val; + } + } else +#endif + if (likely(PyLong_Check(x))) { + if (is_unsigned) { +#if CYTHON_USE_PYLONG_INTERNALS + const digit* digits = ((PyLongObject*)x)->ob_digit; + switch (Py_SIZE(x)) { + case 0: return (int) 0; + case 1: __PYX_VERIFY_RETURN_INT(int, digit, digits[0]) + case 2: + if (8 * sizeof(int) > 1 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(int) >= 2 * PyLong_SHIFT) { + return (int) (((((int)digits[1]) << PyLong_SHIFT) | (int)digits[0])); + } + } + break; + case 3: + if (8 * sizeof(int) > 2 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(int) >= 3 * PyLong_SHIFT) { + return (int) (((((((int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0])); + } + } + break; + case 4: + if (8 * sizeof(int) > 3 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(int) >= 4 * PyLong_SHIFT) { + return (int) (((((((((int)digits[3]) << PyLong_SHIFT) | (int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0])); + } + } + break; + } +#endif +#if CYTHON_COMPILING_IN_CPYTHON + if (unlikely(Py_SIZE(x) < 0)) { + goto raise_neg_overflow; + } +#else + { + int result = PyObject_RichCompareBool(x, Py_False, Py_LT); + if (unlikely(result < 0)) + return (int) -1; + if (unlikely(result == 1)) + goto raise_neg_overflow; + } +#endif + if (sizeof(int) <= sizeof(unsigned long)) { + __PYX_VERIFY_RETURN_INT_EXC(int, unsigned long, PyLong_AsUnsignedLong(x)) +#ifdef HAVE_LONG_LONG + } else if (sizeof(int) <= sizeof(unsigned PY_LONG_LONG)) { + __PYX_VERIFY_RETURN_INT_EXC(int, unsigned PY_LONG_LONG, PyLong_AsUnsignedLongLong(x)) +#endif + } + } else { +#if CYTHON_USE_PYLONG_INTERNALS + const digit* digits = ((PyLongObject*)x)->ob_digit; + switch (Py_SIZE(x)) { + case 0: return (int) 0; + case -1: __PYX_VERIFY_RETURN_INT(int, sdigit, (sdigit) (-(sdigit)digits[0])) + case 1: __PYX_VERIFY_RETURN_INT(int, digit, +digits[0]) + case -2: + if (8 * sizeof(int) - 1 > 1 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(int, long, -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(int) - 1 > 2 * PyLong_SHIFT) { + return (int) (((int)-1)*(((((int)digits[1]) << PyLong_SHIFT) | (int)digits[0]))); + } + } + break; + case 2: + if (8 * sizeof(int) > 1 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(int) - 1 > 2 * PyLong_SHIFT) { + return (int) ((((((int)digits[1]) << PyLong_SHIFT) | (int)digits[0]))); + } + } + break; + case -3: + if (8 * sizeof(int) - 1 > 2 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(int, long, -(long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(int) - 1 > 3 * PyLong_SHIFT) { + return (int) (((int)-1)*(((((((int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0]))); + } + } + break; + case 3: + if (8 * sizeof(int) > 2 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(int) - 1 > 3 * PyLong_SHIFT) { + return (int) ((((((((int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0]))); + } + } + break; + case -4: + if (8 * sizeof(int) - 1 > 3 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(int, long, -(long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(int) - 1 > 4 * PyLong_SHIFT) { + return (int) (((int)-1)*(((((((((int)digits[3]) << PyLong_SHIFT) | (int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0]))); + } + } + break; + case 4: + if (8 * sizeof(int) > 3 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(int) - 1 > 4 * PyLong_SHIFT) { + return (int) ((((((((((int)digits[3]) << PyLong_SHIFT) | (int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0]))); + } + } + break; + } +#endif + if (sizeof(int) <= sizeof(long)) { + __PYX_VERIFY_RETURN_INT_EXC(int, long, PyLong_AsLong(x)) +#ifdef HAVE_LONG_LONG + } else if (sizeof(int) <= sizeof(PY_LONG_LONG)) { + __PYX_VERIFY_RETURN_INT_EXC(int, PY_LONG_LONG, PyLong_AsLongLong(x)) +#endif + } + } + { +#if CYTHON_COMPILING_IN_PYPY && !defined(_PyLong_AsByteArray) + PyErr_SetString(PyExc_RuntimeError, + "_PyLong_AsByteArray() not available in PyPy, cannot convert large numbers"); +#else + int val; + PyObject *v = __Pyx_PyNumber_IntOrLong(x); + #if PY_MAJOR_VERSION < 3 + if (likely(v) && !PyLong_Check(v)) { + PyObject *tmp = v; + v = PyNumber_Long(tmp); + Py_DECREF(tmp); + } + #endif + if (likely(v)) { + int one = 1; int is_little = (int)*(unsigned char *)&one; + unsigned char *bytes = (unsigned char *)&val; + int ret = _PyLong_AsByteArray((PyLongObject *)v, + bytes, sizeof(val), + is_little, !is_unsigned); + Py_DECREF(v); + if (likely(!ret)) + return val; + } +#endif + return (int) -1; + } + } else { + int val; + PyObject *tmp = __Pyx_PyNumber_IntOrLong(x); + if (!tmp) return (int) -1; + val = __Pyx_PyInt_As_int(tmp); + Py_DECREF(tmp); + return val; + } +raise_overflow: + PyErr_SetString(PyExc_OverflowError, + "value too large to convert to int"); + return (int) -1; +raise_neg_overflow: + PyErr_SetString(PyExc_OverflowError, + "can't convert negative value to int"); + return (int) -1; +} + +/* CIntFromPy */ + static CYTHON_INLINE int64_t __Pyx_PyInt_As_int64_t(PyObject *x) { + const int64_t neg_one = (int64_t) -1, const_zero = (int64_t) 0; + const int is_unsigned = neg_one > const_zero; +#if PY_MAJOR_VERSION < 3 + if (likely(PyInt_Check(x))) { + if (sizeof(int64_t) < sizeof(long)) { + __PYX_VERIFY_RETURN_INT(int64_t, long, PyInt_AS_LONG(x)) + } else { + long val = PyInt_AS_LONG(x); + if (is_unsigned && unlikely(val < 0)) { + goto raise_neg_overflow; + } + return (int64_t) val; + } + } else +#endif + if (likely(PyLong_Check(x))) { + if (is_unsigned) { +#if CYTHON_USE_PYLONG_INTERNALS + const digit* digits = ((PyLongObject*)x)->ob_digit; + switch (Py_SIZE(x)) { + case 0: return (int64_t) 0; + case 1: __PYX_VERIFY_RETURN_INT(int64_t, digit, digits[0]) + case 2: + if (8 * sizeof(int64_t) > 1 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(int64_t, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(int64_t) >= 2 * PyLong_SHIFT) { + return (int64_t) (((((int64_t)digits[1]) << PyLong_SHIFT) | (int64_t)digits[0])); + } + } + break; + case 3: + if (8 * sizeof(int64_t) > 2 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(int64_t, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(int64_t) >= 3 * PyLong_SHIFT) { + return (int64_t) (((((((int64_t)digits[2]) << PyLong_SHIFT) | (int64_t)digits[1]) << PyLong_SHIFT) | (int64_t)digits[0])); + } + } + break; + case 4: + if (8 * sizeof(int64_t) > 3 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(int64_t, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(int64_t) >= 4 * PyLong_SHIFT) { + return (int64_t) (((((((((int64_t)digits[3]) << PyLong_SHIFT) | (int64_t)digits[2]) << PyLong_SHIFT) | (int64_t)digits[1]) << PyLong_SHIFT) | (int64_t)digits[0])); + } + } + break; + } +#endif +#if CYTHON_COMPILING_IN_CPYTHON + if (unlikely(Py_SIZE(x) < 0)) { + goto raise_neg_overflow; + } +#else + { + int result = PyObject_RichCompareBool(x, Py_False, Py_LT); + if (unlikely(result < 0)) + return (int64_t) -1; + if (unlikely(result == 1)) + goto raise_neg_overflow; + } +#endif + if (sizeof(int64_t) <= sizeof(unsigned long)) { + __PYX_VERIFY_RETURN_INT_EXC(int64_t, unsigned long, PyLong_AsUnsignedLong(x)) +#ifdef HAVE_LONG_LONG + } else if (sizeof(int64_t) <= sizeof(unsigned PY_LONG_LONG)) { + __PYX_VERIFY_RETURN_INT_EXC(int64_t, unsigned PY_LONG_LONG, PyLong_AsUnsignedLongLong(x)) +#endif + } + } else { +#if CYTHON_USE_PYLONG_INTERNALS + const digit* digits = ((PyLongObject*)x)->ob_digit; + switch (Py_SIZE(x)) { + case 0: return (int64_t) 0; + case -1: __PYX_VERIFY_RETURN_INT(int64_t, sdigit, (sdigit) (-(sdigit)digits[0])) + case 1: __PYX_VERIFY_RETURN_INT(int64_t, digit, +digits[0]) + case -2: + if (8 * sizeof(int64_t) - 1 > 1 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(int64_t, long, -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(int64_t) - 1 > 2 * PyLong_SHIFT) { + return (int64_t) (((int64_t)-1)*(((((int64_t)digits[1]) << PyLong_SHIFT) | (int64_t)digits[0]))); + } + } + break; + case 2: + if (8 * sizeof(int64_t) > 1 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(int64_t, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(int64_t) - 1 > 2 * PyLong_SHIFT) { + return (int64_t) ((((((int64_t)digits[1]) << PyLong_SHIFT) | (int64_t)digits[0]))); + } + } + break; + case -3: + if (8 * sizeof(int64_t) - 1 > 2 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(int64_t, long, -(long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(int64_t) - 1 > 3 * PyLong_SHIFT) { + return (int64_t) (((int64_t)-1)*(((((((int64_t)digits[2]) << PyLong_SHIFT) | (int64_t)digits[1]) << PyLong_SHIFT) | (int64_t)digits[0]))); + } + } + break; + case 3: + if (8 * sizeof(int64_t) > 2 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(int64_t, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(int64_t) - 1 > 3 * PyLong_SHIFT) { + return (int64_t) ((((((((int64_t)digits[2]) << PyLong_SHIFT) | (int64_t)digits[1]) << PyLong_SHIFT) | (int64_t)digits[0]))); + } + } + break; + case -4: + if (8 * sizeof(int64_t) - 1 > 3 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(int64_t, long, -(long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(int64_t) - 1 > 4 * PyLong_SHIFT) { + return (int64_t) (((int64_t)-1)*(((((((((int64_t)digits[3]) << PyLong_SHIFT) | (int64_t)digits[2]) << PyLong_SHIFT) | (int64_t)digits[1]) << PyLong_SHIFT) | (int64_t)digits[0]))); + } + } + break; + case 4: + if (8 * sizeof(int64_t) > 3 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(int64_t, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(int64_t) - 1 > 4 * PyLong_SHIFT) { + return (int64_t) ((((((((((int64_t)digits[3]) << PyLong_SHIFT) | (int64_t)digits[2]) << PyLong_SHIFT) | (int64_t)digits[1]) << PyLong_SHIFT) | (int64_t)digits[0]))); + } + } + break; + } +#endif + if (sizeof(int64_t) <= sizeof(long)) { + __PYX_VERIFY_RETURN_INT_EXC(int64_t, long, PyLong_AsLong(x)) +#ifdef HAVE_LONG_LONG + } else if (sizeof(int64_t) <= sizeof(PY_LONG_LONG)) { + __PYX_VERIFY_RETURN_INT_EXC(int64_t, PY_LONG_LONG, PyLong_AsLongLong(x)) +#endif + } + } + { +#if CYTHON_COMPILING_IN_PYPY && !defined(_PyLong_AsByteArray) + PyErr_SetString(PyExc_RuntimeError, + "_PyLong_AsByteArray() not available in PyPy, cannot convert large numbers"); +#else + int64_t val; + PyObject *v = __Pyx_PyNumber_IntOrLong(x); + #if PY_MAJOR_VERSION < 3 + if (likely(v) && !PyLong_Check(v)) { + PyObject *tmp = v; + v = PyNumber_Long(tmp); + Py_DECREF(tmp); + } + #endif + if (likely(v)) { + int one = 1; int is_little = (int)*(unsigned char *)&one; + unsigned char *bytes = (unsigned char *)&val; + int ret = _PyLong_AsByteArray((PyLongObject *)v, + bytes, sizeof(val), + is_little, !is_unsigned); + Py_DECREF(v); + if (likely(!ret)) + return val; + } +#endif + return (int64_t) -1; + } + } else { + int64_t val; + PyObject *tmp = __Pyx_PyNumber_IntOrLong(x); + if (!tmp) return (int64_t) -1; + val = __Pyx_PyInt_As_int64_t(tmp); + Py_DECREF(tmp); + return val; + } +raise_overflow: + PyErr_SetString(PyExc_OverflowError, + "value too large to convert to int64_t"); + return (int64_t) -1; +raise_neg_overflow: + PyErr_SetString(PyExc_OverflowError, + "can't convert negative value to int64_t"); + return (int64_t) -1; +} + +/* CIntFromPy */ + static CYTHON_INLINE int32_t __Pyx_PyInt_As_int32_t(PyObject *x) { + const int32_t neg_one = (int32_t) -1, const_zero = (int32_t) 0; + const int is_unsigned = neg_one > const_zero; +#if PY_MAJOR_VERSION < 3 + if (likely(PyInt_Check(x))) { + if (sizeof(int32_t) < sizeof(long)) { + __PYX_VERIFY_RETURN_INT(int32_t, long, PyInt_AS_LONG(x)) + } else { + long val = PyInt_AS_LONG(x); + if (is_unsigned && unlikely(val < 0)) { + goto raise_neg_overflow; + } + return (int32_t) val; + } + } else +#endif + if (likely(PyLong_Check(x))) { + if (is_unsigned) { +#if CYTHON_USE_PYLONG_INTERNALS + const digit* digits = ((PyLongObject*)x)->ob_digit; + switch (Py_SIZE(x)) { + case 0: return (int32_t) 0; + case 1: __PYX_VERIFY_RETURN_INT(int32_t, digit, digits[0]) + case 2: + if (8 * sizeof(int32_t) > 1 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(int32_t, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(int32_t) >= 2 * PyLong_SHIFT) { + return (int32_t) (((((int32_t)digits[1]) << PyLong_SHIFT) | (int32_t)digits[0])); + } + } + break; + case 3: + if (8 * sizeof(int32_t) > 2 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(int32_t, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(int32_t) >= 3 * PyLong_SHIFT) { + return (int32_t) (((((((int32_t)digits[2]) << PyLong_SHIFT) | (int32_t)digits[1]) << PyLong_SHIFT) | (int32_t)digits[0])); + } + } + break; + case 4: + if (8 * sizeof(int32_t) > 3 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(int32_t, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(int32_t) >= 4 * PyLong_SHIFT) { + return (int32_t) (((((((((int32_t)digits[3]) << PyLong_SHIFT) | (int32_t)digits[2]) << PyLong_SHIFT) | (int32_t)digits[1]) << PyLong_SHIFT) | (int32_t)digits[0])); + } + } + break; + } +#endif +#if CYTHON_COMPILING_IN_CPYTHON + if (unlikely(Py_SIZE(x) < 0)) { + goto raise_neg_overflow; + } +#else + { + int result = PyObject_RichCompareBool(x, Py_False, Py_LT); + if (unlikely(result < 0)) + return (int32_t) -1; + if (unlikely(result == 1)) + goto raise_neg_overflow; + } +#endif + if (sizeof(int32_t) <= sizeof(unsigned long)) { + __PYX_VERIFY_RETURN_INT_EXC(int32_t, unsigned long, PyLong_AsUnsignedLong(x)) +#ifdef HAVE_LONG_LONG + } else if (sizeof(int32_t) <= sizeof(unsigned PY_LONG_LONG)) { + __PYX_VERIFY_RETURN_INT_EXC(int32_t, unsigned PY_LONG_LONG, PyLong_AsUnsignedLongLong(x)) +#endif + } + } else { +#if CYTHON_USE_PYLONG_INTERNALS + const digit* digits = ((PyLongObject*)x)->ob_digit; + switch (Py_SIZE(x)) { + case 0: return (int32_t) 0; + case -1: __PYX_VERIFY_RETURN_INT(int32_t, sdigit, (sdigit) (-(sdigit)digits[0])) + case 1: __PYX_VERIFY_RETURN_INT(int32_t, digit, +digits[0]) + case -2: + if (8 * sizeof(int32_t) - 1 > 1 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(int32_t, long, -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(int32_t) - 1 > 2 * PyLong_SHIFT) { + return (int32_t) (((int32_t)-1)*(((((int32_t)digits[1]) << PyLong_SHIFT) | (int32_t)digits[0]))); + } + } + break; + case 2: + if (8 * sizeof(int32_t) > 1 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(int32_t, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(int32_t) - 1 > 2 * PyLong_SHIFT) { + return (int32_t) ((((((int32_t)digits[1]) << PyLong_SHIFT) | (int32_t)digits[0]))); + } + } + break; + case -3: + if (8 * sizeof(int32_t) - 1 > 2 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(int32_t, long, -(long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(int32_t) - 1 > 3 * PyLong_SHIFT) { + return (int32_t) (((int32_t)-1)*(((((((int32_t)digits[2]) << PyLong_SHIFT) | (int32_t)digits[1]) << PyLong_SHIFT) | (int32_t)digits[0]))); + } + } + break; + case 3: + if (8 * sizeof(int32_t) > 2 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(int32_t, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(int32_t) - 1 > 3 * PyLong_SHIFT) { + return (int32_t) ((((((((int32_t)digits[2]) << PyLong_SHIFT) | (int32_t)digits[1]) << PyLong_SHIFT) | (int32_t)digits[0]))); + } + } + break; + case -4: + if (8 * sizeof(int32_t) - 1 > 3 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(int32_t, long, -(long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(int32_t) - 1 > 4 * PyLong_SHIFT) { + return (int32_t) (((int32_t)-1)*(((((((((int32_t)digits[3]) << PyLong_SHIFT) | (int32_t)digits[2]) << PyLong_SHIFT) | (int32_t)digits[1]) << PyLong_SHIFT) | (int32_t)digits[0]))); + } + } + break; + case 4: + if (8 * sizeof(int32_t) > 3 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(int32_t, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(int32_t) - 1 > 4 * PyLong_SHIFT) { + return (int32_t) ((((((((((int32_t)digits[3]) << PyLong_SHIFT) | (int32_t)digits[2]) << PyLong_SHIFT) | (int32_t)digits[1]) << PyLong_SHIFT) | (int32_t)digits[0]))); + } + } + break; + } +#endif + if (sizeof(int32_t) <= sizeof(long)) { + __PYX_VERIFY_RETURN_INT_EXC(int32_t, long, PyLong_AsLong(x)) +#ifdef HAVE_LONG_LONG + } else if (sizeof(int32_t) <= sizeof(PY_LONG_LONG)) { + __PYX_VERIFY_RETURN_INT_EXC(int32_t, PY_LONG_LONG, PyLong_AsLongLong(x)) +#endif + } + } + { +#if CYTHON_COMPILING_IN_PYPY && !defined(_PyLong_AsByteArray) + PyErr_SetString(PyExc_RuntimeError, + "_PyLong_AsByteArray() not available in PyPy, cannot convert large numbers"); +#else + int32_t val; + PyObject *v = __Pyx_PyNumber_IntOrLong(x); + #if PY_MAJOR_VERSION < 3 + if (likely(v) && !PyLong_Check(v)) { + PyObject *tmp = v; + v = PyNumber_Long(tmp); + Py_DECREF(tmp); + } + #endif + if (likely(v)) { + int one = 1; int is_little = (int)*(unsigned char *)&one; + unsigned char *bytes = (unsigned char *)&val; + int ret = _PyLong_AsByteArray((PyLongObject *)v, + bytes, sizeof(val), + is_little, !is_unsigned); + Py_DECREF(v); + if (likely(!ret)) + return val; + } +#endif + return (int32_t) -1; + } + } else { + int32_t val; + PyObject *tmp = __Pyx_PyNumber_IntOrLong(x); + if (!tmp) return (int32_t) -1; + val = __Pyx_PyInt_As_int32_t(tmp); + Py_DECREF(tmp); + return val; + } +raise_overflow: + PyErr_SetString(PyExc_OverflowError, + "value too large to convert to int32_t"); + return (int32_t) -1; +raise_neg_overflow: + PyErr_SetString(PyExc_OverflowError, + "can't convert negative value to int32_t"); + return (int32_t) -1; +} + +/* CIntFromPy */ + static CYTHON_INLINE int8_t __Pyx_PyInt_As_int8_t(PyObject *x) { + const int8_t neg_one = (int8_t) -1, const_zero = (int8_t) 0; + const int is_unsigned = neg_one > const_zero; +#if PY_MAJOR_VERSION < 3 + if (likely(PyInt_Check(x))) { + if (sizeof(int8_t) < sizeof(long)) { + __PYX_VERIFY_RETURN_INT(int8_t, long, PyInt_AS_LONG(x)) + } else { + long val = PyInt_AS_LONG(x); + if (is_unsigned && unlikely(val < 0)) { + goto raise_neg_overflow; + } + return (int8_t) val; + } + } else +#endif + if (likely(PyLong_Check(x))) { + if (is_unsigned) { +#if CYTHON_USE_PYLONG_INTERNALS + const digit* digits = ((PyLongObject*)x)->ob_digit; + switch (Py_SIZE(x)) { + case 0: return (int8_t) 0; + case 1: __PYX_VERIFY_RETURN_INT(int8_t, digit, digits[0]) + case 2: + if (8 * sizeof(int8_t) > 1 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(int8_t, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(int8_t) >= 2 * PyLong_SHIFT) { + return (int8_t) (((((int8_t)digits[1]) << PyLong_SHIFT) | (int8_t)digits[0])); + } + } + break; + case 3: + if (8 * sizeof(int8_t) > 2 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(int8_t, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(int8_t) >= 3 * PyLong_SHIFT) { + return (int8_t) (((((((int8_t)digits[2]) << PyLong_SHIFT) | (int8_t)digits[1]) << PyLong_SHIFT) | (int8_t)digits[0])); + } + } + break; + case 4: + if (8 * sizeof(int8_t) > 3 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(int8_t, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(int8_t) >= 4 * PyLong_SHIFT) { + return (int8_t) (((((((((int8_t)digits[3]) << PyLong_SHIFT) | (int8_t)digits[2]) << PyLong_SHIFT) | (int8_t)digits[1]) << PyLong_SHIFT) | (int8_t)digits[0])); + } + } + break; + } +#endif +#if CYTHON_COMPILING_IN_CPYTHON + if (unlikely(Py_SIZE(x) < 0)) { + goto raise_neg_overflow; + } +#else + { + int result = PyObject_RichCompareBool(x, Py_False, Py_LT); + if (unlikely(result < 0)) + return (int8_t) -1; + if (unlikely(result == 1)) + goto raise_neg_overflow; + } +#endif + if (sizeof(int8_t) <= sizeof(unsigned long)) { + __PYX_VERIFY_RETURN_INT_EXC(int8_t, unsigned long, PyLong_AsUnsignedLong(x)) +#ifdef HAVE_LONG_LONG + } else if (sizeof(int8_t) <= sizeof(unsigned PY_LONG_LONG)) { + __PYX_VERIFY_RETURN_INT_EXC(int8_t, unsigned PY_LONG_LONG, PyLong_AsUnsignedLongLong(x)) +#endif + } + } else { +#if CYTHON_USE_PYLONG_INTERNALS + const digit* digits = ((PyLongObject*)x)->ob_digit; + switch (Py_SIZE(x)) { + case 0: return (int8_t) 0; + case -1: __PYX_VERIFY_RETURN_INT(int8_t, sdigit, (sdigit) (-(sdigit)digits[0])) + case 1: __PYX_VERIFY_RETURN_INT(int8_t, digit, +digits[0]) + case -2: + if (8 * sizeof(int8_t) - 1 > 1 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(int8_t, long, -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(int8_t) - 1 > 2 * PyLong_SHIFT) { + return (int8_t) (((int8_t)-1)*(((((int8_t)digits[1]) << PyLong_SHIFT) | (int8_t)digits[0]))); + } + } + break; + case 2: + if (8 * sizeof(int8_t) > 1 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(int8_t, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(int8_t) - 1 > 2 * PyLong_SHIFT) { + return (int8_t) ((((((int8_t)digits[1]) << PyLong_SHIFT) | (int8_t)digits[0]))); + } + } + break; + case -3: + if (8 * sizeof(int8_t) - 1 > 2 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(int8_t, long, -(long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(int8_t) - 1 > 3 * PyLong_SHIFT) { + return (int8_t) (((int8_t)-1)*(((((((int8_t)digits[2]) << PyLong_SHIFT) | (int8_t)digits[1]) << PyLong_SHIFT) | (int8_t)digits[0]))); + } + } + break; + case 3: + if (8 * sizeof(int8_t) > 2 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(int8_t, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(int8_t) - 1 > 3 * PyLong_SHIFT) { + return (int8_t) ((((((((int8_t)digits[2]) << PyLong_SHIFT) | (int8_t)digits[1]) << PyLong_SHIFT) | (int8_t)digits[0]))); + } + } + break; + case -4: + if (8 * sizeof(int8_t) - 1 > 3 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(int8_t, long, -(long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(int8_t) - 1 > 4 * PyLong_SHIFT) { + return (int8_t) (((int8_t)-1)*(((((((((int8_t)digits[3]) << PyLong_SHIFT) | (int8_t)digits[2]) << PyLong_SHIFT) | (int8_t)digits[1]) << PyLong_SHIFT) | (int8_t)digits[0]))); + } + } + break; + case 4: + if (8 * sizeof(int8_t) > 3 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(int8_t, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(int8_t) - 1 > 4 * PyLong_SHIFT) { + return (int8_t) ((((((((((int8_t)digits[3]) << PyLong_SHIFT) | (int8_t)digits[2]) << PyLong_SHIFT) | (int8_t)digits[1]) << PyLong_SHIFT) | (int8_t)digits[0]))); + } + } + break; + } +#endif + if (sizeof(int8_t) <= sizeof(long)) { + __PYX_VERIFY_RETURN_INT_EXC(int8_t, long, PyLong_AsLong(x)) +#ifdef HAVE_LONG_LONG + } else if (sizeof(int8_t) <= sizeof(PY_LONG_LONG)) { + __PYX_VERIFY_RETURN_INT_EXC(int8_t, PY_LONG_LONG, PyLong_AsLongLong(x)) +#endif + } + } + { +#if CYTHON_COMPILING_IN_PYPY && !defined(_PyLong_AsByteArray) + PyErr_SetString(PyExc_RuntimeError, + "_PyLong_AsByteArray() not available in PyPy, cannot convert large numbers"); +#else + int8_t val; + PyObject *v = __Pyx_PyNumber_IntOrLong(x); + #if PY_MAJOR_VERSION < 3 + if (likely(v) && !PyLong_Check(v)) { + PyObject *tmp = v; + v = PyNumber_Long(tmp); + Py_DECREF(tmp); + } + #endif + if (likely(v)) { + int one = 1; int is_little = (int)*(unsigned char *)&one; + unsigned char *bytes = (unsigned char *)&val; + int ret = _PyLong_AsByteArray((PyLongObject *)v, + bytes, sizeof(val), + is_little, !is_unsigned); + Py_DECREF(v); + if (likely(!ret)) + return val; + } +#endif + return (int8_t) -1; + } + } else { + int8_t val; + PyObject *tmp = __Pyx_PyNumber_IntOrLong(x); + if (!tmp) return (int8_t) -1; + val = __Pyx_PyInt_As_int8_t(tmp); + Py_DECREF(tmp); + return val; + } +raise_overflow: + PyErr_SetString(PyExc_OverflowError, + "value too large to convert to int8_t"); + return (int8_t) -1; +raise_neg_overflow: + PyErr_SetString(PyExc_OverflowError, + "can't convert negative value to int8_t"); + return (int8_t) -1; +} + +/* CIntFromPy */ + static CYTHON_INLINE uint8_t __Pyx_PyInt_As_uint8_t(PyObject *x) { + const uint8_t neg_one = (uint8_t) -1, const_zero = (uint8_t) 0; + const int is_unsigned = neg_one > const_zero; +#if PY_MAJOR_VERSION < 3 + if (likely(PyInt_Check(x))) { + if (sizeof(uint8_t) < sizeof(long)) { + __PYX_VERIFY_RETURN_INT(uint8_t, long, PyInt_AS_LONG(x)) + } else { + long val = PyInt_AS_LONG(x); + if (is_unsigned && unlikely(val < 0)) { + goto raise_neg_overflow; + } + return (uint8_t) val; + } + } else +#endif + if (likely(PyLong_Check(x))) { + if (is_unsigned) { +#if CYTHON_USE_PYLONG_INTERNALS + const digit* digits = ((PyLongObject*)x)->ob_digit; + switch (Py_SIZE(x)) { + case 0: return (uint8_t) 0; + case 1: __PYX_VERIFY_RETURN_INT(uint8_t, digit, digits[0]) + case 2: + if (8 * sizeof(uint8_t) > 1 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(uint8_t, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(uint8_t) >= 2 * PyLong_SHIFT) { + return (uint8_t) (((((uint8_t)digits[1]) << PyLong_SHIFT) | (uint8_t)digits[0])); + } + } + break; + case 3: + if (8 * sizeof(uint8_t) > 2 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(uint8_t, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(uint8_t) >= 3 * PyLong_SHIFT) { + return (uint8_t) (((((((uint8_t)digits[2]) << PyLong_SHIFT) | (uint8_t)digits[1]) << PyLong_SHIFT) | (uint8_t)digits[0])); + } + } + break; + case 4: + if (8 * sizeof(uint8_t) > 3 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(uint8_t, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(uint8_t) >= 4 * PyLong_SHIFT) { + return (uint8_t) (((((((((uint8_t)digits[3]) << PyLong_SHIFT) | (uint8_t)digits[2]) << PyLong_SHIFT) | (uint8_t)digits[1]) << PyLong_SHIFT) | (uint8_t)digits[0])); + } + } + break; + } +#endif +#if CYTHON_COMPILING_IN_CPYTHON + if (unlikely(Py_SIZE(x) < 0)) { + goto raise_neg_overflow; + } +#else + { + int result = PyObject_RichCompareBool(x, Py_False, Py_LT); + if (unlikely(result < 0)) + return (uint8_t) -1; + if (unlikely(result == 1)) + goto raise_neg_overflow; + } +#endif + if (sizeof(uint8_t) <= sizeof(unsigned long)) { + __PYX_VERIFY_RETURN_INT_EXC(uint8_t, unsigned long, PyLong_AsUnsignedLong(x)) +#ifdef HAVE_LONG_LONG + } else if (sizeof(uint8_t) <= sizeof(unsigned PY_LONG_LONG)) { + __PYX_VERIFY_RETURN_INT_EXC(uint8_t, unsigned PY_LONG_LONG, PyLong_AsUnsignedLongLong(x)) +#endif + } + } else { +#if CYTHON_USE_PYLONG_INTERNALS + const digit* digits = ((PyLongObject*)x)->ob_digit; + switch (Py_SIZE(x)) { + case 0: return (uint8_t) 0; + case -1: __PYX_VERIFY_RETURN_INT(uint8_t, sdigit, (sdigit) (-(sdigit)digits[0])) + case 1: __PYX_VERIFY_RETURN_INT(uint8_t, digit, +digits[0]) + case -2: + if (8 * sizeof(uint8_t) - 1 > 1 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(uint8_t, long, -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(uint8_t) - 1 > 2 * PyLong_SHIFT) { + return (uint8_t) (((uint8_t)-1)*(((((uint8_t)digits[1]) << PyLong_SHIFT) | (uint8_t)digits[0]))); + } + } + break; + case 2: + if (8 * sizeof(uint8_t) > 1 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(uint8_t, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(uint8_t) - 1 > 2 * PyLong_SHIFT) { + return (uint8_t) ((((((uint8_t)digits[1]) << PyLong_SHIFT) | (uint8_t)digits[0]))); + } + } + break; + case -3: + if (8 * sizeof(uint8_t) - 1 > 2 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(uint8_t, long, -(long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(uint8_t) - 1 > 3 * PyLong_SHIFT) { + return (uint8_t) (((uint8_t)-1)*(((((((uint8_t)digits[2]) << PyLong_SHIFT) | (uint8_t)digits[1]) << PyLong_SHIFT) | (uint8_t)digits[0]))); + } + } + break; + case 3: + if (8 * sizeof(uint8_t) > 2 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(uint8_t, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(uint8_t) - 1 > 3 * PyLong_SHIFT) { + return (uint8_t) ((((((((uint8_t)digits[2]) << PyLong_SHIFT) | (uint8_t)digits[1]) << PyLong_SHIFT) | (uint8_t)digits[0]))); + } + } + break; + case -4: + if (8 * sizeof(uint8_t) - 1 > 3 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(uint8_t, long, -(long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(uint8_t) - 1 > 4 * PyLong_SHIFT) { + return (uint8_t) (((uint8_t)-1)*(((((((((uint8_t)digits[3]) << PyLong_SHIFT) | (uint8_t)digits[2]) << PyLong_SHIFT) | (uint8_t)digits[1]) << PyLong_SHIFT) | (uint8_t)digits[0]))); + } + } + break; + case 4: + if (8 * sizeof(uint8_t) > 3 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(uint8_t, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(uint8_t) - 1 > 4 * PyLong_SHIFT) { + return (uint8_t) ((((((((((uint8_t)digits[3]) << PyLong_SHIFT) | (uint8_t)digits[2]) << PyLong_SHIFT) | (uint8_t)digits[1]) << PyLong_SHIFT) | (uint8_t)digits[0]))); + } + } + break; + } +#endif + if (sizeof(uint8_t) <= sizeof(long)) { + __PYX_VERIFY_RETURN_INT_EXC(uint8_t, long, PyLong_AsLong(x)) +#ifdef HAVE_LONG_LONG + } else if (sizeof(uint8_t) <= sizeof(PY_LONG_LONG)) { + __PYX_VERIFY_RETURN_INT_EXC(uint8_t, PY_LONG_LONG, PyLong_AsLongLong(x)) +#endif + } + } + { +#if CYTHON_COMPILING_IN_PYPY && !defined(_PyLong_AsByteArray) + PyErr_SetString(PyExc_RuntimeError, + "_PyLong_AsByteArray() not available in PyPy, cannot convert large numbers"); +#else + uint8_t val; + PyObject *v = __Pyx_PyNumber_IntOrLong(x); + #if PY_MAJOR_VERSION < 3 + if (likely(v) && !PyLong_Check(v)) { + PyObject *tmp = v; + v = PyNumber_Long(tmp); + Py_DECREF(tmp); + } + #endif + if (likely(v)) { + int one = 1; int is_little = (int)*(unsigned char *)&one; + unsigned char *bytes = (unsigned char *)&val; + int ret = _PyLong_AsByteArray((PyLongObject *)v, + bytes, sizeof(val), + is_little, !is_unsigned); + Py_DECREF(v); + if (likely(!ret)) + return val; + } +#endif + return (uint8_t) -1; + } + } else { + uint8_t val; + PyObject *tmp = __Pyx_PyNumber_IntOrLong(x); + if (!tmp) return (uint8_t) -1; + val = __Pyx_PyInt_As_uint8_t(tmp); + Py_DECREF(tmp); + return val; + } +raise_overflow: + PyErr_SetString(PyExc_OverflowError, + "value too large to convert to uint8_t"); + return (uint8_t) -1; +raise_neg_overflow: + PyErr_SetString(PyExc_OverflowError, + "can't convert negative value to uint8_t"); + return (uint8_t) -1; +} + +/* CIntFromPy */ + static CYTHON_INLINE char __Pyx_PyInt_As_char(PyObject *x) { + const char neg_one = (char) -1, const_zero = (char) 0; + const int is_unsigned = neg_one > const_zero; +#if PY_MAJOR_VERSION < 3 + if (likely(PyInt_Check(x))) { + if (sizeof(char) < sizeof(long)) { + __PYX_VERIFY_RETURN_INT(char, long, PyInt_AS_LONG(x)) + } else { + long val = PyInt_AS_LONG(x); + if (is_unsigned && unlikely(val < 0)) { + goto raise_neg_overflow; + } + return (char) val; + } + } else +#endif + if (likely(PyLong_Check(x))) { + if (is_unsigned) { +#if CYTHON_USE_PYLONG_INTERNALS + const digit* digits = ((PyLongObject*)x)->ob_digit; + switch (Py_SIZE(x)) { + case 0: return (char) 0; + case 1: __PYX_VERIFY_RETURN_INT(char, digit, digits[0]) + case 2: + if (8 * sizeof(char) > 1 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(char, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(char) >= 2 * PyLong_SHIFT) { + return (char) (((((char)digits[1]) << PyLong_SHIFT) | (char)digits[0])); + } + } + break; + case 3: + if (8 * sizeof(char) > 2 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(char, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(char) >= 3 * PyLong_SHIFT) { + return (char) (((((((char)digits[2]) << PyLong_SHIFT) | (char)digits[1]) << PyLong_SHIFT) | (char)digits[0])); + } + } + break; + case 4: + if (8 * sizeof(char) > 3 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(char, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(char) >= 4 * PyLong_SHIFT) { + return (char) (((((((((char)digits[3]) << PyLong_SHIFT) | (char)digits[2]) << PyLong_SHIFT) | (char)digits[1]) << PyLong_SHIFT) | (char)digits[0])); + } + } + break; + } +#endif +#if CYTHON_COMPILING_IN_CPYTHON + if (unlikely(Py_SIZE(x) < 0)) { + goto raise_neg_overflow; + } +#else + { + int result = PyObject_RichCompareBool(x, Py_False, Py_LT); + if (unlikely(result < 0)) + return (char) -1; + if (unlikely(result == 1)) + goto raise_neg_overflow; + } +#endif + if (sizeof(char) <= sizeof(unsigned long)) { + __PYX_VERIFY_RETURN_INT_EXC(char, unsigned long, PyLong_AsUnsignedLong(x)) +#ifdef HAVE_LONG_LONG + } else if (sizeof(char) <= sizeof(unsigned PY_LONG_LONG)) { + __PYX_VERIFY_RETURN_INT_EXC(char, unsigned PY_LONG_LONG, PyLong_AsUnsignedLongLong(x)) +#endif + } + } else { +#if CYTHON_USE_PYLONG_INTERNALS + const digit* digits = ((PyLongObject*)x)->ob_digit; + switch (Py_SIZE(x)) { + case 0: return (char) 0; + case -1: __PYX_VERIFY_RETURN_INT(char, sdigit, (sdigit) (-(sdigit)digits[0])) + case 1: __PYX_VERIFY_RETURN_INT(char, digit, +digits[0]) + case -2: + if (8 * sizeof(char) - 1 > 1 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(char, long, -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(char) - 1 > 2 * PyLong_SHIFT) { + return (char) (((char)-1)*(((((char)digits[1]) << PyLong_SHIFT) | (char)digits[0]))); + } + } + break; + case 2: + if (8 * sizeof(char) > 1 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(char, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(char) - 1 > 2 * PyLong_SHIFT) { + return (char) ((((((char)digits[1]) << PyLong_SHIFT) | (char)digits[0]))); + } + } + break; + case -3: + if (8 * sizeof(char) - 1 > 2 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(char, long, -(long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(char) - 1 > 3 * PyLong_SHIFT) { + return (char) (((char)-1)*(((((((char)digits[2]) << PyLong_SHIFT) | (char)digits[1]) << PyLong_SHIFT) | (char)digits[0]))); + } + } + break; + case 3: + if (8 * sizeof(char) > 2 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(char, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(char) - 1 > 3 * PyLong_SHIFT) { + return (char) ((((((((char)digits[2]) << PyLong_SHIFT) | (char)digits[1]) << PyLong_SHIFT) | (char)digits[0]))); + } + } + break; + case -4: + if (8 * sizeof(char) - 1 > 3 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(char, long, -(long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(char) - 1 > 4 * PyLong_SHIFT) { + return (char) (((char)-1)*(((((((((char)digits[3]) << PyLong_SHIFT) | (char)digits[2]) << PyLong_SHIFT) | (char)digits[1]) << PyLong_SHIFT) | (char)digits[0]))); + } + } + break; + case 4: + if (8 * sizeof(char) > 3 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(char, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(char) - 1 > 4 * PyLong_SHIFT) { + return (char) ((((((((((char)digits[3]) << PyLong_SHIFT) | (char)digits[2]) << PyLong_SHIFT) | (char)digits[1]) << PyLong_SHIFT) | (char)digits[0]))); + } + } + break; + } +#endif + if (sizeof(char) <= sizeof(long)) { + __PYX_VERIFY_RETURN_INT_EXC(char, long, PyLong_AsLong(x)) +#ifdef HAVE_LONG_LONG + } else if (sizeof(char) <= sizeof(PY_LONG_LONG)) { + __PYX_VERIFY_RETURN_INT_EXC(char, PY_LONG_LONG, PyLong_AsLongLong(x)) +#endif + } + } + { +#if CYTHON_COMPILING_IN_PYPY && !defined(_PyLong_AsByteArray) + PyErr_SetString(PyExc_RuntimeError, + "_PyLong_AsByteArray() not available in PyPy, cannot convert large numbers"); +#else + char val; + PyObject *v = __Pyx_PyNumber_IntOrLong(x); + #if PY_MAJOR_VERSION < 3 + if (likely(v) && !PyLong_Check(v)) { + PyObject *tmp = v; + v = PyNumber_Long(tmp); + Py_DECREF(tmp); + } + #endif + if (likely(v)) { + int one = 1; int is_little = (int)*(unsigned char *)&one; + unsigned char *bytes = (unsigned char *)&val; + int ret = _PyLong_AsByteArray((PyLongObject *)v, + bytes, sizeof(val), + is_little, !is_unsigned); + Py_DECREF(v); + if (likely(!ret)) + return val; + } +#endif + return (char) -1; + } + } else { + char val; + PyObject *tmp = __Pyx_PyNumber_IntOrLong(x); + if (!tmp) return (char) -1; + val = __Pyx_PyInt_As_char(tmp); + Py_DECREF(tmp); + return val; + } +raise_overflow: + PyErr_SetString(PyExc_OverflowError, + "value too large to convert to char"); + return (char) -1; +raise_neg_overflow: + PyErr_SetString(PyExc_OverflowError, + "can't convert negative value to char"); + return (char) -1; +} + +/* CIntFromPy */ + static CYTHON_INLINE int16_t __Pyx_PyInt_As_int16_t(PyObject *x) { + const int16_t neg_one = (int16_t) -1, const_zero = (int16_t) 0; + const int is_unsigned = neg_one > const_zero; +#if PY_MAJOR_VERSION < 3 + if (likely(PyInt_Check(x))) { + if (sizeof(int16_t) < sizeof(long)) { + __PYX_VERIFY_RETURN_INT(int16_t, long, PyInt_AS_LONG(x)) + } else { + long val = PyInt_AS_LONG(x); + if (is_unsigned && unlikely(val < 0)) { + goto raise_neg_overflow; + } + return (int16_t) val; + } + } else +#endif + if (likely(PyLong_Check(x))) { + if (is_unsigned) { +#if CYTHON_USE_PYLONG_INTERNALS + const digit* digits = ((PyLongObject*)x)->ob_digit; + switch (Py_SIZE(x)) { + case 0: return (int16_t) 0; + case 1: __PYX_VERIFY_RETURN_INT(int16_t, digit, digits[0]) + case 2: + if (8 * sizeof(int16_t) > 1 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(int16_t, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(int16_t) >= 2 * PyLong_SHIFT) { + return (int16_t) (((((int16_t)digits[1]) << PyLong_SHIFT) | (int16_t)digits[0])); + } + } + break; + case 3: + if (8 * sizeof(int16_t) > 2 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(int16_t, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(int16_t) >= 3 * PyLong_SHIFT) { + return (int16_t) (((((((int16_t)digits[2]) << PyLong_SHIFT) | (int16_t)digits[1]) << PyLong_SHIFT) | (int16_t)digits[0])); + } + } + break; + case 4: + if (8 * sizeof(int16_t) > 3 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(int16_t, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(int16_t) >= 4 * PyLong_SHIFT) { + return (int16_t) (((((((((int16_t)digits[3]) << PyLong_SHIFT) | (int16_t)digits[2]) << PyLong_SHIFT) | (int16_t)digits[1]) << PyLong_SHIFT) | (int16_t)digits[0])); + } + } + break; + } +#endif +#if CYTHON_COMPILING_IN_CPYTHON + if (unlikely(Py_SIZE(x) < 0)) { + goto raise_neg_overflow; + } +#else + { + int result = PyObject_RichCompareBool(x, Py_False, Py_LT); + if (unlikely(result < 0)) + return (int16_t) -1; + if (unlikely(result == 1)) + goto raise_neg_overflow; + } +#endif + if (sizeof(int16_t) <= sizeof(unsigned long)) { + __PYX_VERIFY_RETURN_INT_EXC(int16_t, unsigned long, PyLong_AsUnsignedLong(x)) +#ifdef HAVE_LONG_LONG + } else if (sizeof(int16_t) <= sizeof(unsigned PY_LONG_LONG)) { + __PYX_VERIFY_RETURN_INT_EXC(int16_t, unsigned PY_LONG_LONG, PyLong_AsUnsignedLongLong(x)) +#endif + } + } else { +#if CYTHON_USE_PYLONG_INTERNALS + const digit* digits = ((PyLongObject*)x)->ob_digit; + switch (Py_SIZE(x)) { + case 0: return (int16_t) 0; + case -1: __PYX_VERIFY_RETURN_INT(int16_t, sdigit, (sdigit) (-(sdigit)digits[0])) + case 1: __PYX_VERIFY_RETURN_INT(int16_t, digit, +digits[0]) + case -2: + if (8 * sizeof(int16_t) - 1 > 1 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(int16_t, long, -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(int16_t) - 1 > 2 * PyLong_SHIFT) { + return (int16_t) (((int16_t)-1)*(((((int16_t)digits[1]) << PyLong_SHIFT) | (int16_t)digits[0]))); + } + } + break; + case 2: + if (8 * sizeof(int16_t) > 1 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(int16_t, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(int16_t) - 1 > 2 * PyLong_SHIFT) { + return (int16_t) ((((((int16_t)digits[1]) << PyLong_SHIFT) | (int16_t)digits[0]))); + } + } + break; + case -3: + if (8 * sizeof(int16_t) - 1 > 2 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(int16_t, long, -(long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(int16_t) - 1 > 3 * PyLong_SHIFT) { + return (int16_t) (((int16_t)-1)*(((((((int16_t)digits[2]) << PyLong_SHIFT) | (int16_t)digits[1]) << PyLong_SHIFT) | (int16_t)digits[0]))); + } + } + break; + case 3: + if (8 * sizeof(int16_t) > 2 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(int16_t, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(int16_t) - 1 > 3 * PyLong_SHIFT) { + return (int16_t) ((((((((int16_t)digits[2]) << PyLong_SHIFT) | (int16_t)digits[1]) << PyLong_SHIFT) | (int16_t)digits[0]))); + } + } + break; + case -4: + if (8 * sizeof(int16_t) - 1 > 3 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(int16_t, long, -(long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(int16_t) - 1 > 4 * PyLong_SHIFT) { + return (int16_t) (((int16_t)-1)*(((((((((int16_t)digits[3]) << PyLong_SHIFT) | (int16_t)digits[2]) << PyLong_SHIFT) | (int16_t)digits[1]) << PyLong_SHIFT) | (int16_t)digits[0]))); + } + } + break; + case 4: + if (8 * sizeof(int16_t) > 3 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(int16_t, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(int16_t) - 1 > 4 * PyLong_SHIFT) { + return (int16_t) ((((((((((int16_t)digits[3]) << PyLong_SHIFT) | (int16_t)digits[2]) << PyLong_SHIFT) | (int16_t)digits[1]) << PyLong_SHIFT) | (int16_t)digits[0]))); + } + } + break; + } +#endif + if (sizeof(int16_t) <= sizeof(long)) { + __PYX_VERIFY_RETURN_INT_EXC(int16_t, long, PyLong_AsLong(x)) +#ifdef HAVE_LONG_LONG + } else if (sizeof(int16_t) <= sizeof(PY_LONG_LONG)) { + __PYX_VERIFY_RETURN_INT_EXC(int16_t, PY_LONG_LONG, PyLong_AsLongLong(x)) +#endif + } + } + { +#if CYTHON_COMPILING_IN_PYPY && !defined(_PyLong_AsByteArray) + PyErr_SetString(PyExc_RuntimeError, + "_PyLong_AsByteArray() not available in PyPy, cannot convert large numbers"); +#else + int16_t val; + PyObject *v = __Pyx_PyNumber_IntOrLong(x); + #if PY_MAJOR_VERSION < 3 + if (likely(v) && !PyLong_Check(v)) { + PyObject *tmp = v; + v = PyNumber_Long(tmp); + Py_DECREF(tmp); + } + #endif + if (likely(v)) { + int one = 1; int is_little = (int)*(unsigned char *)&one; + unsigned char *bytes = (unsigned char *)&val; + int ret = _PyLong_AsByteArray((PyLongObject *)v, + bytes, sizeof(val), + is_little, !is_unsigned); + Py_DECREF(v); + if (likely(!ret)) + return val; + } +#endif + return (int16_t) -1; + } + } else { + int16_t val; + PyObject *tmp = __Pyx_PyNumber_IntOrLong(x); + if (!tmp) return (int16_t) -1; + val = __Pyx_PyInt_As_int16_t(tmp); + Py_DECREF(tmp); + return val; + } +raise_overflow: + PyErr_SetString(PyExc_OverflowError, + "value too large to convert to int16_t"); + return (int16_t) -1; +raise_neg_overflow: + PyErr_SetString(PyExc_OverflowError, + "can't convert negative value to int16_t"); + return (int16_t) -1; +} + +/* ObjectAsUCS4 */ + static Py_UCS4 __Pyx__PyObject_AsPy_UCS4(PyObject* x) { + long ival; + ival = __Pyx_PyInt_As_long(x); + if (unlikely(ival < 0)) { + if (!PyErr_Occurred()) + PyErr_SetString(PyExc_OverflowError, + "cannot convert negative value to Py_UCS4"); + return (Py_UCS4)-1; + } else if (unlikely(ival > 1114111)) { + PyErr_SetString(PyExc_OverflowError, + "value too large to convert to Py_UCS4"); + return (Py_UCS4)-1; + } + return (Py_UCS4)ival; +} + +/* CIntFromPy */ + static CYTHON_INLINE long __Pyx_PyInt_As_long(PyObject *x) { + const long neg_one = (long) -1, const_zero = (long) 0; + const int is_unsigned = neg_one > const_zero; +#if PY_MAJOR_VERSION < 3 + if (likely(PyInt_Check(x))) { + if (sizeof(long) < sizeof(long)) { + __PYX_VERIFY_RETURN_INT(long, long, PyInt_AS_LONG(x)) + } else { + long val = PyInt_AS_LONG(x); + if (is_unsigned && unlikely(val < 0)) { + goto raise_neg_overflow; + } + return (long) val; + } + } else +#endif + if (likely(PyLong_Check(x))) { + if (is_unsigned) { +#if CYTHON_USE_PYLONG_INTERNALS + const digit* digits = ((PyLongObject*)x)->ob_digit; + switch (Py_SIZE(x)) { + case 0: return (long) 0; + case 1: __PYX_VERIFY_RETURN_INT(long, digit, digits[0]) + case 2: + if (8 * sizeof(long) > 1 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(long) >= 2 * PyLong_SHIFT) { + return (long) (((((long)digits[1]) << PyLong_SHIFT) | (long)digits[0])); + } + } + break; + case 3: + if (8 * sizeof(long) > 2 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(long) >= 3 * PyLong_SHIFT) { + return (long) (((((((long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0])); + } + } + break; + case 4: + if (8 * sizeof(long) > 3 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(long) >= 4 * PyLong_SHIFT) { + return (long) (((((((((long)digits[3]) << PyLong_SHIFT) | (long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0])); + } + } + break; + } +#endif +#if CYTHON_COMPILING_IN_CPYTHON + if (unlikely(Py_SIZE(x) < 0)) { + goto raise_neg_overflow; + } +#else + { + int result = PyObject_RichCompareBool(x, Py_False, Py_LT); + if (unlikely(result < 0)) + return (long) -1; + if (unlikely(result == 1)) + goto raise_neg_overflow; + } +#endif + if (sizeof(long) <= sizeof(unsigned long)) { + __PYX_VERIFY_RETURN_INT_EXC(long, unsigned long, PyLong_AsUnsignedLong(x)) +#ifdef HAVE_LONG_LONG + } else if (sizeof(long) <= sizeof(unsigned PY_LONG_LONG)) { + __PYX_VERIFY_RETURN_INT_EXC(long, unsigned PY_LONG_LONG, PyLong_AsUnsignedLongLong(x)) +#endif + } + } else { +#if CYTHON_USE_PYLONG_INTERNALS + const digit* digits = ((PyLongObject*)x)->ob_digit; + switch (Py_SIZE(x)) { + case 0: return (long) 0; + case -1: __PYX_VERIFY_RETURN_INT(long, sdigit, (sdigit) (-(sdigit)digits[0])) + case 1: __PYX_VERIFY_RETURN_INT(long, digit, +digits[0]) + case -2: + if (8 * sizeof(long) - 1 > 1 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(long, long, -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(long) - 1 > 2 * PyLong_SHIFT) { + return (long) (((long)-1)*(((((long)digits[1]) << PyLong_SHIFT) | (long)digits[0]))); + } + } + break; + case 2: + if (8 * sizeof(long) > 1 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(long) - 1 > 2 * PyLong_SHIFT) { + return (long) ((((((long)digits[1]) << PyLong_SHIFT) | (long)digits[0]))); + } + } + break; + case -3: + if (8 * sizeof(long) - 1 > 2 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(long, long, -(long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(long) - 1 > 3 * PyLong_SHIFT) { + return (long) (((long)-1)*(((((((long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0]))); + } + } + break; + case 3: + if (8 * sizeof(long) > 2 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(long) - 1 > 3 * PyLong_SHIFT) { + return (long) ((((((((long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0]))); + } + } + break; + case -4: + if (8 * sizeof(long) - 1 > 3 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(long, long, -(long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(long) - 1 > 4 * PyLong_SHIFT) { + return (long) (((long)-1)*(((((((((long)digits[3]) << PyLong_SHIFT) | (long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0]))); + } + } + break; + case 4: + if (8 * sizeof(long) > 3 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(long) - 1 > 4 * PyLong_SHIFT) { + return (long) ((((((((((long)digits[3]) << PyLong_SHIFT) | (long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0]))); + } + } + break; + } +#endif + if (sizeof(long) <= sizeof(long)) { + __PYX_VERIFY_RETURN_INT_EXC(long, long, PyLong_AsLong(x)) +#ifdef HAVE_LONG_LONG + } else if (sizeof(long) <= sizeof(PY_LONG_LONG)) { + __PYX_VERIFY_RETURN_INT_EXC(long, PY_LONG_LONG, PyLong_AsLongLong(x)) +#endif + } + } + { +#if CYTHON_COMPILING_IN_PYPY && !defined(_PyLong_AsByteArray) + PyErr_SetString(PyExc_RuntimeError, + "_PyLong_AsByteArray() not available in PyPy, cannot convert large numbers"); +#else + long val; + PyObject *v = __Pyx_PyNumber_IntOrLong(x); + #if PY_MAJOR_VERSION < 3 + if (likely(v) && !PyLong_Check(v)) { + PyObject *tmp = v; + v = PyNumber_Long(tmp); + Py_DECREF(tmp); + } + #endif + if (likely(v)) { + int one = 1; int is_little = (int)*(unsigned char *)&one; + unsigned char *bytes = (unsigned char *)&val; + int ret = _PyLong_AsByteArray((PyLongObject *)v, + bytes, sizeof(val), + is_little, !is_unsigned); + Py_DECREF(v); + if (likely(!ret)) + return val; + } +#endif + return (long) -1; + } + } else { + long val; + PyObject *tmp = __Pyx_PyNumber_IntOrLong(x); + if (!tmp) return (long) -1; + val = __Pyx_PyInt_As_long(tmp); + Py_DECREF(tmp); + return val; + } +raise_overflow: + PyErr_SetString(PyExc_OverflowError, + "value too large to convert to long"); + return (long) -1; +raise_neg_overflow: + PyErr_SetString(PyExc_OverflowError, + "can't convert negative value to long"); + return (long) -1; +} + +/* Generator */ + static PyMethodDef __pyx_Generator_methods[] = { + {"send", (PyCFunction) __Pyx_Coroutine_Send, METH_O, + (char*) PyDoc_STR("send(arg) -> send 'arg' into generator,\nreturn next yielded value or raise StopIteration.")}, + {"throw", (PyCFunction) __Pyx_Coroutine_Throw, METH_VARARGS, + (char*) PyDoc_STR("throw(typ[,val[,tb]]) -> raise exception in generator,\nreturn next yielded value or raise StopIteration.")}, + {"close", (PyCFunction) __Pyx_Coroutine_Close, METH_NOARGS, + (char*) PyDoc_STR("close() -> raise GeneratorExit inside generator.")}, + {0, 0, 0, 0} +}; +static PyMemberDef __pyx_Generator_memberlist[] = { + {(char *) "gi_running", T_BOOL, offsetof(__pyx_CoroutineObject, is_running), READONLY, NULL}, + {(char*) "gi_yieldfrom", T_OBJECT, offsetof(__pyx_CoroutineObject, yieldfrom), READONLY, + (char*) PyDoc_STR("object being iterated by 'yield from', or None")}, + {0, 0, 0, 0, 0} +}; +static PyGetSetDef __pyx_Generator_getsets[] = { + {(char *) "__name__", (getter)__Pyx_Coroutine_get_name, (setter)__Pyx_Coroutine_set_name, + (char*) PyDoc_STR("name of the generator"), 0}, + {(char *) "__qualname__", (getter)__Pyx_Coroutine_get_qualname, (setter)__Pyx_Coroutine_set_qualname, + (char*) PyDoc_STR("qualified name of the generator"), 0}, + {0, 0, 0, 0, 0} +}; +static PyTypeObject __pyx_GeneratorType_type = { + PyVarObject_HEAD_INIT(0, 0) + "generator", + sizeof(__pyx_CoroutineObject), + 0, + (destructor) __Pyx_Coroutine_dealloc, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC | Py_TPFLAGS_HAVE_FINALIZE, + 0, + (traverseproc) __Pyx_Coroutine_traverse, + 0, + 0, + offsetof(__pyx_CoroutineObject, gi_weakreflist), + 0, + (iternextfunc) __Pyx_Generator_Next, + __pyx_Generator_methods, + __pyx_Generator_memberlist, + __pyx_Generator_getsets, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, +#if PY_VERSION_HEX >= 0x030400a1 + 0, +#else + __Pyx_Coroutine_del, +#endif + 0, +#if PY_VERSION_HEX >= 0x030400a1 + __Pyx_Coroutine_del, +#endif +}; +static int __pyx_Generator_init(void) { + __pyx_GeneratorType_type.tp_getattro = PyObject_GenericGetAttr; + __pyx_GeneratorType_type.tp_iter = PyObject_SelfIter; + __pyx_GeneratorType = __Pyx_FetchCommonType(&__pyx_GeneratorType_type); + if (unlikely(!__pyx_GeneratorType)) { + return -1; + } + return 0; +} + +/* CheckBinaryVersion */ + static int __Pyx_check_binary_version(void) { + char ctversion[4], rtversion[4]; + PyOS_snprintf(ctversion, 4, "%d.%d", PY_MAJOR_VERSION, PY_MINOR_VERSION); + PyOS_snprintf(rtversion, 4, "%s", Py_GetVersion()); + if (ctversion[0] != rtversion[0] || ctversion[2] != rtversion[2]) { + char message[200]; + PyOS_snprintf(message, sizeof(message), + "compiletime version %s of module '%.100s' " + "does not match runtime version %s", + ctversion, __Pyx_MODULE_NAME, rtversion); + return PyErr_WarnEx(NULL, message, 1); + } + return 0; +} + +/* VoidPtrExport */ + static int __Pyx_ExportVoidPtr(PyObject *name, void *p, const char *sig) { + PyObject *d; + PyObject *cobj = 0; + d = PyDict_GetItem(__pyx_d, __pyx_n_s_pyx_capi); + Py_XINCREF(d); + if (!d) { + d = PyDict_New(); + if (!d) + goto bad; + if (__Pyx_PyObject_SetAttrStr(__pyx_m, __pyx_n_s_pyx_capi, d) < 0) + goto bad; + } +#if PY_VERSION_HEX >= 0x02070000 + cobj = PyCapsule_New(p, sig, 0); +#else + cobj = PyCObject_FromVoidPtrAndDesc(p, (void *)sig, 0); +#endif + if (!cobj) + goto bad; + if (PyDict_SetItem(d, name, cobj) < 0) + goto bad; + Py_DECREF(cobj); + Py_DECREF(d); + return 0; +bad: + Py_XDECREF(cobj); + Py_XDECREF(d); + return -1; +} + +/* ModuleImport */ + #ifndef __PYX_HAVE_RT_ImportModule +#define __PYX_HAVE_RT_ImportModule +static PyObject *__Pyx_ImportModule(const char *name) { + PyObject *py_name = 0; + PyObject *py_module = 0; + py_name = __Pyx_PyIdentifier_FromString(name); + if (!py_name) + goto bad; + py_module = PyImport_Import(py_name); + Py_DECREF(py_name); + return py_module; +bad: + Py_XDECREF(py_name); + return 0; +} +#endif + +/* TypeImport */ + #ifndef __PYX_HAVE_RT_ImportType +#define __PYX_HAVE_RT_ImportType +static PyTypeObject *__Pyx_ImportType(const char *module_name, const char *class_name, + size_t size, int strict) +{ + PyObject *py_module = 0; + PyObject *result = 0; + PyObject *py_name = 0; + char warning[200]; + Py_ssize_t basicsize; +#ifdef Py_LIMITED_API + PyObject *py_basicsize; +#endif + py_module = __Pyx_ImportModule(module_name); + if (!py_module) + goto bad; + py_name = __Pyx_PyIdentifier_FromString(class_name); + if (!py_name) + goto bad; + result = PyObject_GetAttr(py_module, py_name); + Py_DECREF(py_name); + py_name = 0; + Py_DECREF(py_module); + py_module = 0; + if (!result) + goto bad; + if (!PyType_Check(result)) { + PyErr_Format(PyExc_TypeError, + "%.200s.%.200s is not a type object", + module_name, class_name); + goto bad; + } +#ifndef Py_LIMITED_API + basicsize = ((PyTypeObject *)result)->tp_basicsize; +#else + py_basicsize = PyObject_GetAttrString(result, "__basicsize__"); + if (!py_basicsize) + goto bad; + basicsize = PyLong_AsSsize_t(py_basicsize); + Py_DECREF(py_basicsize); + py_basicsize = 0; + if (basicsize == (Py_ssize_t)-1 && PyErr_Occurred()) + goto bad; +#endif + if (!strict && (size_t)basicsize > size) { + PyOS_snprintf(warning, sizeof(warning), + "%s.%s size changed, may indicate binary incompatibility. Expected %zd, got %zd", + module_name, class_name, basicsize, size); + if (PyErr_WarnEx(NULL, warning, 0) < 0) goto bad; + } + else if ((size_t)basicsize != size) { + PyErr_Format(PyExc_ValueError, + "%.200s.%.200s has the wrong size, try recompiling. Expected %zd, got %zd", + module_name, class_name, basicsize, size); + goto bad; + } + return (PyTypeObject *)result; +bad: + Py_XDECREF(py_module); + Py_XDECREF(result); + return NULL; +} +#endif + +/* InitStrings */ + static int __Pyx_InitStrings(__Pyx_StringTabEntry *t) { + while (t->p) { + #if PY_MAJOR_VERSION < 3 + if (t->is_unicode) { + *t->p = PyUnicode_DecodeUTF8(t->s, t->n - 1, NULL); + } else if (t->intern) { + *t->p = PyString_InternFromString(t->s); + } else { + *t->p = PyString_FromStringAndSize(t->s, t->n - 1); + } + #else + if (t->is_unicode | t->is_str) { + if (t->intern) { + *t->p = PyUnicode_InternFromString(t->s); + } else if (t->encoding) { + *t->p = PyUnicode_Decode(t->s, t->n - 1, t->encoding, NULL); + } else { + *t->p = PyUnicode_FromStringAndSize(t->s, t->n - 1); + } + } else { + *t->p = PyBytes_FromStringAndSize(t->s, t->n - 1); + } + #endif + if (!*t->p) + return -1; + ++t; + } + return 0; +} + +static CYTHON_INLINE PyObject* __Pyx_PyUnicode_FromString(const char* c_str) { + return __Pyx_PyUnicode_FromStringAndSize(c_str, (Py_ssize_t)strlen(c_str)); +} +static CYTHON_INLINE char* __Pyx_PyObject_AsString(PyObject* o) { + Py_ssize_t ignore; + return __Pyx_PyObject_AsStringAndSize(o, &ignore); +} +static CYTHON_INLINE char* __Pyx_PyObject_AsStringAndSize(PyObject* o, Py_ssize_t *length) { +#if CYTHON_COMPILING_IN_CPYTHON && (__PYX_DEFAULT_STRING_ENCODING_IS_ASCII || __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT) + if ( +#if PY_MAJOR_VERSION < 3 && __PYX_DEFAULT_STRING_ENCODING_IS_ASCII + __Pyx_sys_getdefaultencoding_not_ascii && +#endif + PyUnicode_Check(o)) { +#if PY_VERSION_HEX < 0x03030000 + char* defenc_c; + PyObject* defenc = _PyUnicode_AsDefaultEncodedString(o, NULL); + if (!defenc) return NULL; + defenc_c = PyBytes_AS_STRING(defenc); +#if __PYX_DEFAULT_STRING_ENCODING_IS_ASCII + { + char* end = defenc_c + PyBytes_GET_SIZE(defenc); + char* c; + for (c = defenc_c; c < end; c++) { + if ((unsigned char) (*c) >= 128) { + PyUnicode_AsASCIIString(o); + return NULL; + } + } + } +#endif + *length = PyBytes_GET_SIZE(defenc); + return defenc_c; +#else + if (__Pyx_PyUnicode_READY(o) == -1) return NULL; +#if __PYX_DEFAULT_STRING_ENCODING_IS_ASCII + if (PyUnicode_IS_ASCII(o)) { + *length = PyUnicode_GET_LENGTH(o); + return PyUnicode_AsUTF8(o); + } else { + PyUnicode_AsASCIIString(o); + return NULL; + } +#else + return PyUnicode_AsUTF8AndSize(o, length); +#endif +#endif + } else +#endif +#if (!CYTHON_COMPILING_IN_PYPY) || (defined(PyByteArray_AS_STRING) && defined(PyByteArray_GET_SIZE)) + if (PyByteArray_Check(o)) { + *length = PyByteArray_GET_SIZE(o); + return PyByteArray_AS_STRING(o); + } else +#endif + { + char* result; + int r = PyBytes_AsStringAndSize(o, &result, length); + if (unlikely(r < 0)) { + return NULL; + } else { + return result; + } + } +} +static CYTHON_INLINE int __Pyx_PyObject_IsTrue(PyObject* x) { + int is_true = x == Py_True; + if (is_true | (x == Py_False) | (x == Py_None)) return is_true; + else return PyObject_IsTrue(x); +} +static CYTHON_INLINE PyObject* __Pyx_PyNumber_IntOrLong(PyObject* x) { +#if CYTHON_USE_TYPE_SLOTS + PyNumberMethods *m; +#endif + const char *name = NULL; + PyObject *res = NULL; +#if PY_MAJOR_VERSION < 3 + if (PyInt_Check(x) || PyLong_Check(x)) +#else + if (PyLong_Check(x)) +#endif + return __Pyx_NewRef(x); +#if CYTHON_USE_TYPE_SLOTS + m = Py_TYPE(x)->tp_as_number; + #if PY_MAJOR_VERSION < 3 + if (m && m->nb_int) { + name = "int"; + res = PyNumber_Int(x); + } + else if (m && m->nb_long) { + name = "long"; + res = PyNumber_Long(x); + } + #else + if (m && m->nb_int) { + name = "int"; + res = PyNumber_Long(x); + } + #endif +#else + res = PyNumber_Int(x); +#endif + if (res) { +#if PY_MAJOR_VERSION < 3 + if (!PyInt_Check(res) && !PyLong_Check(res)) { +#else + if (!PyLong_Check(res)) { +#endif + PyErr_Format(PyExc_TypeError, + "__%.4s__ returned non-%.4s (type %.200s)", + name, name, Py_TYPE(res)->tp_name); + Py_DECREF(res); + return NULL; + } + } + else if (!PyErr_Occurred()) { + PyErr_SetString(PyExc_TypeError, + "an integer is required"); + } + return res; +} +static CYTHON_INLINE Py_ssize_t __Pyx_PyIndex_AsSsize_t(PyObject* b) { + Py_ssize_t ival; + PyObject *x; +#if PY_MAJOR_VERSION < 3 + if (likely(PyInt_CheckExact(b))) { + if (sizeof(Py_ssize_t) >= sizeof(long)) + return PyInt_AS_LONG(b); + else + return PyInt_AsSsize_t(x); + } +#endif + if (likely(PyLong_CheckExact(b))) { + #if CYTHON_USE_PYLONG_INTERNALS + const digit* digits = ((PyLongObject*)b)->ob_digit; + const Py_ssize_t size = Py_SIZE(b); + if (likely(__Pyx_sst_abs(size) <= 1)) { + ival = likely(size) ? digits[0] : 0; + if (size == -1) ival = -ival; + return ival; + } else { + switch (size) { + case 2: + if (8 * sizeof(Py_ssize_t) > 2 * PyLong_SHIFT) { + return (Py_ssize_t) (((((size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0])); + } + break; + case -2: + if (8 * sizeof(Py_ssize_t) > 2 * PyLong_SHIFT) { + return -(Py_ssize_t) (((((size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0])); + } + break; + case 3: + if (8 * sizeof(Py_ssize_t) > 3 * PyLong_SHIFT) { + return (Py_ssize_t) (((((((size_t)digits[2]) << PyLong_SHIFT) | (size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0])); + } + break; + case -3: + if (8 * sizeof(Py_ssize_t) > 3 * PyLong_SHIFT) { + return -(Py_ssize_t) (((((((size_t)digits[2]) << PyLong_SHIFT) | (size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0])); + } + break; + case 4: + if (8 * sizeof(Py_ssize_t) > 4 * PyLong_SHIFT) { + return (Py_ssize_t) (((((((((size_t)digits[3]) << PyLong_SHIFT) | (size_t)digits[2]) << PyLong_SHIFT) | (size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0])); + } + break; + case -4: + if (8 * sizeof(Py_ssize_t) > 4 * PyLong_SHIFT) { + return -(Py_ssize_t) (((((((((size_t)digits[3]) << PyLong_SHIFT) | (size_t)digits[2]) << PyLong_SHIFT) | (size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0])); + } + break; + } + } + #endif + return PyLong_AsSsize_t(b); + } + x = PyNumber_Index(b); + if (!x) return -1; + ival = PyInt_AsSsize_t(x); + Py_DECREF(x); + return ival; +} +static CYTHON_INLINE PyObject * __Pyx_PyInt_FromSize_t(size_t ival) { + return PyInt_FromSize_t(ival); +} + + +#endif /* Py_PYTHON_H */ diff --git a/asyncpg/protocol/protocol.pxd b/asyncpg/protocol/protocol.pxd new file mode 100644 index 0000000..190b3ae --- /dev/null +++ b/asyncpg/protocol/protocol.pxd @@ -0,0 +1,62 @@ +# Copyright (C) 2016-present the ayncpg authors and contributors +# +# +# This module is part of asyncpg and is released under +# the Apache 2.0 License: http://www.apache.org/licenses/LICENSE-2.0 + + +# cython: language_level=3 + + +from libc.stdint cimport int16_t, int32_t, uint16_t, uint32_t, int64_t, uint64_t + +from .debug cimport ASYNCPG_DEBUG + +include "consts.pxi" +include "pgtypes.pxi" + +include "buffer.pxd" +include "codecs/base.pxd" +include "settings.pxd" +include "coreproto.pxd" +include "prepared_stmt.pxd" + + +cdef class BaseProtocol(CoreProtocol): + + cdef: + object loop + object address + ConnectionSettings settings + object cancel_sent_waiter + object cancel_waiter + object waiter + bint return_extra + object create_future + object timeout_handle + object timeout_callback + object completed_callback + object connection + + str last_query + + int uid_counter + bint closing + + readonly uint64_t queries_count + + PreparedStatementState statement + + cdef _ensure_clear_state(self) + cdef _new_waiter(self, timeout) + + cdef _on_result__connect(self, object waiter) + cdef _on_result__prepare(self, object waiter) + cdef _on_result__bind_and_exec(self, object waiter) + cdef _on_result__close_stmt_or_portal(self, object waiter) + cdef _on_result__simple_query(self, object waiter) + cdef _on_result__bind(self, object waiter) + + cdef _handle_waiter_on_connection_lost(self, cause) + + cdef _dispatch_result(self) diff --git a/asyncpg/protocol/protocol.pyx b/asyncpg/protocol/protocol.pyx new file mode 100644 index 0000000..6fdad83 --- /dev/null +++ b/asyncpg/protocol/protocol.pyx @@ -0,0 +1,532 @@ +# Copyright (C) 2016-present the ayncpg authors and contributors +# +# +# This module is part of asyncpg and is released under +# the Apache 2.0 License: http://www.apache.org/licenses/LICENSE-2.0 + + +# cython: language_level=3 + +cimport cython +cimport cpython + +import asyncio +import codecs +import collections +import socket + +from libc.stdint cimport int8_t, uint8_t, int16_t, uint16_t, \ + int32_t, uint32_t, int64_t, uint64_t + +from asyncpg.protocol cimport record + +from asyncpg.protocol.python cimport ( + PyMem_Malloc, PyMem_Realloc, PyMem_Calloc, PyMem_Free, + PyMemoryView_GET_BUFFER, PyMemoryView_Check, + PyUnicode_AsUTF8AndSize, PyByteArray_AsString, + PyByteArray_Check, PyUnicode_AsUCS4Copy, + PyUnicode_FromKindAndData, PyUnicode_4BYTE_KIND) + +from cpython cimport PyBuffer_FillInfo, PyBytes_AsString + +from asyncpg.exceptions import _base as apg_exc_base +from asyncpg import types as apg_types +from asyncpg import exceptions as apg_exc + +from asyncpg.protocol cimport hton + +include "consts.pxi" +include "pgtypes.pxi" + +include "encodings.pyx" +include "settings.pyx" +include "buffer.pyx" + +include "codecs/base.pyx" +include "codecs/textutils.pyx" + +# String types. Need to go first, as other codecs may rely on +# text decoding/encoding. +include "codecs/bytea.pyx" +include "codecs/text.pyx" + +# Builtin types, in lexicographical order. +include "codecs/bits.pyx" +include "codecs/datetime.pyx" +include "codecs/float.pyx" +include "codecs/geometry.pyx" +include "codecs/int.pyx" +include "codecs/json.pyx" +include "codecs/money.pyx" +include "codecs/network.pyx" +include "codecs/numeric.pyx" +include "codecs/tsearch.pyx" +include "codecs/txid.pyx" +include "codecs/uuid.pyx" + +# Various pseudotypes and system types +include "codecs/misc.pyx" + +# nonscalar +include "codecs/array.pyx" +include "codecs/range.pyx" +include "codecs/record.pyx" + +# contrib +include "codecs/hstore.pyx" + +include "coreproto.pyx" +include "prepared_stmt.pyx" + + +cdef class BaseProtocol(CoreProtocol): + def __init__(self, addr, connected_fut, con_args, loop): + CoreProtocol.__init__(self, con_args) + + self.loop = loop + self.waiter = connected_fut + self.cancel_waiter = None + self.cancel_sent_waiter = None + + self.address = addr + self.settings = ConnectionSettings( + (self.address, con_args.get('database'))) + + self.uid_counter = 0 + self.statement = None + self.return_extra = False + + self.last_query = None + + self.closing = False + + self.timeout_handle = None + self.timeout_callback = self._on_timeout + self.completed_callback = self._on_waiter_completed + + self.queries_count = 0 + + try: + self.create_future = loop.create_future + except AttributeError: + self.create_future = self._create_future_fallback + + def set_connection(self, connection): + self.connection = connection + + def get_server_pid(self): + return self.backend_pid + + def get_settings(self): + return self.settings + + async def prepare(self, stmt_name, query, timeout): + if self.cancel_waiter is not None: + await self.cancel_waiter + if self.cancel_sent_waiter is not None: + await self.cancel_sent_waiter + self.cancel_sent_waiter = None + + self._ensure_clear_state() + + if stmt_name is None: + self.uid_counter += 1 + stmt_name = 'stmt_{}'.format(self.uid_counter) + + self._prepare(stmt_name, query) + self.last_query = query + self.statement = PreparedStatementState(stmt_name, query, self) + + return await self._new_waiter(timeout) + + async def bind_execute(self, PreparedStatementState state, args, + str portal_name, int limit, return_extra, + timeout): + + if self.cancel_waiter is not None: + await self.cancel_waiter + if self.cancel_sent_waiter is not None: + await self.cancel_sent_waiter + self.cancel_sent_waiter = None + + self._ensure_clear_state() + + self._bind_execute( + portal_name, + state.name, + state._encode_bind_msg(args), + limit) + + self.last_query = state.query + self.statement = state + self.return_extra = return_extra + self.queries_count += 1 + + return await self._new_waiter(timeout) + + async def bind_execute_many(self, PreparedStatementState state, args, + str portal_name, timeout): + + if self.cancel_waiter is not None: + await self.cancel_waiter + if self.cancel_sent_waiter is not None: + await self.cancel_sent_waiter + self.cancel_sent_waiter = None + + self._ensure_clear_state() + + # Make sure the argument sequence is encoded lazily with + # this generator expression to keep the memory pressure under + # control. + data_gen = (state._encode_bind_msg(b) for b in args) + arg_bufs = iter(data_gen) + + waiter = self._new_waiter(timeout) + + self._bind_execute_many( + portal_name, + state.name, + arg_bufs) + + self.last_query = state.query + self.statement = state + self.return_extra = False + self.queries_count += 1 + + return await waiter + + async def bind(self, PreparedStatementState state, args, + str portal_name, timeout): + + if self.cancel_waiter is not None: + await self.cancel_waiter + if self.cancel_sent_waiter is not None: + await self.cancel_sent_waiter + self.cancel_sent_waiter = None + + self._ensure_clear_state() + + self._bind( + portal_name, + state.name, + state._encode_bind_msg(args)) + + self.last_query = state.query + self.statement = state + + return await self._new_waiter(timeout) + + async def execute(self, PreparedStatementState state, + str portal_name, int limit, return_extra, + timeout): + + if self.cancel_waiter is not None: + await self.cancel_waiter + if self.cancel_sent_waiter is not None: + await self.cancel_sent_waiter + self.cancel_sent_waiter = None + + self._ensure_clear_state() + + self._execute( + portal_name, + limit) + + self.last_query = state.query + self.statement = state + self.return_extra = return_extra + self.queries_count += 1 + + return await self._new_waiter(timeout) + + async def query(self, query, timeout): + if self.cancel_waiter is not None: + await self.cancel_waiter + if self.cancel_sent_waiter is not None: + await self.cancel_sent_waiter + self.cancel_sent_waiter = None + + self._ensure_clear_state() + + self._simple_query(query) + self.last_query = query + self.queries_count += 1 + + return await self._new_waiter(timeout) + + async def close_statement(self, PreparedStatementState state, timeout): + if self.cancel_waiter is not None: + await self.cancel_waiter + if self.cancel_sent_waiter is not None: + await self.cancel_sent_waiter + self.cancel_sent_waiter = None + + self._ensure_clear_state() + + if state.refs != 0: + raise RuntimeError( + 'cannot close prepared statement; refs == {} != 0'.format( + state.refs)) + + self._close(state.name, False) + state.closed = True + return await self._new_waiter(timeout) + + def is_closed(self): + return self.closing + + def is_connected(self): + return not self.closing and self.con_status == CONNECTION_OK + + def abort(self): + if self.closing: + return + self.closing = True + self._handle_waiter_on_connection_lost(None) + self._terminate() + self.transport.abort() + + async def close(self): + if self.cancel_waiter is not None: + await self.cancel_waiter + if self.cancel_sent_waiter is not None: + await self.cancel_sent_waiter + self.cancel_sent_waiter = None + + self._handle_waiter_on_connection_lost(None) + assert self.waiter is None + + if self.closing: + return + + self._terminate() + self.waiter = self.create_future() + self.closing = True + self.transport.abort() + return await self.waiter + + def _request_cancel(self): + self.cancel_waiter = self.create_future() + self.cancel_sent_waiter = self.create_future() + self.connection._cancel_current_command(self.cancel_sent_waiter) + + def _on_timeout(self, fut): + if self.waiter is not fut or fut.done() or \ + self.cancel_waiter is not None or \ + self.timeout_handle is None: + return + self._request_cancel() + self.waiter.set_exception(asyncio.TimeoutError()) + + def _on_waiter_completed(self, fut): + if fut is not self.waiter or self.cancel_waiter is not None: + return + if fut.cancelled(): + if self.timeout_handle: + self.timeout_handle.cancel() + self.timeout_handle = None + self._request_cancel() + + def _create_future_fallback(self): + return asyncio.Future(loop=self.loop) + + cdef _handle_waiter_on_connection_lost(self, cause): + if self.waiter is not None and not self.waiter.done(): + exc = apg_exc.ConnectionDoesNotExistError( + 'connection was closed in the middle of ' + 'operation') + if cause is not None: + exc.__cause__ = cause + self.waiter.set_exception(exc) + self.waiter = None + + cdef _set_server_parameter(self, name, val): + self.settings.add_setting(name, val) + + cdef _ensure_clear_state(self): + if self.cancel_waiter is not None: + raise apg_exc.InterfaceError( + 'cannot perform operation: another operation is cancelling') + if self.closing: + raise apg_exc.InterfaceError( + 'cannot perform operation: connection is closed') + if self.waiter is not None or self.timeout_handle is not None: + raise apg_exc.InterfaceError( + 'cannot perform operation: another operation is in progress') + + cdef _new_waiter(self, timeout): + self.waiter = self.create_future() + if timeout is not False: + timeout = timeout or self.connection._command_timeout + if timeout is not None and timeout > 0: + self.timeout_handle = self.connection._loop.call_later( + timeout, self.timeout_callback, self.waiter) + self.waiter.add_done_callback(self.completed_callback) + return self.waiter + + cdef _on_result__connect(self, object waiter): + waiter.set_result(True) + + cdef _on_result__prepare(self, object waiter): + if ASYNCPG_DEBUG: + if self.statement is None: + raise RuntimeError( + '_on_result__prepare: statement is None') + + if self.result_param_desc is not None: + self.statement._set_args_desc(self.result_param_desc) + if self.result_row_desc is not None: + self.statement._set_row_desc(self.result_row_desc) + waiter.set_result(self.statement) + + cdef _on_result__bind_and_exec(self, object waiter): + if self.return_extra: + waiter.set_result(( + self.result, + self.result_status_msg, + self.result_execute_completed)) + else: + waiter.set_result(self.result) + + cdef _on_result__bind(self, object waiter): + waiter.set_result(self.result) + + cdef _on_result__close_stmt_or_portal(self, object waiter): + waiter.set_result(self.result) + + cdef _on_result__simple_query(self, object waiter): + waiter.set_result(self.result_status_msg.decode(self.encoding)) + + cdef _decode_row(self, const char* buf, ssize_t buf_len): + if ASYNCPG_DEBUG: + if self.statement is None: + raise RuntimeError( + '_decode_row: statement is None') + + return self.statement._decode_row(buf, buf_len) + + cdef _dispatch_result(self): + waiter = self.waiter + self.waiter = None + + if ASYNCPG_DEBUG: + if waiter is None: + raise RuntimeError('_on_result: waiter is None') + + if waiter.cancelled(): + return + + if waiter.done(): + raise RuntimeError('_on_result: waiter is done') + + if self.result_type == RESULT_FAILED: + if isinstance(self.result, dict): + exc = apg_exc_base.PostgresMessage.new( + self.result, query=self.last_query) + else: + exc = self.result + waiter.set_exception(exc) + return + + try: + if self.state == PROTOCOL_AUTH: + self._on_result__connect(waiter) + + elif self.state == PROTOCOL_PREPARE: + self._on_result__prepare(waiter) + + elif self.state == PROTOCOL_BIND_EXECUTE: + self._on_result__bind_and_exec(waiter) + + elif self.state == PROTOCOL_BIND_EXECUTE_MANY: + self._on_result__bind_and_exec(waiter) + + elif self.state == PROTOCOL_EXECUTE: + self._on_result__bind_and_exec(waiter) + + elif self.state == PROTOCOL_BIND: + self._on_result__bind(waiter) + + elif self.state == PROTOCOL_CLOSE_STMT_PORTAL: + self._on_result__close_stmt_or_portal(waiter) + + elif self.state == PROTOCOL_SIMPLE_QUERY: + self._on_result__simple_query(waiter) + + else: + raise RuntimeError( + 'got result for unknown protocol state {}'. + format(self.state)) + + except Exception as exc: + waiter.set_exception(exc) + + cdef _on_result(self): + if self.timeout_handle is not None: + self.timeout_handle.cancel() + self.timeout_handle = None + + if self.cancel_waiter is not None: + if self.waiter is None or not self.waiter.cancelled(): + self.cancel_waiter.set_result( + RuntimeError('invalid state after cancellation')) + else: + self.cancel_waiter.set_result(None) + self.cancel_waiter = None + self.waiter = None + return + + try: + self._dispatch_result() + finally: + self.statement = None + self.last_query = None + self.return_extra = False + + cdef _on_notification(self, pid, channel, payload): + self.connection._notify(pid, channel, payload) + + cdef _on_connection_lost(self, exc): + if self.closing: + # The connection was lost because + # Protocol.close() was called + if self.waiter is not None and not self.waiter.done(): + if exc is None: + self.waiter.set_result(None) + else: + self.waiter.set_exception(exc) + self.waiter = None + else: + # The connection was lost because it was + # terminated or due to another error; + # Throw an error in any awaiting waiter. + self.closing = True + self._handle_waiter_on_connection_lost(exc) + + +class Protocol(BaseProtocol, asyncio.Protocol): + pass + + +def _create_record(object mapping, tuple elems): + # Exposed only for testing purposes. + + cdef: + object rec + int32_t i + + if mapping is None: + desc = record.ApgRecordDesc_New({}, ()) + else: + desc = record.ApgRecordDesc_New( + mapping, tuple(mapping) if mapping else ()) + + rec = record.ApgRecord_New(desc, len(elems)) + for i in range(len(elems)): + elem = elems[i] + cpython.Py_INCREF(elem) + record.ApgRecord_SET_ITEM(rec, i, elem) + return rec + + +record.ApgRecord_InitTypes() diff --git a/asyncpg/protocol/python.pxd b/asyncpg/protocol/python.pxd new file mode 100644 index 0000000..869eed3 --- /dev/null +++ b/asyncpg/protocol/python.pxd @@ -0,0 +1,27 @@ +# Copyright (C) 2016-present the ayncpg authors and contributors +# +# +# This module is part of asyncpg and is released under +# the Apache 2.0 License: http://www.apache.org/licenses/LICENSE-2.0 + + +from cpython cimport Py_buffer + +cdef extern from "Python.h": + void* PyMem_Malloc(size_t n) + void* PyMem_Realloc(void *p, size_t n) + void* PyMem_Calloc(size_t nelem, size_t elsize) # Python >= 3.5! + void PyMem_Free(void *p) + + int PyByteArray_Check(object) + + int PyMemoryView_Check(object) + Py_buffer *PyMemoryView_GET_BUFFER(object) + + char* PyUnicode_AsUTF8AndSize(object unicode, ssize_t *size) except NULL + char* PyByteArray_AsString(object) + Py_UCS4* PyUnicode_AsUCS4Copy(object) + object PyUnicode_FromKindAndData( + int kind, const void *buffer, Py_ssize_t size) + + int PyUnicode_4BYTE_KIND diff --git a/asyncpg/protocol/record/__init__.pxd b/asyncpg/protocol/record/__init__.pxd new file mode 100644 index 0000000..cd28d20 --- /dev/null +++ b/asyncpg/protocol/record/__init__.pxd @@ -0,0 +1,16 @@ +# Copyright (C) 2016-present the ayncpg authors and contributors +# +# +# This module is part of asyncpg and is released under +# the Apache 2.0 License: http://www.apache.org/licenses/LICENSE-2.0 + + +cdef extern from "record/recordobj.h": + + int ApgRecord_InitTypes() except -1 + + int ApgRecord_CheckExact(object) + object ApgRecord_New(object, int) + void ApgRecord_SET_ITEM(object, int, object) + + object ApgRecordDesc_New(object, object) diff --git a/asyncpg/protocol/record/recordobj.c b/asyncpg/protocol/record/recordobj.c new file mode 100644 index 0000000..eed1c56 --- /dev/null +++ b/asyncpg/protocol/record/recordobj.c @@ -0,0 +1,953 @@ +/* Big parts of this file are copied (with modifications) from + CPython/Objects/tupleobject.c. + + Portions Copyright (c) PSF (and other CPython copyright holders). + Portions Copyright (c) 2016-present MagicStack Inc. + License: PSFL v2; see CPython/LICENSE for details. +*/ + +#include "recordobj.h" + + +static PyObject * record_iter(PyObject *); +static PyObject * record_new_items_iter(PyObject *); + +static ApgRecordObject *free_list[ApgRecord_MAXSAVESIZE]; +static int numfree[ApgRecord_MAXSAVESIZE]; + + +PyObject * +ApgRecord_New(PyObject *desc, Py_ssize_t size) +{ + ApgRecordObject *o; + Py_ssize_t i; + + if (size < 0 || desc == NULL || !ApgRecordDesc_CheckExact(desc)) { + PyErr_BadInternalCall(); + return NULL; + } + + if (size < ApgRecord_MAXSAVESIZE && (o = free_list[size]) != NULL) { + free_list[size] = (ApgRecordObject *) o->ob_item[0]; + numfree[size]--; + _Py_NewReference((PyObject *)o); + } + else { + /* Check for overflow */ + if ((size_t)size > ((size_t)PY_SSIZE_T_MAX - sizeof(ApgRecordObject) - + sizeof(PyObject *)) / sizeof(PyObject *)) { + return PyErr_NoMemory(); + } + o = PyObject_GC_NewVar(ApgRecordObject, &ApgRecord_Type, size); + if (o == NULL) { + return NULL; + } + } + + for (i = 0; i < size; i++) { + o->ob_item[i] = NULL; + } + + Py_INCREF(desc); + o->desc = (ApgRecordDescObject*)desc; + o->self_hash = -1; + PyObject_GC_Track(o); + return (PyObject *) o; +} + + +static void +record_dealloc(ApgRecordObject *o) +{ + Py_ssize_t i; + Py_ssize_t len = Py_SIZE(o); + + PyObject_GC_UnTrack(o); + + o->self_hash = -1; + + Py_CLEAR(o->desc); + + Py_TRASHCAN_SAFE_BEGIN(o) + if (len > 0) { + i = len; + while (--i >= 0) { + Py_CLEAR(o->ob_item[i]); + } + + if (len < ApgRecord_MAXSAVESIZE && + numfree[len] < ApgRecord_MAXFREELIST && + ApgRecord_CheckExact(o)) + { + o->ob_item[0] = (PyObject *) free_list[len]; + numfree[len]++; + free_list[len] = o; + goto done; /* return */ + } + } + Py_TYPE(o)->tp_free((PyObject *)o); +done: + Py_TRASHCAN_SAFE_END(o) +} + + +static int +record_traverse(ApgRecordObject *o, visitproc visit, void *arg) +{ + Py_ssize_t i; + + Py_VISIT(o->desc); + + for (i = Py_SIZE(o); --i >= 0;) { + if (o->ob_item[i] != NULL) { + Py_VISIT(o->ob_item[i]); + } + } + + return 0; +} + + +static Py_ssize_t +record_length(ApgRecordObject *o) +{ + return Py_SIZE(o); +} + + +static Py_hash_t +record_hash(ApgRecordObject *v) +{ + Py_uhash_t x; /* Unsigned for defined overflow behavior. */ + Py_hash_t y; + Py_ssize_t len; + PyObject **p; + Py_uhash_t mult; + + if (v->self_hash != -1) { + return v->self_hash; + } + + len = Py_SIZE(v); + mult = _PyHASH_MULTIPLIER; + + x = 0x345678UL; + p = v->ob_item; + while (--len >= 0) { + y = PyObject_Hash(*p++); + if (y == -1) { + return -1; + } + x = (x ^ (Py_uhash_t)y) * mult; + /* the cast might truncate len; that doesn't change hash stability */ + mult += (Py_uhash_t)(82520UL + (size_t)len + (size_t)len); + } + x += 97531UL; + if (x == (Py_uhash_t)-1) { + x = (Py_uhash_t)-2; + } + v->self_hash = (Py_hash_t)x; + return (Py_hash_t)x; +} + + +static PyObject * +record_richcompare(PyObject *v, PyObject *w, int op) +{ + Py_ssize_t i; + Py_ssize_t vlen, wlen; + int v_is_tuple = 0; + int w_is_tuple = 0; + int comp; + + if (!ApgRecord_CheckExact(v)) { + if (!PyTuple_Check(v)) { + Py_RETURN_NOTIMPLEMENTED; + } + v_is_tuple = 1; + } + + if (!ApgRecord_CheckExact(w)) { + if (!PyTuple_Check(w)) { + Py_RETURN_NOTIMPLEMENTED; + } + w_is_tuple = 1; + } + +#define V_ITEM(i) \ + (v_is_tuple ? (PyTuple_GET_ITEM(v, i)) : (ApgRecord_GET_ITEM(v, i))) +#define W_ITEM(i) \ + (w_is_tuple ? (PyTuple_GET_ITEM(w, i)) : (ApgRecord_GET_ITEM(w, i))) + + vlen = Py_SIZE(v); + wlen = Py_SIZE(w); + + if (op == Py_EQ && vlen != wlen) { + /* Checking if v == w, but len(v) != len(w): return False */ + Py_RETURN_FALSE; + } + + if (op == Py_NE && vlen != wlen) { + /* Checking if v != w, and len(v) != len(w): return True */ + Py_RETURN_TRUE; + } + + /* Search for the first index where items are different. + * Note that because tuples are immutable, it's safe to reuse + * vlen and wlen across the comparison calls. + */ + for (i = 0; i < vlen && i < wlen; i++) { + comp = PyObject_RichCompareBool(V_ITEM(i), W_ITEM(i), Py_EQ); + if (comp < 0) { + return NULL; + } + if (!comp) { + break; + } + } + + if (i >= vlen || i >= wlen) { + /* No more items to compare -- compare sizes */ + int cmp; + switch (op) { + case Py_LT: cmp = vlen < wlen; break; + case Py_LE: cmp = vlen <= wlen; break; + case Py_EQ: cmp = vlen == wlen; break; + case Py_NE: cmp = vlen != wlen; break; + case Py_GT: cmp = vlen > wlen; break; + case Py_GE: cmp = vlen >= wlen; break; + default: return NULL; /* cannot happen */ + } + if (cmp) { + Py_RETURN_TRUE; + } + else { + Py_RETURN_FALSE; + } + } + + /* We have an item that differs -- shortcuts for EQ/NE */ + if (op == Py_EQ) { + Py_RETURN_FALSE; + } + if (op == Py_NE) { + Py_RETURN_TRUE; + } + + /* Compare the final item again using the proper operator */ + return PyObject_RichCompare(V_ITEM(i), W_ITEM(i), op); + +#undef V_ITEM +#undef W_ITEM +} + + +static PyObject * +record_item(ApgRecordObject *o, Py_ssize_t i) +{ + if (i < 0 || i >= Py_SIZE(o)) { + PyErr_SetString(PyExc_IndexError, "record index out of range"); + return NULL; + } + Py_INCREF(o->ob_item[i]); + return o->ob_item[i]; +} + + +static PyObject * +record_subscript(ApgRecordObject* o, PyObject* item) +{ + if (PyIndex_Check(item)) { + Py_ssize_t i = PyNumber_AsSsize_t(item, PyExc_IndexError); + if (i == -1 && PyErr_Occurred()) + return NULL; + if (i < 0) { + i += Py_SIZE(o); + } + return record_item(o, i); + } + else if (PySlice_Check(item)) { + Py_ssize_t start, stop, step, slicelength, cur, i; + PyObject* result; + PyObject* it; + PyObject **src, **dest; + + if (PySlice_GetIndicesEx( + item, + Py_SIZE(o), + &start, &stop, &step, &slicelength) < 0) + { + return NULL; + } + + if (slicelength <= 0) { + return PyTuple_New(0); + } + else { + result = PyTuple_New(slicelength); + if (!result) return NULL; + + src = o->ob_item; + dest = ((PyTupleObject *)result)->ob_item; + for (cur = start, i = 0; i < slicelength; cur += step, i++) { + it = src[cur]; + Py_INCREF(it); + dest[i] = it; + } + + return result; + } + } + else { + PyObject *mapped; + mapped = PyObject_GetItem(o->desc->mapping, item); + if (mapped != NULL) { + Py_ssize_t i; + PyObject *result; + + if (!PyIndex_Check(mapped)) { + Py_DECREF(mapped); + goto noitem; + } + + i = PyNumber_AsSsize_t(mapped, PyExc_IndexError); + Py_DECREF(mapped); + + if (i < 0) { + if (PyErr_Occurred()) { + PyErr_Clear(); + } + goto noitem; + } + + result = record_item(o, i); + if (result == NULL) { + PyErr_Clear(); + goto noitem; + } + return result; + } + else { + goto noitem; + } + } + +noitem: + _PyErr_SetKeyError(item); + return NULL; +} + + +static PyObject * +record_repr(ApgRecordObject *v) +{ + Py_ssize_t i, n; + PyObject *keys_iter; + _PyUnicodeWriter writer; + + n = Py_SIZE(v); + if (n == 0) { + return PyUnicode_FromString(""); + } + + keys_iter = PyObject_GetIter(v->desc->keys); + if (keys_iter == NULL) { + return NULL; + } + + i = Py_ReprEnter((PyObject *)v); + if (i != 0) { + Py_DECREF(keys_iter); + return i > 0 ? PyUnicode_FromString("") : NULL; + } + + _PyUnicodeWriter_Init(&writer); + writer.overallocate = 1; + writer.min_length = 12; /* */ + + if (_PyUnicodeWriter_WriteASCIIString(&writer, " 0) { + if (_PyUnicodeWriter_WriteChar(&writer, ' ') < 0) { + goto error; + } + } + + if (Py_EnterRecursiveCall(" while getting the repr of a record")) { + goto error; + } + val_repr = PyObject_Repr(v->ob_item[i]); + Py_LeaveRecursiveCall(); + if (val_repr == NULL) { + goto error; + } + + key = PyIter_Next(keys_iter); + if (key == NULL) { + Py_DECREF(val_repr); + PyErr_SetString(PyExc_RuntimeError, "invalid record mapping"); + goto error; + } + + key_repr = PyObject_Str(key); + Py_DECREF(key); + if (key_repr == NULL) { + Py_DECREF(val_repr); + goto error; + } + + if (_PyUnicodeWriter_WriteStr(&writer, key_repr) < 0) { + Py_DECREF(key_repr); + Py_DECREF(val_repr); + goto error; + } + Py_DECREF(key_repr); + + if (_PyUnicodeWriter_WriteChar(&writer, '=') < 0) { + Py_DECREF(val_repr); + goto error; + } + + if (_PyUnicodeWriter_WriteStr(&writer, val_repr) < 0) { + Py_DECREF(val_repr); + goto error; + } + Py_DECREF(val_repr); + } + + writer.overallocate = 0; + if (_PyUnicodeWriter_WriteChar(&writer, '>') < 0) { + goto error; + } + + Py_DECREF(keys_iter); + Py_ReprLeave((PyObject *)v); + return _PyUnicodeWriter_Finish(&writer); + +error: + Py_DECREF(keys_iter); + _PyUnicodeWriter_Dealloc(&writer); + Py_ReprLeave((PyObject *)v); + return NULL; +} + + + +static PyObject * +record_values(PyObject *o, PyObject *args) +{ + return record_iter(o); +} + + +static PyObject * +record_keys(PyObject *o, PyObject *args) +{ + if (!ApgRecord_CheckExact(o)) { + PyErr_BadInternalCall(); + return NULL; + } + + return PyObject_GetIter(((ApgRecordObject*)o)->desc->mapping); +} + + +static PyObject * +record_items(PyObject *o, PyObject *args) +{ + if (!ApgRecord_CheckExact(o)) { + PyErr_BadInternalCall(); + return NULL; + } + + return record_new_items_iter(o); +} + + +static int +record_contains(ApgRecordObject *o, PyObject *arg) +{ + if (!ApgRecord_CheckExact(o)) { + PyErr_BadInternalCall(); + return -1; + } + + return PySequence_Contains(o->desc->mapping, arg); +} + + +static PySequenceMethods record_as_sequence = { + (lenfunc)record_length, /* sq_length */ + 0, /* sq_concat */ + 0, /* sq_repeat */ + (ssizeargfunc)record_item, /* sq_item */ + 0, /* sq_slice */ + 0, /* sq_ass_item */ + 0, /* sq_ass_slice */ + (objobjproc)record_contains, /* sq_contains */ +}; + + +static PyMappingMethods record_as_mapping = { + (lenfunc)record_length, /* mp_length */ + (binaryfunc)record_subscript, /* mp_subscript */ + 0 /* mp_ass_subscript */ +}; + + +static PyMethodDef record_methods[] = { + {"values", (PyCFunction)record_values, METH_NOARGS}, + {"keys", (PyCFunction)record_keys, METH_NOARGS}, + {"items", (PyCFunction)record_items, METH_NOARGS}, + {NULL, NULL} /* sentinel */ +}; + + +PyTypeObject ApgRecord_Type = { + PyVarObject_HEAD_INIT(NULL, 0) + "Record", /* tp_name */ + sizeof(ApgRecordObject) - sizeof(PyObject *), /* tp_basic_size */ + sizeof(PyObject *), /* tp_itemsize */ + (destructor)record_dealloc, /* tp_dealloc */ + 0, /* tp_print */ + 0, /* tp_getattr */ + 0, /* tp_setattr */ + 0, /* tp_reserved */ + (reprfunc)record_repr, /* tp_repr */ + 0, /* tp_as_number */ + &record_as_sequence, /* tp_as_sequence */ + &record_as_mapping, /* tp_as_mapping */ + (hashfunc)record_hash, /* tp_hash */ + 0, /* tp_call */ + 0, /* tp_str */ + PyObject_GenericGetAttr, /* tp_getattro */ + 0, /* tp_setattro */ + 0, /* tp_as_buffer */ + Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC | + Py_TPFLAGS_BASETYPE, /* tp_flags */ + 0, /* tp_doc */ + (traverseproc)record_traverse, /* tp_traverse */ + 0, /* tp_clear */ + record_richcompare, /* tp_richcompare */ + 0, /* tp_weaklistoffset */ + record_iter, /* tp_iter */ + 0, /* tp_iternext */ + record_methods, /* tp_methods */ + 0, /* tp_members */ + 0, /* tp_getset */ + 0, /* tp_base */ + 0, /* tp_dict */ + 0, /* tp_descr_get */ + 0, /* tp_descr_set */ + 0, /* tp_dictoffset */ + 0, /* tp_init */ + 0, /* tp_alloc */ + 0, /* tp_new */ + PyObject_GC_Del, /* tp_free */ +}; + + +/* Record Iterator */ + + +typedef struct { + PyObject_HEAD + Py_ssize_t it_index; + ApgRecordObject *it_seq; /* Set to NULL when iterator is exhausted */ +} ApgRecordIterObject; + + +static void +record_iter_dealloc(ApgRecordIterObject *it) +{ + PyObject_GC_UnTrack(it); + Py_CLEAR(it->it_seq); + PyObject_GC_Del(it); +} + + +static int +record_iter_traverse(ApgRecordIterObject *it, visitproc visit, void *arg) +{ + Py_VISIT(it->it_seq); + return 0; +} + + +static PyObject * +record_iter_next(ApgRecordIterObject *it) +{ + ApgRecordObject *seq; + PyObject *item; + + assert(it != NULL); + seq = it->it_seq; + if (seq == NULL) + return NULL; + assert(ApgRecord_CheckExact(seq)); + + if (it->it_index < Py_SIZE(seq)) { + item = ApgRecord_GET_ITEM(seq, it->it_index); + ++it->it_index; + Py_INCREF(item); + return item; + } + + it->it_seq = NULL; + Py_DECREF(seq); + return NULL; +} + + +static PyObject * +record_iter_len(ApgRecordIterObject *it) +{ + Py_ssize_t len = 0; + if (it->it_seq) { + len = Py_SIZE(it->it_seq) - it->it_index; + } + return PyLong_FromSsize_t(len); +} + + +PyDoc_STRVAR(record_iter_len_doc, + "Private method returning an estimate of len(list(it))."); + + +static PyMethodDef record_iter_methods[] = { + {"__length_hint__", (PyCFunction)record_iter_len, METH_NOARGS, + record_iter_len_doc}, + {NULL, NULL} /* sentinel */ +}; + + +PyTypeObject ApgRecordIter_Type = { + PyVarObject_HEAD_INIT(NULL, 0) + "RecordIterator", /* tp_name */ + sizeof(ApgRecordIterObject), /* tp_basicsize */ + 0, /* tp_itemsize */ + /* methods */ + (destructor)record_iter_dealloc, /* tp_dealloc */ + 0, /* tp_print */ + 0, /* tp_getattr */ + 0, /* tp_setattr */ + 0, /* tp_reserved */ + 0, /* tp_repr */ + 0, /* tp_as_number */ + 0, /* tp_as_sequence */ + 0, /* tp_as_mapping */ + 0, /* tp_hash */ + 0, /* tp_call */ + 0, /* tp_str */ + PyObject_GenericGetAttr, /* tp_getattro */ + 0, /* tp_setattro */ + 0, /* tp_as_buffer */ + Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC, /* tp_flags */ + 0, /* tp_doc */ + (traverseproc)record_iter_traverse, /* tp_traverse */ + 0, /* tp_clear */ + 0, /* tp_richcompare */ + 0, /* tp_weaklistoffset */ + PyObject_SelfIter, /* tp_iter */ + (iternextfunc)record_iter_next, /* tp_iternext */ + record_iter_methods, /* tp_methods */ + 0, +}; + + +static PyObject * +record_iter(PyObject *seq) +{ + ApgRecordIterObject *it; + + if (!ApgRecord_CheckExact(seq)) { + PyErr_BadInternalCall(); + return NULL; + } + it = PyObject_GC_New(ApgRecordIterObject, &ApgRecordIter_Type); + if (it == NULL) + return NULL; + it->it_index = 0; + Py_INCREF(seq); + it->it_seq = (ApgRecordObject *)seq; + PyObject_GC_Track(it); + return (PyObject *)it; +} + + +/* Record Items Iterator */ + + +typedef struct { + PyObject_HEAD + Py_ssize_t it_index; + PyObject *it_map_iter; + ApgRecordObject *it_seq; /* Set to NULL when iterator is exhausted */ +} ApgRecordItemsObject; + + +static void +record_items_dealloc(ApgRecordItemsObject *it) +{ + PyObject_GC_UnTrack(it); + Py_CLEAR(it->it_map_iter); + Py_CLEAR(it->it_seq); + PyObject_GC_Del(it); +} + + +static int +record_items_traverse(ApgRecordItemsObject *it, visitproc visit, void *arg) +{ + Py_VISIT(it->it_map_iter); + Py_VISIT(it->it_seq); + return 0; +} + + +static PyObject * +record_items_next(ApgRecordItemsObject *it) +{ + ApgRecordObject *seq; + PyObject *key; + PyObject *val; + PyObject *tup; + + assert(it != NULL); + seq = it->it_seq; + if (seq == NULL) { + return NULL; + } + assert(ApgRecord_CheckExact(seq)); + assert(it->it_map_iter != NULL); + + key = PyIter_Next(it->it_map_iter); + if (key == NULL) { + /* likely it_map_iter had less items than seq has values */ + goto exhausted; + } + + if (it->it_index < Py_SIZE(seq)) { + val = ApgRecord_GET_ITEM(seq, it->it_index); + ++it->it_index; + Py_INCREF(val); + } + else { + /* it_map_iter had more items than seq has values */ + Py_DECREF(key); + goto exhausted; + } + + tup = PyTuple_New(2); + if (tup == NULL) { + Py_DECREF(val); + Py_DECREF(key); + goto exhausted; + } + + PyTuple_SET_ITEM(tup, 0, key); + PyTuple_SET_ITEM(tup, 1, val); + return tup; + +exhausted: + Py_CLEAR(it->it_map_iter); + Py_CLEAR(it->it_seq); + return NULL; +} + + +static PyObject * +record_items_len(ApgRecordItemsObject *it) +{ + Py_ssize_t len = 0; + if (it->it_seq) { + len = Py_SIZE(it->it_seq) - it->it_index; + } + return PyLong_FromSsize_t(len); +} + + +PyDoc_STRVAR(record_items_len_doc, + "Private method returning an estimate of len(list(it()))."); + + +static PyMethodDef record_items_methods[] = { + {"__length_hint__", (PyCFunction)record_items_len, METH_NOARGS, + record_items_len_doc}, + {NULL, NULL} /* sentinel */ +}; + + +PyTypeObject ApgRecordItems_Type = { + PyVarObject_HEAD_INIT(NULL, 0) + "RecordItemsIterator", /* tp_name */ + sizeof(ApgRecordItemsObject), /* tp_basicsize */ + 0, /* tp_itemsize */ + /* methods */ + (destructor)record_items_dealloc, /* tp_dealloc */ + 0, /* tp_print */ + 0, /* tp_getattr */ + 0, /* tp_setattr */ + 0, /* tp_reserved */ + 0, /* tp_repr */ + 0, /* tp_as_number */ + 0, /* tp_as_sequence */ + 0, /* tp_as_mapping */ + 0, /* tp_hash */ + 0, /* tp_call */ + 0, /* tp_str */ + PyObject_GenericGetAttr, /* tp_getattro */ + 0, /* tp_setattro */ + 0, /* tp_as_buffer */ + Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC, /* tp_flags */ + 0, /* tp_doc */ + (traverseproc)record_items_traverse, /* tp_traverse */ + 0, /* tp_clear */ + 0, /* tp_richcompare */ + 0, /* tp_weaklistoffset */ + PyObject_SelfIter, /* tp_iter */ + (iternextfunc)record_items_next, /* tp_iternext */ + record_items_methods, /* tp_methods */ + 0, +}; + + +static PyObject * +record_new_items_iter(PyObject *seq) +{ + ApgRecordItemsObject *it; + PyObject *map_iter; + + if (!ApgRecord_CheckExact(seq)) { + PyErr_BadInternalCall(); + return NULL; + } + + map_iter = PyObject_GetIter(((ApgRecordObject*)seq)->desc->mapping); + if (map_iter == NULL) { + return NULL; + } + + it = PyObject_GC_New(ApgRecordItemsObject, &ApgRecordItems_Type); + if (it == NULL) + return NULL; + + it->it_map_iter = map_iter; + it->it_index = 0; + Py_INCREF(seq); + it->it_seq = (ApgRecordObject *)seq; + PyObject_GC_Track(it); + + return (PyObject *)it; +} + + +int ApgRecord_InitTypes(void) +{ + if (PyType_Ready(&ApgRecord_Type) < 0) { + return -1; + } + + if (PyType_Ready(&ApgRecordDesc_Type) < 0) { + return -1; + } + + if (PyType_Ready(&ApgRecordIter_Type) < 0) { + return -1; + } + + if (PyType_Ready(&ApgRecordItems_Type) < 0) { + return -1; + } + + return 0; +} + + +/* ----------------- */ + + +static void +record_desc_dealloc(ApgRecordDescObject *o) +{ + PyObject_GC_UnTrack(o); + Py_CLEAR(o->mapping); + Py_CLEAR(o->keys); + PyObject_GC_Del(o); +} + + +static int +record_desc_traverse(ApgRecordDescObject *o, visitproc visit, void *arg) +{ + Py_VISIT(o->mapping); + Py_VISIT(o->keys); + return 0; +} + + +PyTypeObject ApgRecordDesc_Type = { + PyVarObject_HEAD_INIT(NULL, 0) + "RecordDescriptor", /* tp_name */ + sizeof(ApgRecordDescObject), /* tp_basicsize */ + 0, /* tp_itemsize */ + /* methods */ + (destructor)record_desc_dealloc, /* tp_dealloc */ + 0, /* tp_print */ + 0, /* tp_getattr */ + 0, /* tp_setattr */ + 0, /* tp_reserved */ + 0, /* tp_repr */ + 0, /* tp_as_number */ + 0, /* tp_as_sequence */ + 0, /* tp_as_mapping */ + 0, /* tp_hash */ + 0, /* tp_call */ + 0, /* tp_str */ + PyObject_GenericGetAttr, /* tp_getattro */ + 0, /* tp_setattro */ + 0, /* tp_as_buffer */ + Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC, /* tp_flags */ + 0, /* tp_doc */ + (traverseproc)record_desc_traverse, /* tp_traverse */ + 0, /* tp_clear */ + 0, /* tp_richcompare */ + 0, /* tp_weaklistoffset */ + PyObject_SelfIter, /* tp_iter */ + 0, /* tp_iternext */ + 0, /* tp_methods */ + 0, +}; + + +PyObject * +ApgRecordDesc_New(PyObject *mapping, PyObject *keys) +{ + ApgRecordDescObject *o; + + if (!mapping || !keys || !PyTuple_CheckExact(keys)) { + PyErr_BadInternalCall(); + return NULL; + } + + o = PyObject_GC_New(ApgRecordDescObject, &ApgRecordDesc_Type); + if (o == NULL) { + return NULL; + } + + Py_INCREF(mapping); + o->mapping = mapping; + + Py_INCREF(keys); + o->keys = keys; + + PyObject_GC_Track(o); + return (PyObject *) o; +} diff --git a/asyncpg/protocol/record/recordobj.h b/asyncpg/protocol/record/recordobj.h new file mode 100644 index 0000000..c64cbc6 --- /dev/null +++ b/asyncpg/protocol/record/recordobj.h @@ -0,0 +1,52 @@ +#ifndef APG_RECORDOBJ_H +#define APG_RECORDOBJ_H + +#include "Python.h" + + +/* Largest record to save on free list */ +#define ApgRecord_MAXSAVESIZE 20 + +/* Maximum number of records of each size to save */ +#define ApgRecord_MAXFREELIST 2000 + + +typedef struct { + PyObject_HEAD + PyObject *mapping; + PyObject *keys; +} ApgRecordDescObject; + + +typedef struct { + PyObject_VAR_HEAD + Py_hash_t self_hash; + ApgRecordDescObject *desc; + PyObject *ob_item[1]; + + /* ob_item contains space for 'ob_size' elements. + * Items must normally not be NULL, except during construction when + * the record is not yet visible outside the function that builds it. + */ +} ApgRecordObject; + + +extern PyTypeObject ApgRecord_Type; +extern PyTypeObject ApgRecordIter_Type; +extern PyTypeObject ApgRecordItems_Type; + +extern PyTypeObject ApgRecordDesc_Type; + +#define ApgRecord_CheckExact(o) (Py_TYPE(o) == &ApgRecord_Type) +#define ApgRecordDesc_CheckExact(o) (Py_TYPE(o) == &ApgRecordDesc_Type) + +#define ApgRecord_SET_ITEM(op, i, v) \ + (((ApgRecordObject *)(op))->ob_item[i] = v) +#define ApgRecord_GET_ITEM(op, i) \ + (((ApgRecordObject *)(op))->ob_item[i]) + +int ApgRecord_InitTypes(void); +PyObject * ApgRecord_New(PyObject *, Py_ssize_t); +PyObject * ApgRecordDesc_New(PyObject *, PyObject *); + +#endif diff --git a/asyncpg/protocol/settings.pxd b/asyncpg/protocol/settings.pxd new file mode 100644 index 0000000..b50fe14 --- /dev/null +++ b/asyncpg/protocol/settings.pxd @@ -0,0 +1,25 @@ +# Copyright (C) 2016-present the ayncpg authors and contributors +# +# +# This module is part of asyncpg and is released under +# the Apache 2.0 License: http://www.apache.org/licenses/LICENSE-2.0 + + +cdef class ConnectionSettings: + cdef: + str _encoding + object _codec + dict _settings + bint _is_utf8 + DataCodecConfig _data_codecs + + cdef add_setting(self, str name, str val) + cdef inline is_encoding_utf8(self) + cpdef inline get_text_codec(self) + cpdef inline register_data_types(self, types) + cpdef inline add_python_codec( + self, typeoid, typename, typeschema, typekind, encoder, + decoder, binary) + cpdef inline set_builtin_type_codec( + self, typeoid, typename, typeschema, typekind, alias_to) + cpdef inline Codec get_data_codec(self, uint32_t oid, CodecFormat format=*) diff --git a/asyncpg/protocol/settings.pyx b/asyncpg/protocol/settings.pyx new file mode 100644 index 0000000..9360c45 --- /dev/null +++ b/asyncpg/protocol/settings.pyx @@ -0,0 +1,62 @@ +# Copyright (C) 2016-present the ayncpg authors and contributors +# +# +# This module is part of asyncpg and is released under +# the Apache 2.0 License: http://www.apache.org/licenses/LICENSE-2.0 + + +@cython.final +cdef class ConnectionSettings: + + def __cinit__(self, conn_key): + self._encoding = 'utf-8' + self._is_utf8 = True + self._settings = {} + self._codec = codecs.lookup('utf-8') + self._data_codecs = DataCodecConfig(conn_key) + + cdef add_setting(self, str name, str val): + self._settings[name] = val + if name == 'client_encoding': + py_enc = get_python_encoding(val) + self._codec = codecs.lookup(py_enc) + self._encoding = self._codec.name + self._is_utf8 = self._encoding == 'utf-8' + + cdef inline is_encoding_utf8(self): + return self._is_utf8 + + cpdef inline get_text_codec(self): + return self._codec + + cpdef inline register_data_types(self, types): + self._data_codecs.add_types(types) + + cpdef inline add_python_codec(self, typeoid, typename, typeschema, + typekind, encoder, decoder, binary): + self._data_codecs.add_python_codec(typeoid, typename, typeschema, + typekind, encoder, decoder, binary) + + cpdef inline set_builtin_type_codec(self, typeoid, typename, typeschema, + typekind, alias_to): + self._data_codecs.set_builtin_type_codec(typeoid, typename, typeschema, + typekind, alias_to) + + cpdef inline Codec get_data_codec(self, uint32_t oid, + CodecFormat format=PG_FORMAT_ANY): + if format == PG_FORMAT_ANY: + codec = self._data_codecs.get_codec(oid, PG_FORMAT_BINARY) + if codec is None: + codec = self._data_codecs.get_codec(oid, PG_FORMAT_TEXT) + return codec + else: + return self._data_codecs.get_codec(oid, format) + + def __getattr__(self, name): + if not name.startswith('_'): + try: + return self._settings[name] + except KeyError: + raise AttributeError(name) from None + + return object.__getattr__(self, name) diff --git a/asyncpg/serverversion.py b/asyncpg/serverversion.py new file mode 100644 index 0000000..2e31031 --- /dev/null +++ b/asyncpg/serverversion.py @@ -0,0 +1,33 @@ +# Copyright (C) 2016-present the ayncpg authors and contributors +# +# +# This module is part of asyncpg and is released under +# the Apache 2.0 License: http://www.apache.org/licenses/LICENSE-2.0 + + +from . import types + + +def split_server_version_string(version_string): + version_string = version_string.strip() + if version_string.startswith('PostgreSQL '): + version_string = version_string[len('PostgreSQL '):] + + parts = version_string.strip().split('.') + if not parts[-1].isdigit(): + # release level specified + level = parts[-1].rstrip('0123456789').lower() + serial = parts[-1][level:] + versions = [int(p) for p in parts[:-1]][:3] + else: + level = 'final' + serial = 0 + versions = [int(p) for p in parts][:3] + + if len(versions) < 3: + versions += [0] * (3 - len(versions)) + + versions.append(level) + versions.append(serial) + + return types.ServerVersion(*versions) diff --git a/asyncpg/transaction.py b/asyncpg/transaction.py new file mode 100644 index 0000000..edbdeec --- /dev/null +++ b/asyncpg/transaction.py @@ -0,0 +1,212 @@ +# Copyright (C) 2016-present the ayncpg authors and contributors +# +# +# This module is part of asyncpg and is released under +# the Apache 2.0 License: http://www.apache.org/licenses/LICENSE-2.0 + + +import enum + +from . import exceptions as apg_errors + + +class TransactionState(enum.Enum): + NEW = 0 + STARTED = 1 + COMMITTED = 2 + ROLLEDBACK = 3 + FAILED = 4 + + +ISOLATION_LEVELS = {'read_committed', 'serializable', 'repeatable_read'} + + +class Transaction: + """Represents a transaction or savepoint block. + + Transactions are created by calling the + :meth:`Connection.transaction() ` + function. + """ + + __slots__ = ('_connection', '_isolation', '_readonly', '_deferrable', + '_state', '_nested', '_id', '_managed') + + def __init__(self, connection, isolation, readonly, deferrable): + if isolation not in ISOLATION_LEVELS: + raise ValueError( + 'isolation is expected to be either of {}, ' + 'got {!r}'.format(ISOLATION_LEVELS, isolation)) + + if isolation != 'serializable': + if readonly: + raise ValueError( + '"readonly" is only supported for ' + 'serializable transactions') + + if deferrable and not readonly: + raise ValueError( + '"deferrable" is only supported for ' + 'serializable readonly transactions') + + self._connection = connection + self._isolation = isolation + self._readonly = readonly + self._deferrable = deferrable + self._state = TransactionState.NEW + self._nested = False + self._id = None + self._managed = False + + async def __aenter__(self): + if self._managed: + raise apg_errors.InterfaceError( + 'cannot enter context: already in an `async with` block') + self._managed = True + await self.start() + + async def __aexit__(self, extype, ex, tb): + try: + if extype is not None: + await self.__rollback() + else: + await self.__commit() + finally: + self._managed = False + + async def start(self): + """Enter the transaction or savepoint block.""" + self.__check_state_base('start') + if self._state is TransactionState.STARTED: + raise apg_errors.InterfaceError( + 'cannot start; the transaction is already started') + + con = self._connection + + if con._top_xact is None: + con._top_xact = self + else: + # Nested transaction block + top_xact = con._top_xact + if self._isolation != top_xact._isolation: + raise apg_errors.InterfaceError( + 'nested transaction has a different isolation level: ' + 'current {!r} != outer {!r}'.format( + self._isolation, top_xact._isolation)) + self._nested = True + + if self._nested: + self._id = con._get_unique_id() + query = 'SAVEPOINT {};'.format(self._id) + else: + if self._isolation == 'read_committed': + query = 'BEGIN;' + elif self._isolation == 'repeatable_read': + query = 'BEGIN ISOLATION LEVEL REPEATABLE READ;' + else: + query = 'BEGIN ISOLATION LEVEL SERIALIZABLE' + if self._readonly: + query += ' READ ONLY' + if self._deferrable: + query += ' DEFERRABLE' + query += ';' + + try: + await self._connection.execute(query) + except: + self._state = TransactionState.FAILED + raise + else: + self._state = TransactionState.STARTED + + def __check_state_base(self, opname): + if self._state is TransactionState.COMMITTED: + raise apg_errors.InterfaceError( + 'cannot {}; the transaction is already committed'.format( + opname)) + if self._state is TransactionState.ROLLEDBACK: + raise apg_errors.InterfaceError( + 'cannot {}; the transaction is already rolled back'.format( + opname)) + if self._state is TransactionState.FAILED: + raise apg_errors.InterfaceError( + 'cannot {}; the transaction is in error state'.format( + opname)) + + def __check_state(self, opname): + if self._state is not TransactionState.STARTED: + if self._state is TransactionState.NEW: + raise apg_errors.InterfaceError( + 'cannot {}; the transaction is not yet started'.format( + opname)) + self.__check_state_base(opname) + + async def __commit(self): + self.__check_state('commit') + + if self._connection._top_xact is self: + self._connection._top_xact = None + + if self._nested: + query = 'RELEASE SAVEPOINT {};'.format(self._id) + else: + query = 'COMMIT;' + + try: + await self._connection.execute(query) + except: + self._state = TransactionState.FAILED + raise + else: + self._state = TransactionState.COMMITTED + + async def __rollback(self): + self.__check_state('rollback') + + if self._connection._top_xact is self: + self._connection._top_xact = None + + if self._nested: + query = 'ROLLBACK TO {};'.format(self._id) + else: + query = 'ROLLBACK;' + + try: + await self._connection.execute(query) + except: + self._state = TransactionState.FAILED + raise + else: + self._state = TransactionState.ROLLEDBACK + + async def commit(self): + """Exit the transaction or savepoint block and commit changes.""" + if self._managed: + raise apg_errors.InterfaceError( + 'cannot manually commit from within an `async with` block') + await self.__commit() + + async def rollback(self): + """Exit the transaction or savepoint block and rollback changes.""" + if self._managed: + raise apg_errors.InterfaceError( + 'cannot manually rollback from within an `async with` block') + await self.__rollback() + + def __repr__(self): + attrs = [] + attrs.append('state:{}'.format(self._state.name.lower())) + + attrs.append(self._isolation) + if self._readonly: + attrs.append('readonly') + if self._deferrable: + attrs.append('deferrable') + + if self.__class__.__module__.startswith('asyncpg.'): + mod = 'asyncpg' + else: + mod = self.__class__.__module__ + + return '<{}.{} {} {:#x}>'.format( + mod, self.__class__.__name__, ' '.join(attrs), id(self)) diff --git a/asyncpg/types.py b/asyncpg/types.py new file mode 100644 index 0000000..b2a8e46 --- /dev/null +++ b/asyncpg/types.py @@ -0,0 +1,417 @@ +# Copyright (C) 2016-present the ayncpg authors and contributors +# +# +# This module is part of asyncpg and is released under +# the Apache 2.0 License: http://www.apache.org/licenses/LICENSE-2.0 + + +import collections + + +__all__ = ( + 'Type', 'Attribute', 'Range', 'BitString', 'Point', 'Path', 'Polygon', + 'Box', 'Line', 'LineSegment', 'Circle', 'ServerVersion' +) + + +Type = collections.namedtuple('Type', ['oid', 'name', 'kind', 'schema']) +Type.__doc__ = 'Database data type.' +Type.oid.__doc__ = 'OID of the type.' +Type.name.__doc__ = 'Type name. For example "int2".' +Type.kind.__doc__ = \ + 'Type kind. Can be "scalar", "array", "composite" or "range".' +Type.schema.__doc__ = 'Name of the database schema that defines the type.' + + +Attribute = collections.namedtuple('Attribute', ['name', 'type']) +Attribute.__doc__ = 'Database relation attribute.' +Attribute.name.__doc__ = 'Attribute name.' +Attribute.type.__doc__ = 'Attribute data type :class:`asyncpg.types.Type`.' + + +ServerVersion = collections.namedtuple( + 'ServerVersion', ['major', 'minor', 'micro', 'releaselevel', 'serial']) +ServerVersion.__doc__ = 'PostgreSQL server version tuple.' + + +class Range: + """Immutable representation of PostgreSQL `range` type.""" + + __slots__ = '_lower', '_upper', '_lower_inc', '_upper_inc', '_empty' + + def __init__(self, lower=None, upper=None, *, + lower_inc=True, upper_inc=False, + empty=False): + self._empty = empty + if empty: + self._lower = self._upper = None + self._lower_inc = self._upper_inc = False + else: + self._lower = lower + self._upper = upper + self._lower_inc = lower is not None and lower_inc + self._upper_inc = upper is not None and upper_inc + + @property + def lower(self): + return self._lower + + @property + def lower_inc(self): + return self._lower_inc + + @property + def lower_inf(self): + return self._lower is None and not self._empty + + @property + def upper(self): + return self._upper + + @property + def upper_inc(self): + return self._upper_inc + + @property + def upper_inf(self): + return self._upper is None and not self._empty + + @property + def isempty(self): + return self._empty + + def __bool__(self): + return not self._empty + + def __eq__(self, other): + if not isinstance(other, Range): + return NotImplemented + + return ( + self._lower, + self._upper, + self._lower_inc, + self._upper_inc, + self._empty + ) == ( + other._lower, + other._upper, + other._lower_inc, + other._upper_inc, + other._empty + ) + + def __hash__(self, other): + return hash(( + self._lower, + self._upper, + self._lower_inc, + self._upper_inc, + self._empty + )) + + def __repr__(self): + if self._empty: + desc = 'empty' + else: + if self._lower is None or not self._lower_inc: + lb = '(' + else: + lb = '[' + + if self._lower is not None: + lb += repr(self._lower) + + if self._upper is not None: + ub = repr(self._upper) + else: + ub = '' + + if self._upper is None or not self._upper_inc: + ub += ')' + else: + ub += ']' + + desc = '{}, {}'.format(lb, ub) + + return ''.format(desc) + + __str__ = __repr__ + + +class BitString: + """Immutable representation of PostgreSQL `bit` and `varbit` types.""" + + __slots__ = '_bytes', '_bitlength' + + def __init__(self, bitstring=None): + if not bitstring: + self._bytes = bytes() + self._bitlength = 0 + else: + bytelen = len(bitstring) // 8 + 1 + bytes_ = bytearray(bytelen) + byte = 0 + byte_pos = 0 + bit_pos = 0 + + for i, bit in enumerate(bitstring): + if bit == ' ': + continue + bit = int(bit) + if bit != 0 and bit != 1: + raise ValueError( + 'invalid bit value at position {}'.format(i)) + + byte |= bit << (8 - bit_pos - 1) + bit_pos += 1 + if bit_pos == 8: + bytes_[byte_pos] = byte + byte = 0 + byte_pos += 1 + bit_pos = 0 + + if bit_pos != 0: + bytes_[byte_pos] = byte + + bitlen = byte_pos * 8 + bit_pos + bytelen = byte_pos + (1 if bit_pos else 0) + + self._bytes = bytes(bytes_[:bytelen]) + self._bitlength = bitlen + + @classmethod + def frombytes(cls, bytes_=None, bitlength=None): + if bitlength is None and bytes_ is None: + bytes_ = bytes() + bitlength = 0 + + elif bitlength is None: + bitlength = len(bytes_) * 8 + + else: + if bytes_ is None: + bytes_ = bytes(bitlength // 8 + 1) + bitlength = bitlength + else: + bytes_len = len(bytes_) * 8 + + if bytes_len == 0 and bitlength != 0: + raise ValueError('invalid bit length specified') + + if bytes_len != 0 and bitlength == 0: + raise ValueError('invalid bit length specified') + + if bitlength < bytes_len - 8: + raise ValueError('invalid bit length specified') + + if bitlength > bytes_len: + raise ValueError('invalid bit length specified') + + result = cls() + result._bytes = bytes_ + result._bitlength = bitlength + + return result + + @property + def bytes(self): + return self._bytes + + def as_string(self): + s = '' + + for i in range(self._bitlength): + s += str(self._getitem(i)) + if i % 4 == 3: + s += ' ' + + return s.strip() + + def __repr__(self): + return ''.format(self.as_string()) + + __str__ = __repr__ + + def __eq__(self, other): + if not isinstance(other, BitString): + return NotImplemented + + return (self._bytes == other._bytes and + self._bitlength == other._bitlength) + + def __hash__(self): + return hash((self._bytes, self._bitlength)) + + def _getitem(self, i): + byte = self._bytes[i // 8] + shift = 8 - i % 8 - 1 + return (byte >> shift) & 0x1 + + def __getitem__(self, i): + if isinstance(i, slice): + raise NotImplementedError('BitString does not support slices') + + if i >= self._bitlength: + raise IndexError('index out of range') + + return self._getitem(i) + + def __len__(self): + return self._bitlength + + +class Point(tuple): + """Immutable representation of PostgreSQL `point` type.""" + + __slots__ = () + + def __new__(cls, x, y): + return super().__new__(cls, (float(x), float(y))) + + def __repr__(self): + return '{}.{}({})'.format( + type(self).__module__, + type(self).__name__, + tuple.__repr__(self) + ) + + @property + def x(self): + return self[0] + + @property + def y(self): + return self[1] + + +class Box(tuple): + """Immutable representation of PostgreSQL `box` type.""" + + __slots__ = () + + def __new__(cls, high, low): + return super().__new__(cls, (Point(*high), Point(*low))) + + def __repr__(self): + return '{}.{}({})'.format( + type(self).__module__, + type(self).__name__, + tuple.__repr__(self) + ) + + @property + def high(self): + return self[0] + + @property + def low(self): + return self[1] + + +class Line(tuple): + """Immutable representation of PostgreSQL `line` type.""" + + __slots__ = () + + def __new__(cls, A, B, C): + return super().__new__(cls, (A, B, C)) + + @property + def A(self): + return self[0] + + @property + def B(self): + return self[1] + + @property + def C(self): + return self[2] + + +class LineSegment(tuple): + """Immutable representation of PostgreSQL `lseg` type.""" + + __slots__ = () + + def __new__(cls, p1, p2): + return super().__new__(cls, (Point(*p1), Point(*p2))) + + def __repr__(self): + return '{}.{}({})'.format( + type(self).__module__, + type(self).__name__, + tuple.__repr__(self) + ) + + @property + def p1(self): + return self[0] + + @property + def p2(self): + return self[1] + + +class Path: + """Immutable representation of PostgreSQL `path` type.""" + + __slots__ = '_is_closed', 'points' + + def __init__(self, *points, is_closed=False): + self.points = tuple(Point(*p) for p in points) + self._is_closed = is_closed + + @property + def is_closed(self): + return self._is_closed + + def __eq__(self, other): + if not isinstance(other, Path): + return NotImplemented + + return (self.points == other.points and + self._is_closed == other._is_closed) + + def __hash__(self): + return hash((self.points, self.is_closed)) + + def __iter__(self): + return iter(self.points) + + def __len__(self): + return len(self.points) + + def __getitem__(self, i): + return self.points[i] + + def __contains__(self, point): + return point in self.points + + +class Polygon(Path): + """Immutable representation of PostgreSQL `polygon` type.""" + + __slots__ = () + + def __init__(self, *points): + # polygon is always closed + super().__init__(*points, is_closed=True) + + +class Circle(tuple): + """Immutable representation of PostgreSQL `circle` type.""" + + __slots__ = () + + def __new__(cls, center, radius): + return super().__new__(cls, (center, radius)) + + @property + def center(self): + return self[0] + + @property + def radius(self): + return self[1] diff --git a/docs/api/index.rst b/docs/api/index.rst new file mode 100644 index 0000000..43486bd --- /dev/null +++ b/docs/api/index.rst @@ -0,0 +1,329 @@ +.. _asyncpg-api-reference: + +============= +API Reference +============= + +.. module:: asyncpg + :synopsis: A fast PostgreSQL Database Client Library for Python/asyncio + +.. currentmodule:: asyncpg + + +.. _asyncpg-api-connection: + +Connection +========== + +.. autofunction:: asyncpg.connection.connect + + +.. autoclass:: asyncpg.connection.Connection + :members: + + +.. _asyncpg-api-prepared-stmt: + +Prepared Statements +=================== + +Prepared statements are a PostgreSQL feature that can be used to optimize the +performance of queries that are executed more than once. When a query +is *prepared* by a call to :meth:`Connection.prepare`, the server parses, +analyzes and compiles the query allowing to reuse that work once there is +a need to run the same query again. + +.. code-block:: pycon + + >>> import asyncpg, asyncio + >>> loop = asyncio.get_event_loop() + >>> async def run(): + ... conn = await asyncpg.connect() + ... stmt = await conn.prepare('''SELECT 2 ^ $1''') + ... print(await stmt.fetchval(10)) + ... print(await stmt.fetchval(20)) + ... + >>> loop.run_until_complete(run()) + 1024.0 + 1048576.0 + +.. note:: + + asyncpg automatically maintains a small LRU cache for queries executed + during calls to the :meth:`~Connection.fetch`, :meth:`~Connection.fetchrow`, + or :meth:`~Connection.fetchval` methods. + + +.. autoclass:: asyncpg.prepared_stmt.PreparedStatement() + :members: + + +.. _asyncpg-api-transaction: + +Transactions +============ + +The most common way to use transactions is through an ``async with`` statement: + +.. code-block:: python + + async with connection.transaction(): + await connection.execute("INSERT INTO mytable VALUES(1, 2, 3)") + + +asyncpg supports nested transactions (a nested transaction context will create +a `savepoint`_.): + +.. code-block:: python + + async with connection.transaction(): + await connection.execute('CREATE TABLE mytab (a int)') + + try: + # Create a nested transaction: + async with connection.transaction(): + await connection.execute('INSERT INTO mytab (a) VALUES (1), (2)') + # This nested transaction will be automatically rolled back: + raise Exception + except: + # Ignore exception + pass + + # Because the nested transaction was rolled back, there + # will be nothing in `mytab`. + assert await connection.fetch('SELECT a FROM mytab') == [] + +Alternatively, transactions can be used without an ``async with`` block: + +.. code-block:: python + + tr = connection.transaction() + await tr.start() + try: + ... + except: + await tr.rollback() + raise + finally: + await tr.commit() + + +See also the +:meth:`Connection.transaction() ` +function. + +.. _savepoint: https://www.postgresql.org/docs/current/static/sql-savepoint.html + + +.. autoclass:: asyncpg.transaction.Transaction() + :members: + + .. describe:: async with c: + + start and commit/rollback the transaction or savepoint block + automatically when entering and exiting the code inside the + context manager block. + + +.. _asyncpg-api-cursor: + +Cursors +======= + +Cursors are useful when there is a need to iterate over the results of +a large query without fetching all rows at once. The cursor interface +provided by asyncpg supports *asynchronous iteration* via the ``async for`` +statement, and also a way to read row chunks and skip forward over the +result set. + +To iterate over a cursor using a connection object use +:meth:`Connection.cursor() `. +To make the iteration efficient, the cursor will prefetch records to +reduce the number of queries sent to the server: + +.. code-block:: python + + async def iterate(con: Connection): + async with con.transaction(): + # Postgres requires non-scrollable cursors to be created + # and used in a transaction. + async for record in con.cursor('SELECT generate_series(0, 100)'): + print(record) + +Or, alternatively, you can iterate over the cursor manually (cursor +won't be prefetching any rows): + +.. code-block:: python + + async def iterate(con: Connection): + async with con.transaction(): + # Postgres requires non-scrollable cursors to be created + # and used in a transaction. + + async with con.transaction(): + # Create a Cursor object + cur = await con.cursor('SELECT generate_series(0, 100)') + + # Move the cursor 10 rows forward + await cur.forward(10) + + # Fetch one row and print it + print(await cur.fetchrow()) + + # Fetch a list of 5 rows and print it + print(await cur.fetch(5)) + +It's also possible to create cursors from prepared statements: + +.. code-block:: python + + async def iterate(con: Connection): + # Create a prepared statement that will accept one argument + stmt = await con.prepare('SELECT generate_series(0, $1)') + + async with con.transaction(): + # Postgres requires non-scrollable cursors to be created + # and used in a transaction. + + # Execute the prepared statement passing `10` as the + # argument -- that will generate a series or records + # from 0..10. Iterate over all of them and print every + # record. + async for record in stmt.cursor(10): + print(record) + + +.. note:: + + Cursors created by a call to + :meth:`Connection.cursor() ` or + :meth:`PreparedStatement.cursor() ` + are *non-scrollable*: they can only be read forwards. To create a scrollable + cursor, use the ``DECLARE ... SCROLL CURSOR`` SQL statement directly. + +.. warning:: + + Cursors created by a call to + :meth:`Connection.cursor() ` or + :meth:`PreparedStatement.cursor() ` + cannot be used outside of a transaction. Any such attempt will result in + :exc:`~asyncpg.exceptions.InterfaceError`. + + To create a cursor usable outside of a transaction, use the + ``DECLARE ... CURSOR WITH HOLD`` SQL statement directly. + + +.. autoclass:: asyncpg.cursor.CursorFactory() + :members: + + .. describe:: async for row in c + + Execute the statement and iterate over the results asynchronously. + + .. describe:: await c + + Execute the statement and return an instance of + :class:`~asyncpg.cursor.Cursor` which can be used to navigate over and + fetch subsets of the query results. + + +.. autoclass:: asyncpg.cursor.Cursor() + :members: + + +.. _asyncpg-api-pool: + +Connection Pool +=============== + +.. autofunction:: asyncpg.pool.create_pool + + +.. autoclass:: asyncpg.pool.Pool() + :members: + + +.. _asyncpg-api-record: + +Record Objects +============== + +Each row (or composite type value) returned by calls to ``fetch*`` methods +is represented by an instance of the ``Record`` object. ``Record`` objects +are similar to instances of ``collections.namedtuple`` and allow addressing +of values either by a numeric index or by a field name: + +.. code-block:: pycon + + >>> import asyncpg + >>> import asyncio + >>> loop = asyncio.get_event_loop() + >>> conn = loop.run_until_complete(asyncpg.connect()) + >>> r = loop.run_until_complete(conn.fetchrow(''' + ... SELECT oid, rolname, rolsuper FROM pg_roles WHERE rolname = user''')) + >>> r + + >>> r['oid'] + 16388 + >>> r[0] + 16388 + + +.. class:: Record() + + A read-only representation of PostgreSQL row. + + .. describe:: len(r) + + Return the number of fields in record *r*. + + .. describe:: r[field] + + Return the field of *r* with field name or index *field*. + + .. describe:: name in r + + Return ``True`` if record *r* has a field named *name*. + + .. describe:: iter(r) + + Return an iterator over the *values* of the record *r*. + + .. method:: values() + + Return an iterator over the record values. + + .. method:: keys() + + Return an iterator over the record field names. + + .. method:: items() + + Return an iterator over ``(field, value)`` pairs. + + +.. class:: ConnectionSettings() + + A read-only collection of Connection settings. + + .. describe:: settings.setting_name + + Return the value of the "setting_name" setting. Raises an + ``AttributeError`` if the setting is not defined. + + Example: + + .. code-block:: pycon + + >>> connection.get_settings().client_encoding + 'UTF8' + + +Introspection +============= + +.. autoclass:: asyncpg.types.Type() + :members: + +.. autoclass:: asyncpg.types.Attribute() + :members: diff --git a/docs/conf.py b/docs/conf.py new file mode 100644 index 0000000..b25e0e2 --- /dev/null +++ b/docs/conf.py @@ -0,0 +1,93 @@ +#!/usr/bin/env python3 + +import alabaster +import os +import re +import sys + +sys.path.insert(0, os.path.abspath('..')) + +with open(os.path.abspath('../setup.py'), 'rt') as f: + _m = re.search( + r'''VERSION\s*=\s*(?P'|")(?P[\d\.]+)(?P=q)''', f.read()) + if not _m: + raise RuntimeError('unable to read the version from setup.py') + version = _m.group('ver') + + +# -- General configuration ------------------------------------------------ + +extensions = [ + 'sphinx.ext.autodoc', + 'sphinx.ext.doctest', + 'sphinx.ext.viewcode', + 'sphinx.ext.githubpages', + 'sphinxcontrib.asyncio', +] + +add_module_names = False + +templates_path = ['_templates'] +source_suffix = '.rst' +master_doc = 'index' +project = 'asyncpg' +copyright = '2016-present, the ayncpg authors and contributors' +author = '' +release = version +language = None +exclude_patterns = ['_build'] +pygments_style = 'sphinx' +todo_include_todos = False +suppress_warnings = ['image.nonlocal_uri'] + +# -- Options for HTML output ---------------------------------------------- + +html_theme = 'sphinx_rtd_theme' +# html_theme_options = { +# 'description': 'asyncpg is a fast PostgreSQL client library for the ' +# 'Python asyncio framework', +# 'show_powered_by': False, +# } +html_theme_path = [alabaster.get_path()] +html_title = 'asyncpg Documentation' +html_short_title = 'asyncpg' +html_static_path = [] +html_sidebars = { + '**': [ + 'about.html', + 'navigation.html', + ] +} +html_show_sourcelink = False +html_show_sphinx = False +html_show_copyright = True +htmlhelp_basename = 'asyncpgdoc' + + +# -- Options for LaTeX output --------------------------------------------- + +latex_elements = {} + +latex_documents = [ + (master_doc, 'asyncpg.tex', 'asyncpg Documentation', + author, 'manual'), +] + + +# -- Options for manual page output --------------------------------------- + +man_pages = [ + (master_doc, 'asyncpg', 'asyncpg Documentation', + [author], 1) +] + + +# -- Options for Texinfo output ------------------------------------------- + +texinfo_documents = [ + (master_doc, 'asyncpg', 'asyncpg Documentation', + author, 'asyncpg', + 'asyncpg is a fast PostgreSQL client library for the ' + 'Python asyncio framework', + 'Miscellaneous'), +] diff --git a/docs/examples.rst b/docs/examples.rst new file mode 100644 index 0000000..67bf568 --- /dev/null +++ b/docs/examples.rst @@ -0,0 +1,47 @@ +.. _asyncpg-examples: + + +Usage Examples +============== + +Below is an example of how **asyncpg** can be used to implement a simple +Web service that computes the requested power of two. + + +.. code-block:: python + + import asyncio + import asyncpg + from aiohttp import web + + + async def handle(request): + """Handle incoming requests.""" + pool = request.app['pool'] + power = int(request.match_info.get('power', 10)) + + # Take a connection from the pool. + async with pool.acquire() as connection: + # Open a transaction. + async with connection.transaction(): + # Run the query passing the request argument. + result = await connection.fetchval('select 2 ^ $1', power) + return web.Response( + text="2 ^ {} is {}".format(power, result)) + + + async def init_app(): + """Initialize the application server.""" + app = web.Application() + # Create a database connection pool + app['pool'] = await asyncpg.create_pool(database='postgres', + user='postgres') + # Configure service routes + app.router.add_route('GET', '/{power:\d+}', handle) + app.router.add_route('GET', '/', handle) + return app + + + loop = asyncio.get_event_loop() + app = loop.run_until_complete(init_app()) + web.run_app(app) diff --git a/docs/index.rst b/docs/index.rst new file mode 100644 index 0000000..33d61a4 --- /dev/null +++ b/docs/index.rst @@ -0,0 +1,29 @@ +.. image:: https://travis-ci.org/MagicStack/asyncpg.svg?branch=master + :target: https://travis-ci.org/MagicStack/asyncpg + +.. image:: https://img.shields.io/pypi/status/asyncpg.svg?maxAge=2592000?style=plastic + :target: https://pypi.python.org/pypi/asyncpg + + +======= +asyncpg +======= + +**asyncpg** is a database interface library designed specifically for +PostgreSQL and Python/asyncio. asyncpg is an efficient, clean implementation +of PostgreSQL server binary protocol for use with Python's ``asyncio`` +framework. + +**asyncpg** is a C extension and it is only currently compatible with +CPython 3.5. + + +Contents +-------- + +.. toctree:: + :maxdepth: 2 + + installation + examples + api/index diff --git a/docs/installation.rst b/docs/installation.rst new file mode 100644 index 0000000..44c7eb4 --- /dev/null +++ b/docs/installation.rst @@ -0,0 +1,57 @@ +.. _asyncpg-installation: + + +Installation +============ + +**asyncpg** has no external dependencies and the recommended way to +install it is to use **pip**: + +.. code-block:: bash + + $ pip install asyncpg + + +.. note:: + + It is recommended to use **pip** version **8.1** or later to take + advantage of the precompiled wheel packages. Older versions of pip + will ignore the wheel packages and install asyncpg from the source + package. In that case a working C compiler is required. + + +Building from source +-------------------- + +If you want to build **asyncpg** from a Git checkout you will need: + + * A working C compiler. + * CPython header files. These can usually be obtained by installing + the relevant Python development package: **python3-dev** on Debian/Ubuntu, + **python3-devel** on RHEL/Fedora. + * Cython version 0.24 or later. The easiest way to install it to use + virtualenv and pip, however a system package should also suffice. + * GNU make + +Once the above requirements are satisfied, run: + +.. code-block:: bash + + $ make + +At this point you can run the usual ``setup.py`` commands or +``pip install -e .`` to install the newly built version. + +.. note:: + + A debug build can be created by running ``make debug``. + + +Running tests +------------- + +To execute the testsuite simply run: + +.. code-block:: bash + + $ make test diff --git a/performance.png b/performance.png new file mode 100644 index 0000000..14f4cd8 Binary files /dev/null and b/performance.png differ diff --git a/setup.cfg b/setup.cfg new file mode 100644 index 0000000..861a9f5 --- /dev/null +++ b/setup.cfg @@ -0,0 +1,5 @@ +[egg_info] +tag_build = +tag_date = 0 +tag_svn_revision = 0 + diff --git a/setup.py b/setup.py new file mode 100644 index 0000000..94e7c5f --- /dev/null +++ b/setup.py @@ -0,0 +1,213 @@ +# Copyright (C) 2016-present the ayncpg authors and contributors +# +# +# This module is part of asyncpg and is released under +# the Apache 2.0 License: http://www.apache.org/licenses/LICENSE-2.0 + + +import os +import os.path +import platform +import re +import sys +import unittest + +import setuptools +from setuptools.command import build_ext as _build_ext + + +if sys.version_info < (3, 5): + raise RuntimeError('asyncpg requires Python 3.5 or greater') + +VERSION = '0.8.4' +CFLAGS = ['-O2'] +LDFLAGS = [] + +if platform.uname().system == 'Windows': + LDFLAGS.append('ws2_32.lib') +else: + CFLAGS.extend(['-Wall', '-Wsign-compare', '-Wconversion']) + + +def discover_tests(): + test_loader = unittest.TestLoader() + test_suite = test_loader.discover('tests', pattern='test_*.py') + return test_suite + + +class build_ext(_build_ext.build_ext): + user_options = _build_ext.build_ext.user_options + [ + ('cython-always', None, + 'run cythonize() even if .c files are present'), + ('cython-annotate', None, + 'Produce a colorized HTML version of the Cython source.'), + ('cython-directives=', None, + 'Cythion compiler directives'), + ] + + def initialize_options(self): + super(build_ext, self).initialize_options() + self.cython_always = False + self.cython_annotate = None + self.cython_directives = None + + def finalize_options(self): + need_cythonize = self.cython_always + cfiles = {} + + for extension in self.distribution.ext_modules: + for i, sfile in enumerate(extension.sources): + if sfile.endswith('.pyx'): + prefix, ext = os.path.splitext(sfile) + cfile = prefix + '.c' + + if os.path.exists(cfile) and not self.cython_always: + extension.sources[i] = cfile + else: + if os.path.exists(cfile): + cfiles[cfile] = os.path.getmtime(cfile) + else: + cfiles[cfile] = 0 + need_cythonize = True + + if need_cythonize: + try: + import Cython + except ImportError: + raise RuntimeError( + 'please install Cython to compile asyncpg from source') + + if Cython.__version__ < '0.24': + raise RuntimeError( + 'asyncpg requires Cython version 0.24 or greater') + + from Cython.Build import cythonize + + directives = {} + if self.cython_directives: + for directive in self.cython_directives.split(','): + k, _, v = directive.partition('=') + if v.lower() == 'false': + v = False + if v.lower() == 'true': + v = True + + directives[k] = v + + self.distribution.ext_modules[:] = cythonize( + self.distribution.ext_modules, + compiler_directives=directives, + annotate=self.cython_annotate) + + for cfile, timestamp in cfiles.items(): + if os.path.getmtime(cfile) != timestamp: + # The file was recompiled, patch + self._patch_cfile(cfile) + + super(build_ext, self).finalize_options() + + def _patch_cfile(self, cfile): + # Script to patch Cython 'async def' coroutines to have a 'tp_iter' + # slot, which makes them compatible with 'yield from' without the + # `asyncio.coroutine` decorator. + + with open(cfile, 'rt') as f: + src = f.read() + + src = re.sub( + r''' + \s* offsetof\(__pyx_CoroutineObject,\s*gi_weakreflist\), + \s* 0, + \s* 0, + \s* __pyx_Coroutine_methods, + \s* __pyx_Coroutine_memberlist, + \s* __pyx_Coroutine_getsets, + ''', + + r''' + offsetof(__pyx_CoroutineObject, gi_weakreflist), + __Pyx_Coroutine_await, /* tp_iter */ + (iternextfunc) __Pyx_Generator_Next, /* tp_iternext */ + __pyx_Coroutine_methods, + __pyx_Coroutine_memberlist, + __pyx_Coroutine_getsets, + ''', + + src, flags=re.X) + + # Fix a segfault in Cython. + src = re.sub( + r''' + \s* __Pyx_Coroutine_get_qualname\(__pyx_CoroutineObject\s+\*self\) + \s* { + \s* Py_INCREF\(self->gi_qualname\); + ''', + + r''' + __Pyx_Coroutine_get_qualname(__pyx_CoroutineObject *self) + { + if (self->gi_qualname == NULL) { return __pyx_empty_unicode; } + Py_INCREF(self->gi_qualname); + ''', + + src, flags=re.X) + + src = re.sub( + r''' + \s* __Pyx_Coroutine_get_name\(__pyx_CoroutineObject\s+\*self\) + \s* { + \s* Py_INCREF\(self->gi_name\); + ''', + + r''' + __Pyx_Coroutine_get_name(__pyx_CoroutineObject *self) + { + if (self->gi_name == NULL) { return __pyx_empty_unicode; } + Py_INCREF(self->gi_name); + ''', + + src, flags=re.X) + + with open(cfile, 'wt') as f: + f.write(src) + + +with open(os.path.join(os.path.dirname(__file__), 'README.rst')) as f: + readme = f.read() + + +setuptools.setup( + name='asyncpg', + version=VERSION, + description='An asyncio PosgtreSQL driver', + long_description=readme, + classifiers=[ + 'License :: OSI Approved :: Apache Software License', + 'Intended Audience :: Developers', + 'Programming Language :: Python :: 3 :: Only', + 'Programming Language :: Python :: 3.5', + 'Programming Language :: Python :: 3.6', + 'Operating System :: POSIX', + 'Operating System :: MacOS :: MacOS X', + 'Operating System :: Microsoft :: Windows', + 'Development Status :: 4 - Beta', + ], + platforms=['POSIX'], + author='MagicStack Inc', + author_email='hello@magic.io', + url='https://github.com/MagicStack/asyncpg', + license='Apache License, Version 2.0', + packages=['asyncpg'], + provides=['asyncpg'], + include_package_data=True, + ext_modules=[ + setuptools.Extension( + "asyncpg.protocol.protocol", + ["asyncpg/protocol/record/recordobj.c", + "asyncpg/protocol/protocol.pyx"], + extra_compile_args=CFLAGS, + extra_link_args=LDFLAGS) + ], + cmdclass={'build_ext': build_ext}, + test_suite='setup.discover_tests', +) diff --git a/tests/test_cancellation.py b/tests/test_cancellation.py new file mode 100644 index 0000000..898b752 --- /dev/null +++ b/tests/test_cancellation.py @@ -0,0 +1,96 @@ +# Copyright (C) 2016-present the ayncpg authors and contributors +# +# +# This module is part of asyncpg and is released under +# the Apache 2.0 License: http://www.apache.org/licenses/LICENSE-2.0 + + +import asyncio +import asyncpg + +from asyncpg import _testbase as tb + + +class TestCancellation(tb.ConnectedTestCase): + + async def test_cancellation_01(self): + st1000 = await self.con.prepare('SELECT 1000') + + async def test0(): + val = await self.con.execute('SELECT 42') + self.assertEqual(val, 'SELECT 1') + + async def test1(): + val = await self.con.fetchval('SELECT 42') + self.assertEqual(val, 42) + + async def test2(): + val = await self.con.fetchrow('SELECT 42') + self.assertEqual(val, (42,)) + + async def test3(): + val = await self.con.fetch('SELECT 42') + self.assertEqual(val, [(42,)]) + + async def test4(): + val = await self.con.prepare('SELECT 42') + self.assertEqual(await val.fetchval(), 42) + + async def test5(): + self.assertEqual(await st1000.fetchval(), 1000) + + async def test6(): + self.assertEqual(await st1000.fetchrow(), (1000,)) + + async def test7(): + self.assertEqual(await st1000.fetch(), [(1000,)]) + + async def test8(): + cur = await st1000.cursor() + self.assertEqual(await cur.fetchrow(), (1000,)) + + for test in {test0, test1, test2, test3, test4, test5, + test6, test7, test8}: + + with self.subTest(testfunc=test), self.assertRunUnder(1): + st = await self.con.prepare('SELECT pg_sleep(20)') + task = self.loop.create_task(st.fetch()) + await asyncio.sleep(0.05, loop=self.loop) + task.cancel() + + with self.assertRaises(asyncio.CancelledError): + await task + + async with self.con.transaction(): + await test() + + async def test_cancellation_02(self): + st = await self.con.prepare('SELECT 1') + task = self.loop.create_task(st.fetch()) + await asyncio.sleep(0.05, loop=self.loop) + task.cancel() + self.assertEqual(await task, [(1,)]) + + async def test_cancellation_03(self): + with self.assertRaises(asyncpg.InFailedSQLTransactionError): + async with self.con.transaction(): + task = self.loop.create_task( + self.con.fetch('SELECT pg_sleep(20)')) + await asyncio.sleep(0.05, loop=self.loop) + task.cancel() + + with self.assertRaises(asyncio.CancelledError): + await task + + await self.con.fetch('SELECT generate_series(0, 100)') + + self.assertEqual( + await self.con.fetchval('SELECT 42'), + 42) + + async def test_cancellation_04(self): + await self.con.fetchval('SELECT pg_sleep(0)') + waiter = asyncio.Future(loop=self.loop) + self.con._cancel_current_command(waiter) + await waiter + self.assertEqual(await self.con.fetchval('SELECT 42'), 42) diff --git a/tests/test_codecs.py b/tests/test_codecs.py new file mode 100644 index 0000000..34c8786 --- /dev/null +++ b/tests/test_codecs.py @@ -0,0 +1,1020 @@ +# Copyright (C) 2016-present the ayncpg authors and contributors +# +# +# This module is part of asyncpg and is released under +# the Apache 2.0 License: http://www.apache.org/licenses/LICENSE-2.0 + + +import datetime +import decimal +import ipaddress +import math +import random +import struct +import unittest +import uuid + +import asyncpg +from asyncpg import _testbase as tb + + +def _timezone(offset): + minutes = offset // 60 + return datetime.timezone(datetime.timedelta(minutes=minutes)) + + +infinity_datetime = datetime.datetime( + datetime.MAXYEAR, 12, 31, 23, 59, 59, 999999) +negative_infinity_datetime = datetime.datetime( + datetime.MINYEAR, 1, 1, 0, 0, 0, 0) + +infinity_date = datetime.date(datetime.MAXYEAR, 12, 31) +negative_infinity_date = datetime.date(datetime.MINYEAR, 1, 1) + + +type_samples = [ + ('bool', 'bool', ( + True, False, + )), + ('smallint', 'int2', ( + -2 ** 15 + 1, 2 ** 15 - 1, + -1, 0, 1, + )), + ('int', 'int4', ( + -2 ** 31 + 1, 2 ** 31 - 1, + -1, 0, 1, + )), + ('bigint', 'int8', ( + -2 ** 63 + 1, 2 ** 63 - 1, + -1, 0, 1, + )), + ('numeric', 'numeric', ( + -(2 ** 64), + 2 ** 64, + -(2 ** 128), + 2 ** 128, + -1, 0, 1, + decimal.Decimal("0.00000000000000"), + decimal.Decimal("1.00000000000000"), + decimal.Decimal("-1.00000000000000"), + decimal.Decimal("-2.00000000000000"), + decimal.Decimal("1000000000000000.00000000000000"), + decimal.Decimal("-0.00000000000000"), + decimal.Decimal(1234), + decimal.Decimal(-1234), + decimal.Decimal("1234000000.00088883231"), + decimal.Decimal(str(1234.00088883231)), + decimal.Decimal("3123.23111"), + decimal.Decimal("-3123000000.23111"), + decimal.Decimal("3123.2311100000"), + decimal.Decimal("-03123.0023111"), + decimal.Decimal("3123.23111"), + decimal.Decimal("3123.23111"), + decimal.Decimal("10000.23111"), + decimal.Decimal("100000.23111"), + decimal.Decimal("1000000.23111"), + decimal.Decimal("10000000.23111"), + decimal.Decimal("100000000.23111"), + decimal.Decimal("1000000000.23111"), + decimal.Decimal("1000000000.3111"), + decimal.Decimal("1000000000.111"), + decimal.Decimal("1000000000.11"), + decimal.Decimal("100000000.0"), + decimal.Decimal("10000000.0"), + decimal.Decimal("1000000.0"), + decimal.Decimal("100000.0"), + decimal.Decimal("10000.0"), + decimal.Decimal("1000.0"), + decimal.Decimal("100.0"), + decimal.Decimal("100"), + decimal.Decimal("100.1"), + decimal.Decimal("100.12"), + decimal.Decimal("100.123"), + decimal.Decimal("100.1234"), + decimal.Decimal("100.12345"), + decimal.Decimal("100.123456"), + decimal.Decimal("100.1234567"), + decimal.Decimal("100.12345679"), + decimal.Decimal("100.123456790"), + decimal.Decimal("100.123456790000000000000000"), + decimal.Decimal("1.0"), + decimal.Decimal("0.0"), + decimal.Decimal("-1.0"), + decimal.Decimal("1.0E-1000"), + decimal.Decimal("1.0E1000"), + decimal.Decimal("0.000000000000000000000000001"), + decimal.Decimal("0.000000000000010000000000001"), + decimal.Decimal("0.00000000000000000000000001"), + decimal.Decimal("0.00000000100000000000000001"), + decimal.Decimal("0.0000000000000000000000001"), + decimal.Decimal("0.000000000000000000000001"), + decimal.Decimal("0.00000000000000000000001"), + decimal.Decimal("0.0000000000000000000001"), + decimal.Decimal("0.000000000000000000001"), + decimal.Decimal("0.00000000000000000001"), + decimal.Decimal("0.0000000000000000001"), + decimal.Decimal("0.000000000000000001"), + decimal.Decimal("0.00000000000000001"), + decimal.Decimal("0.0000000000000001"), + decimal.Decimal("0.000000000000001"), + decimal.Decimal("0.00000000000001"), + decimal.Decimal("0.0000000000001"), + decimal.Decimal("0.000000000001"), + decimal.Decimal("0.00000000001"), + decimal.Decimal("0.0000000001"), + decimal.Decimal("0.000000001"), + decimal.Decimal("0.00000001"), + decimal.Decimal("0.0000001"), + decimal.Decimal("0.000001"), + decimal.Decimal("0.00001"), + decimal.Decimal("0.0001"), + decimal.Decimal("0.001"), + decimal.Decimal("0.01"), + decimal.Decimal("0.1"), + )), + ('bytea', 'bytea', ( + bytes(range(256)), + bytes(range(255, -1, -1)), + b'\x00\x00', + b'foo', + b'f' * 1024 * 1024, + dict(input=bytearray(b'\x02\x01'), output=b'\x02\x01'), + )), + ('text', 'text', ( + '', + 'A' * (1024 * 1024 + 11) + )), + ('"char"', 'char', ( + b'a', + b'b', + b'\x00' + )), + ('timestamp', 'timestamp', [ + datetime.datetime(3000, 5, 20, 5, 30, 10), + datetime.datetime(2000, 1, 1, 5, 25, 10), + datetime.datetime(500, 1, 1, 5, 25, 10), + datetime.datetime(250, 1, 1, 5, 25, 10), + infinity_datetime, + negative_infinity_datetime, + {'textinput': 'infinity', 'output': infinity_datetime}, + {'textinput': '-infinity', 'output': negative_infinity_datetime}, + ]), + ('date', 'date', [ + datetime.date(3000, 5, 20), + datetime.date(2000, 1, 1), + datetime.date(500, 1, 1), + infinity_date, + negative_infinity_date, + {'textinput': 'infinity', 'output': infinity_date}, + {'textinput': '-infinity', 'output': negative_infinity_date}, + ]), + ('time', 'time', [ + datetime.time(12, 15, 20), + datetime.time(0, 1, 1), + datetime.time(23, 59, 59), + ]), + ('timestamptz', 'timestamptz', [ + # It's converted to UTC. When it comes back out, it will be in UTC + # again. The datetime comparison will take the tzinfo into account. + datetime.datetime(1990, 5, 12, 10, 10, 0, tzinfo=_timezone(4000)), + datetime.datetime(1982, 5, 18, 10, 10, 0, tzinfo=_timezone(6000)), + datetime.datetime(1950, 1, 1, 10, 10, 0, tzinfo=_timezone(7000)), + datetime.datetime(1800, 1, 1, 10, 10, 0, tzinfo=_timezone(2000)), + datetime.datetime(2400, 1, 1, 10, 10, 0, tzinfo=_timezone(2000)), + infinity_datetime, + negative_infinity_datetime, + ]), + ('timetz', 'timetz', [ + # timetz retains the offset + datetime.time(10, 10, 0, tzinfo=_timezone(4000)), + datetime.time(10, 10, 0, tzinfo=_timezone(6000)), + datetime.time(10, 10, 0, tzinfo=_timezone(7000)), + datetime.time(10, 10, 0, tzinfo=_timezone(2000)), + datetime.time(22, 30, 0, tzinfo=_timezone(0)), + ]), + ('interval', 'interval', [ + # no months :( + datetime.timedelta(40, 10, 1234), + datetime.timedelta(0, 0, 4321), + datetime.timedelta(0, 0), + datetime.timedelta(-100, 0), + datetime.timedelta(-100, -400), + ]), + ('uuid', 'uuid', [ + uuid.UUID('38a4ff5a-3a56-11e6-a6c2-c8f73323c6d4'), + uuid.UUID('00000000-0000-0000-0000-000000000000'), + {'input': '00000000-0000-0000-0000-000000000000', + 'output': uuid.UUID('00000000-0000-0000-0000-000000000000')} + ]), + ('uuid[]', 'uuid[]', [ + [uuid.UUID('38a4ff5a-3a56-11e6-a6c2-c8f73323c6d4'), + uuid.UUID('00000000-0000-0000-0000-000000000000')], + [] + ]), + ('json', 'json', [ + '[1, 2, 3, 4]', + '{"a": [1, 2], "b": 0}' + ], (9, 2)), + ('jsonb', 'jsonb', [ + '[1, 2, 3, 4]', + '{"a": [1, 2], "b": 0}' + ], (9, 4)), + ('oid[]', 'oid[]', [ + [1, 2, 3, 4], + [] + ]), + ('smallint[]', 'int2[]', [ + [1, 2, 3, 4], + [1, 2, 3, 4, 5, 6, 7, 8, 9, 0], + [] + ]), + ('bigint[]', 'int8[]', [ + [2 ** 42, -2 ** 54, 0], + [] + ]), + ('int[]', 'int4[]', [ + [2 ** 22, -2 ** 24, 0], + [] + ]), + ('time[]', 'time[]', [ + [datetime.time(12, 15, 20), datetime.time(0, 1, 1)], + [] + ]), + ('text[]', 'text[]', [ + ['ABCDE', 'EDCBA'], + [], + ['A' * 1024 * 1024] * 10 + ]), + ('float8', 'float8', [ + 1.1, + -1.1, + 0, + 2, + 1e-4, + -1e-20, + 122.2e-100, + 2e5, + math.pi, + math.e, + math.inf, + -math.inf, + math.nan + ]), + ('float4', 'float4', [ + 1.1, + -1.1, + 0, + 2, + 1e-4, + -1e-20, + 2e5, + math.pi, + math.e, + math.inf, + -math.inf, + math.nan + ]), + ('cidr', 'cidr', [ + ipaddress.IPv4Network('255.255.255.255/32'), + ipaddress.IPv4Network('127.0.0.0/8'), + ipaddress.IPv4Network('127.1.0.0/16'), + ipaddress.IPv4Network('127.1.0.0/18'), + ipaddress.IPv4Network('10.0.0.0/32'), + ipaddress.IPv4Network('0.0.0.0/0'), + ipaddress.IPv6Network('ffff' + ':ffff' * 7 + '/128'), + ipaddress.IPv6Network('::1/128'), + ipaddress.IPv6Network('::/0'), + ]), + ('inet', 'inet', [ + ipaddress.IPv4Address('255.255.255.255'), + ipaddress.IPv4Address('127.0.0.1'), + ipaddress.IPv4Address('0.0.0.0'), + ipaddress.IPv6Address('ffff' + ':ffff' * 7), + ipaddress.IPv6Address('::1'), + ipaddress.IPv6Address('::'), + dict( + input='127.0.0.0/8', + output=ipaddress.IPv4Network('127.0.0.0/8')), + dict( + input='127.0.0.1/32', + output=ipaddress.IPv4Network('127.0.0.1/32')), + ]), + ('macaddr', 'macaddr', [ + '00:00:00:00:00:00', + 'ff:ff:ff:ff:ff:ff' + ]), + ('txid_snapshot', 'txid_snapshot', [ + (100, 1000, (100, 200, 300, 400)) + ]), + ('varbit', 'varbit', [ + asyncpg.BitString('0000 0001'), + asyncpg.BitString('00010001'), + asyncpg.BitString(''), + asyncpg.BitString(), + asyncpg.BitString.frombytes(b'\x00', bitlength=3), + asyncpg.BitString('0000 0000 1'), + dict(input=b'\x01', output=asyncpg.BitString('0000 0001')), + dict(input=bytearray(b'\x02'), output=asyncpg.BitString('0000 0010')), + ]), + ('path', 'path', [ + asyncpg.Path(asyncpg.Point(0.0, 0.0), asyncpg.Point(1.0, 1.0)), + asyncpg.Path(asyncpg.Point(0.0, 0.0), asyncpg.Point(1.0, 1.0), + is_closed=True), + dict(input=((0.0, 0.0), (1.0, 1.0)), + output=asyncpg.Path(asyncpg.Point(0.0, 0.0), + asyncpg.Point(1.0, 1.0), + is_closed=True)), + dict(input=[(0.0, 0.0), (1.0, 1.0)], + output=asyncpg.Path(asyncpg.Point(0.0, 0.0), + asyncpg.Point(1.0, 1.0), + is_closed=False)), + ]), + ('point', 'point', [ + asyncpg.Point(0.0, 0.0), + asyncpg.Point(1.0, 2.0), + ]), + ('box', 'box', [ + asyncpg.Box((1.0, 2.0), (0.0, 0.0)), + ]), + ('line', 'line', [ + asyncpg.Line(1, 2, 3), + ], (9, 4)), + ('lseg', 'lseg', [ + asyncpg.LineSegment((1, 2), (2, 2)), + ]), + ('polygon', 'polygon', [ + asyncpg.Polygon(asyncpg.Point(0.0, 0.0), asyncpg.Point(1.0, 0.0), + asyncpg.Point(1.0, 1.0), asyncpg.Point(0.0, 1.0)), + ]), + ('circle', 'circle', [ + asyncpg.Circle((0.0, 0.0), 100), + ]), +] + + +class TestCodecs(tb.ConnectedTestCase): + + async def test_standard_codecs(self): + """Test encoding/decoding of standard data types and arrays thereof.""" + for (typname, intname, sample_data, *metadata) in type_samples: + if metadata and self.server_version < metadata[0]: + continue + + st = await self.con.prepare( + "SELECT $1::" + typname + ) + + textst = await self.con.prepare( + "SELECT $1::text::" + typname + ) + + for sample in sample_data: + with self.subTest(sample=sample, typname=typname): + stmt = st + if isinstance(sample, dict): + if 'textinput' in sample: + inputval = sample['textinput'] + stmt = textst + else: + inputval = sample['input'] + outputval = sample['output'] + else: + inputval = outputval = sample + + result = await stmt.fetchval(inputval) + err_msg = ( + "unexpected result for {} when passing {!r}: " + "received {!r}, expected {!r}".format( + typname, inputval, result, outputval)) + + if typname.startswith('float'): + if math.isnan(outputval): + if not math.isnan(result): + self.fail(err_msg) + else: + self.assertTrue( + math.isclose(result, outputval, rel_tol=1e-6), + err_msg) + else: + self.assertEqual(result, outputval, err_msg) + + with self.subTest(sample=None, typname=typname): + # Test that None is handled for all types. + rsample = await st.fetchval(None) + self.assertIsNone(rsample) + + at = st.get_attributes() + self.assertEqual(at[0].type.name, intname) + + async def test_all_builtin_types_handled(self): + from asyncpg.protocol.protocol import TYPEMAP + + for oid, typename in TYPEMAP.items(): + codec = self.con.get_settings().get_data_codec(oid) + self.assertIsNotNone( + codec, + 'core type {} ({}) is unhandled'.format(typename, oid)) + + async def test_void(self): + res = await self.con.fetchval('select pg_sleep(0)') + self.assertIsNone(res) + await self.con.fetchval('select now($1::void)', '') + + def test_bitstring(self): + bitlen = random.randint(0, 1000) + bs = ''.join(random.choice(('1', '0', ' ')) for _ in range(bitlen)) + bits = asyncpg.BitString(bs) + sanitized_bs = bs.replace(' ', '') + self.assertEqual(sanitized_bs, + bits.as_string().replace(' ', '')) + + expected_bytelen = \ + len(sanitized_bs) // 8 + (1 if len(sanitized_bs) % 8 else 0) + + self.assertEqual(len(bits.bytes), expected_bytelen) + + async def test_unhandled_type_fallback(self): + await self.con.execute(''' + CREATE EXTENSION IF NOT EXISTS isn + ''') + + try: + input_val = '1436-4522' + + res = await self.con.fetchrow(''' + SELECT $1::issn AS issn, 42 AS int + ''', input_val) + + self.assertEqual(res['issn'], input_val) + self.assertEqual(res['int'], 42) + + finally: + await self.con.execute(''' + DROP EXTENSION isn + ''') + + async def test_invalid_input(self): + cases = [ + ('bytea', TypeError, 'a bytes-like object is required', [ + 1, + 'aaa' + ]), + ('bool', TypeError, 'a boolean is required', [ + 1, + ]), + ('int2', TypeError, 'an integer is required', [ + '2', + 'aa', + ]), + ('smallint', ValueError, 'integer too large', [ + 32768, + -32768 + ]), + ('float4', ValueError, 'float value too large', [ + 4.1 * 10 ** 40, + -4.1 * 10 ** 40, + ]), + ('int4', TypeError, 'an integer is required', [ + '2', + 'aa', + ]), + ('int8', TypeError, 'an integer is required', [ + '2', + 'aa', + ]) + ] + + for typname, errcls, errmsg, data in cases: + stmt = await self.con.prepare("SELECT $1::" + typname) + + for sample in data: + with self.subTest(sample=sample, typname=typname): + with self.assertRaisesRegex(errcls, errmsg): + await stmt.fetchval(sample) + + async def test_arrays(self): + """Test encoding/decoding of arrays (particularly multidimensional).""" + cases = [ + ( + r"SELECT '[1:3][-1:0]={{1,2},{4,5},{6,7}}'::int[]", + [[1, 2], [4, 5], [6, 7]] + ), + ( + r"SELECT '{{{{{{1}}}}}}'::int[]", + [[[[[[1]]]]]] + ), + ( + r"SELECT '{1, 2, NULL}'::int[]::anyarray", + [1, 2, None] + ), + ] + + for sql, expected in cases: + with self.subTest(sql=sql): + res = await self.con.fetchval(sql) + self.assertEqual(res, expected) + + with self.assertRaises(asyncpg.ProgramLimitExceededError): + await self.con.fetchval("SELECT '{{{{{{{1}}}}}}}'::int[]") + + cases = [ + [None], + [1, 2, 3, 4, 5, 6], + [[1, 2], [4, 5], [6, 7]], + [[[1], [2]], [[4], [5]], [[None], [7]]], + [[[[[[1]]]]]], + [[[[[[None]]]]]] + ] + + st = await self.con.prepare( + "SELECT $1::int[]" + ) + + for case in cases: + with self.subTest(case=case): + result = await st.fetchval(case) + err_msg = ( + "failed to return array data as-is; " + "gave {!r}, received {!r}".format( + case, result)) + + self.assertEqual(result, case, err_msg) + + with self.assertRaisesRegex(ValueError, 'dimensions'): + await self.con.fetchval( + "SELECT $1::int[]", + [[[[[[[1]]]]]]]) + + with self.assertRaisesRegex(ValueError, 'non-homogeneous'): + await self.con.fetchval( + "SELECT $1::int[]", + [1, [1]]) + + with self.assertRaisesRegex(ValueError, 'non-homogeneous'): + await self.con.fetchval( + "SELECT $1::int[]", + [[1], 1, [2]]) + + with self.assertRaisesRegex(ValueError, 'invalid array element'): + await self.con.fetchval( + "SELECT $1::int[]", + [1, 't', 2]) + + with self.assertRaisesRegex(ValueError, 'invalid array element'): + await self.con.fetchval( + "SELECT $1::int[]", + [[1], ['t'], [2]]) + + with self.assertRaisesRegex(TypeError, + 'non-trivial iterable expected'): + await self.con.fetchval( + "SELECT $1::int[]", + 1) + + async def test_composites(self): + """Test encoding/decoding of composite types.""" + await self.con.execute(''' + CREATE TYPE test_composite AS ( + a int, + b text, + c int[] + ) + ''') + + st = await self.con.prepare(''' + SELECT ROW(NULL, 1234, '5678', ROW(42, '42')) + ''') + + res = await st.fetchval() + + self.assertEqual(res, (None, 1234, '5678', (42, '42'))) + + try: + st = await self.con.prepare(''' + SELECT ROW( + NULL, + '5678', + ARRAY[9, NULL, 11]::int[] + )::test_composite AS test + ''') + + res = await st.fetch() + res = res[0]['test'] + + self.assertIsNone(res['a']) + self.assertEqual(res['b'], '5678') + self.assertEqual(res['c'], [9, None, 11]) + + self.assertIsNone(res[0]) + self.assertEqual(res[1], '5678') + self.assertEqual(res[2], [9, None, 11]) + + at = st.get_attributes() + self.assertEqual(len(at), 1) + self.assertEqual(at[0].name, 'test') + self.assertEqual(at[0].type.name, 'test_composite') + self.assertEqual(at[0].type.kind, 'composite') + + res = await self.con.fetchval(''' + SELECT $1::test_composite + ''', res) + + finally: + await self.con.execute('DROP TYPE test_composite') + + async def test_domains(self): + """Test encoding/decoding of composite types.""" + await self.con.execute(''' + CREATE DOMAIN my_dom AS int + ''') + + await self.con.execute(''' + CREATE DOMAIN my_dom2 AS my_dom + ''') + + try: + st = await self.con.prepare(''' + SELECT 3::my_dom2 + ''') + res = await st.fetchval() + + self.assertEqual(res, 3) + + st = await self.con.prepare(''' + SELECT NULL::my_dom2 + ''') + res = await st.fetchval() + + self.assertIsNone(res) + + at = st.get_attributes() + self.assertEqual(len(at), 1) + self.assertEqual(at[0].name, 'my_dom2') + self.assertEqual(at[0].type.name, 'int4') + self.assertEqual(at[0].type.kind, 'scalar') + + finally: + await self.con.execute('DROP DOMAIN my_dom2') + await self.con.execute('DROP DOMAIN my_dom') + + async def test_range_types(self): + """Test encoding/decoding of range types.""" + + if self.server_version < (9, 2): + raise unittest.SkipTest( + 'PostgreSQL servers < 9.2 do not support range types.') + + cases = [ + ('int4range', [ + [(1, 9), asyncpg.Range(1, 10)], + [asyncpg.Range(0, 9, lower_inc=False, upper_inc=True), + asyncpg.Range(1, 10)], + [(), asyncpg.Range(empty=True)], + [asyncpg.Range(empty=True), asyncpg.Range(empty=True)], + [(None, 2), asyncpg.Range(None, 3)], + [asyncpg.Range(None, 2, upper_inc=True), + asyncpg.Range(None, 3)], + [(2,), asyncpg.Range(2, None)], + [(2, None), asyncpg.Range(2, None)], + [asyncpg.Range(2, None), asyncpg.Range(2, None)], + [(None, None), asyncpg.Range(None, None)], + [asyncpg.Range(None, None), asyncpg.Range(None, None)] + ]) + ] + + for (typname, sample_data) in cases: + st = await self.con.prepare( + "SELECT $1::" + typname + ) + + for sample, expected in sample_data: + with self.subTest(sample=sample, typname=typname): + result = await st.fetchval(sample) + self.assertEqual(result, expected) + + with self.assertRaisesRegex( + TypeError, 'list, tuple or Range object expected'): + await self.con.fetch("SELECT $1::int4range", 'aa') + + with self.assertRaisesRegex( + ValueError, 'expected 0, 1 or 2 elements'): + await self.con.fetch("SELECT $1::int4range", (0, 2, 3)) + + async def test_extra_codec_alias(self): + """Test encoding/decoding of a builtin non-pg_catalog codec.""" + await self.con.execute(''' + CREATE EXTENSION IF NOT EXISTS hstore + ''') + + try: + await self.con.set_builtin_type_codec( + 'hstore', codec_name='pg_contrib.hstore') + + cases = [ + {'ham': 'spam', 'nada': None}, + {} + ] + + st = await self.con.prepare(''' + SELECT $1::hstore AS result + ''') + + for case in cases: + res = await st.fetchval(case) + self.assertEqual(res, case) + + res = await self.con.fetchval(''' + SELECT $1::hstore AS result + ''', (('foo', 2), ('bar', 3))) + + self.assertEqual(res, {'foo': '2', 'bar': '3'}) + + with self.assertRaisesRegex(ValueError, 'null value not allowed'): + await self.con.fetchval(''' + SELECT $1::hstore AS result + ''', {None: '1'}) + + finally: + await self.con.execute(''' + DROP EXTENSION hstore + ''') + + async def test_custom_codec_text(self): + """Test encoding/decoding using a custom codec in text mode.""" + await self.con.execute(''' + CREATE EXTENSION IF NOT EXISTS hstore + ''') + + def hstore_decoder(data): + result = {} + items = data.split(',') + for item in items: + k, _, v = item.partition('=>') + result[k.strip('"')] = v.strip('"') + + return result + + def hstore_encoder(obj): + return ','.join('{}=>{}'.format(k, v) for k, v in obj.items()) + + try: + await self.con.set_type_codec('hstore', encoder=hstore_encoder, + decoder=hstore_decoder) + + st = await self.con.prepare(''' + SELECT $1::hstore AS result + ''') + + res = await st.fetchrow({'ham': 'spam'}) + res = res['result'] + + self.assertEqual(res, {'ham': 'spam'}) + + pt = st.get_parameters() + self.assertTrue(isinstance(pt, tuple)) + self.assertEqual(len(pt), 1) + self.assertEqual(pt[0].name, 'hstore') + self.assertEqual(pt[0].kind, 'scalar') + self.assertEqual(pt[0].schema, 'public') + + at = st.get_attributes() + self.assertTrue(isinstance(at, tuple)) + self.assertEqual(len(at), 1) + self.assertEqual(at[0].name, 'result') + self.assertEqual(at[0].type, pt[0]) + + err = 'cannot use custom codec on non-scalar type public._hstore' + with self.assertRaisesRegex(ValueError, err): + await self.con.set_type_codec('_hstore', + encoder=hstore_encoder, + decoder=hstore_decoder) + + await self.con.execute(''' + CREATE TYPE mytype AS (a int); + ''') + + try: + err = 'cannot use custom codec on non-scalar type ' + \ + 'public.mytype' + with self.assertRaisesRegex(ValueError, err): + await self.con.set_type_codec( + 'mytype', encoder=hstore_encoder, + decoder=hstore_decoder) + finally: + await self.con.execute(''' + DROP TYPE mytype; + ''') + + finally: + await self.con.execute(''' + DROP EXTENSION hstore + ''') + + async def test_custom_codec_binary(self): + """Test encoding/decoding using a custom codec in binary mode.""" + await self.con.execute(''' + CREATE EXTENSION IF NOT EXISTS hstore + ''') + + longstruct = struct.Struct('!L') + ulong_unpack = lambda b: longstruct.unpack_from(b)[0] + ulong_pack = longstruct.pack + + def hstore_decoder(data): + result = {} + n = ulong_unpack(data) + view = memoryview(data) + ptr = 4 + + for i in range(n): + klen = ulong_unpack(view[ptr:ptr + 4]) + ptr += 4 + k = bytes(view[ptr:ptr + klen]).decode() + ptr += klen + vlen = ulong_unpack(view[ptr:ptr + 4]) + ptr += 4 + if vlen == -1: + v = None + else: + v = bytes(view[ptr:ptr + vlen]).decode() + ptr += vlen + + result[k] = v + + return result + + def hstore_encoder(obj): + buffer = bytearray(ulong_pack(len(obj))) + + for k, v in obj.items(): + kenc = k.encode() + buffer += ulong_pack(len(kenc)) + kenc + + if v is None: + buffer += b'\xFF\xFF\xFF\xFF' # -1 + else: + venc = v.encode() + buffer += ulong_pack(len(venc)) + venc + + return buffer + + try: + await self.con.set_type_codec('hstore', encoder=hstore_encoder, + decoder=hstore_decoder, + binary=True) + + st = await self.con.prepare(''' + SELECT $1::hstore AS result + ''') + + res = await st.fetchrow({'ham': 'spam'}) + res = res['result'] + + self.assertEqual(res, {'ham': 'spam'}) + + pt = st.get_parameters() + self.assertTrue(isinstance(pt, tuple)) + self.assertEqual(len(pt), 1) + self.assertEqual(pt[0].name, 'hstore') + self.assertEqual(pt[0].kind, 'scalar') + self.assertEqual(pt[0].schema, 'public') + + at = st.get_attributes() + self.assertTrue(isinstance(at, tuple)) + self.assertEqual(len(at), 1) + self.assertEqual(at[0].name, 'result') + self.assertEqual(at[0].type, pt[0]) + + finally: + await self.con.execute(''' + DROP EXTENSION hstore + ''') + + async def test_composites_in_arrays(self): + await self.con.execute(''' + CREATE TYPE t AS (a text, b int); + CREATE TABLE tab (d t[]); + ''') + + try: + await self.con.execute( + 'INSERT INTO tab (d) VALUES ($1)', + [('a', 1)]) + + r = await self.con.fetchval(''' + SELECT d FROM tab + ''') + + self.assertEqual(r, [('a', 1)]) + finally: + await self.con.execute(''' + DROP TABLE tab; + DROP TYPE t; + ''') + + async def test_table_as_composite(self): + await self.con.execute(''' + CREATE TABLE tab (a text, b int); + INSERT INTO tab VALUES ('1', 1); + ''') + + try: + r = await self.con.fetchrow(''' + SELECT tab FROM tab + ''') + + self.assertEqual(r, (('1', 1),)) + + finally: + await self.con.execute(''' + DROP TABLE tab; + ''') + + async def test_relacl_array_type(self): + await self.con.execute(r''' + CREATE USER """u1'"; + CREATE USER "{u2"; + CREATE USER ",u3"; + CREATE USER "u4}"; + CREATE USER "u5"""; + CREATE USER "u6\"""; + CREATE USER "u7\"; + CREATE USER norm1; + CREATE USER norm2; + CREATE TABLE t0 (); GRANT SELECT ON t0 TO norm1; + CREATE TABLE t1 (); GRANT SELECT ON t1 TO """u1'"; + CREATE TABLE t2 (); GRANT SELECT ON t2 TO "{u2"; + CREATE TABLE t3 (); GRANT SELECT ON t3 TO ",u3"; + CREATE TABLE t4 (); GRANT SELECT ON t4 TO "u4}"; + CREATE TABLE t5 (); GRANT SELECT ON t5 TO "u5"""; + CREATE TABLE t6 (); GRANT SELECT ON t6 TO "u6\"""; + CREATE TABLE t7 (); GRANT SELECT ON t7 TO "u7\"; + + CREATE TABLE a1 (); + GRANT SELECT ON a1 TO """u1'"; + GRANT SELECT ON a1 TO "{u2"; + GRANT SELECT ON a1 TO ",u3"; + GRANT SELECT ON a1 TO "norm1"; + GRANT SELECT ON a1 TO "u4}"; + GRANT SELECT ON a1 TO "u5"""; + GRANT SELECT ON a1 TO "u6\"""; + GRANT SELECT ON a1 TO "u7\"; + GRANT SELECT ON a1 TO "norm2"; + + CREATE TABLE a2 (); + GRANT SELECT ON a2 TO """u1'" WITH GRANT OPTION; + GRANT SELECT ON a2 TO "{u2" WITH GRANT OPTION; + GRANT SELECT ON a2 TO ",u3" WITH GRANT OPTION; + GRANT SELECT ON a2 TO "norm1" WITH GRANT OPTION; + GRANT SELECT ON a2 TO "u4}" WITH GRANT OPTION; + GRANT SELECT ON a2 TO "u5""" WITH GRANT OPTION; + GRANT SELECT ON a2 TO "u6\""" WITH GRANT OPTION; + GRANT SELECT ON a2 TO "u7\" WITH GRANT OPTION; + + SET SESSION AUTHORIZATION """u1'"; GRANT SELECT ON a2 TO "norm2"; + SET SESSION AUTHORIZATION "{u2"; GRANT SELECT ON a2 TO "norm2"; + SET SESSION AUTHORIZATION ",u3"; GRANT SELECT ON a2 TO "norm2"; + SET SESSION AUTHORIZATION "u4}"; GRANT SELECT ON a2 TO "norm2"; + SET SESSION AUTHORIZATION "u5"""; GRANT SELECT ON a2 TO "norm2"; + SET SESSION AUTHORIZATION "u6\"""; GRANT SELECT ON a2 TO "norm2"; + SET SESSION AUTHORIZATION "u7\"; GRANT SELECT ON a2 TO "norm2"; + RESET SESSION AUTHORIZATION; + ''') + + try: + rows = await self.con.fetch(''' + SELECT + relacl, + relacl::text[] AS chk, + relacl::text[]::text AS text_ + FROM + pg_catalog.pg_class + WHERE + relacl IS NOT NULL + ''') + + for row in rows: + self.assertEqual(row['relacl'], row['chk'],) + + finally: + await self.con.execute(r''' + DROP TABLE t0; + DROP TABLE t1; + DROP TABLE t2; + DROP TABLE t3; + DROP TABLE t4; + DROP TABLE t5; + DROP TABLE t6; + DROP TABLE t7; + DROP TABLE a1; + DROP TABLE a2; + DROP USER """u1'"; + DROP USER "{u2"; + DROP USER ",u3"; + DROP USER "u4}"; + DROP USER "u5"""; + DROP USER "u6\"""; + DROP USER "u7\"; + DROP USER norm1; + DROP USER norm2; + ''') diff --git a/tests/test_connect.py b/tests/test_connect.py new file mode 100644 index 0000000..09c987e --- /dev/null +++ b/tests/test_connect.py @@ -0,0 +1,384 @@ +# Copyright (C) 2016-present the ayncpg authors and contributors +# +# +# This module is part of asyncpg and is released under +# the Apache 2.0 License: http://www.apache.org/licenses/LICENSE-2.0 + + +import contextlib +import ipaddress +import os +import platform +import unittest + +import asyncpg +from asyncpg import _testbase as tb +from asyncpg.connection import _parse_connect_params + +_system = platform.uname().system + + +class TestSettings(tb.ConnectedTestCase): + + async def test_get_settings_01(self): + self.assertEqual( + self.con.get_settings().client_encoding, + 'UTF8') + + +class TestAuthentication(tb.ConnectedTestCase): + def setUp(self): + super().setUp() + + if not self.cluster.is_managed(): + self.skipTest('unmanaged cluster') + + methods = [ + ('trust', None), + ('reject', None), + ('md5', 'correctpassword'), + ('password', 'correctpassword'), + ] + + self.cluster.reset_hba() + + create_script = [] + for method, password in methods: + create_script.append( + 'CREATE ROLE {}_user WITH LOGIN{};'.format( + method, + ' PASSWORD {!r}'.format(password) if password else '' + ) + ) + + if _system != 'Windows': + self.cluster.add_hba_entry( + type='local', + database='postgres', user='{}_user'.format(method), + auth_method=method) + + self.cluster.add_hba_entry( + type='host', address=ipaddress.ip_network('127.0.0.0/24'), + database='postgres', user='{}_user'.format(method), + auth_method=method) + + self.cluster.add_hba_entry( + type='host', address=ipaddress.ip_network('::1/128'), + database='postgres', user='{}_user'.format(method), + auth_method=method) + + # Put hba changes into effect + self.cluster.reload() + + create_script = '\n'.join(create_script) + self.loop.run_until_complete(self.con.execute(create_script)) + + def tearDown(self): + # Reset cluster's pg_hba.conf since we've meddled with it + self.cluster.trust_local_connections() + + methods = [ + 'trust', + 'reject', + 'md5', + 'password', + ] + + drop_script = [] + for method in methods: + drop_script.append('DROP ROLE {}_user;'.format(method)) + + drop_script = '\n'.join(drop_script) + self.loop.run_until_complete(self.con.execute(drop_script)) + + super().tearDown() + + async def test_auth_bad_user(self): + with self.assertRaises( + asyncpg.InvalidAuthorizationSpecificationError): + await self.cluster.connect(user='__nonexistent__', + database='postgres', + loop=self.loop) + + async def test_auth_trust(self): + conn = await self.cluster.connect( + user='trust_user', database='postgres', loop=self.loop) + await conn.close() + + async def test_auth_reject(self): + with self.assertRaisesRegex( + asyncpg.InvalidAuthorizationSpecificationError, + 'pg_hba.conf rejects connection'): + for tried in range(3): + try: + await self.cluster.connect( + user='reject_user', database='postgres', + loop=self.loop) + except asyncpg.ConnectionDoesNotExistError: + if _system == 'Windows': + # On Windows the server sometimes just closes + # the connection sooner than we receive the + # actual error. + continue + else: + raise + else: + break + + async def test_auth_password_cleartext(self): + conn = await self.cluster.connect( + user='password_user', database='postgres', + password='correctpassword', loop=self.loop) + await conn.close() + + with self.assertRaisesRegex( + asyncpg.InvalidPasswordError, + 'password authentication failed for user "password_user"'): + await self.cluster.connect( + user='password_user', database='postgres', + password='wrongpassword', loop=self.loop) + + async def test_auth_password_md5(self): + conn = await self.cluster.connect( + user='md5_user', database='postgres', password='correctpassword', + loop=self.loop) + await conn.close() + + with self.assertRaisesRegex( + asyncpg.InvalidPasswordError, + 'password authentication failed for user "md5_user"'): + await self.cluster.connect( + user='md5_user', database='postgres', password='wrongpassword', + loop=self.loop) + + async def test_auth_unsupported(self): + pass + + +class TestConnectParams(unittest.TestCase): + + TESTS = [ + { + 'env': { + 'PGUSER': 'user', + 'PGDATABASE': 'testdb', + 'PGPASSWORD': 'passw', + 'PGHOST': 'host', + 'PGPORT': '123' + }, + 'result': (['host'], 123, { + 'user': 'user', + 'password': 'passw', + 'database': 'testdb'}) + }, + + { + 'env': { + 'PGUSER': 'user', + 'PGDATABASE': 'testdb', + 'PGPASSWORD': 'passw', + 'PGHOST': 'host', + 'PGPORT': '123' + }, + + 'host': 'host2', + 'port': '456', + 'user': 'user2', + 'password': 'passw2', + 'database': 'db2', + + 'result': (['host2'], 456, { + 'user': 'user2', + 'password': 'passw2', + 'database': 'db2'}) + }, + + { + 'env': { + 'PGUSER': 'user', + 'PGDATABASE': 'testdb', + 'PGPASSWORD': 'passw', + 'PGHOST': 'host', + 'PGPORT': '123' + }, + + 'dsn': 'postgres://user3:123123@localhost/abcdef', + + 'host': 'host2', + 'port': '456', + 'user': 'user2', + 'password': 'passw2', + 'database': 'db2', + + 'result': (['host2'], 456, { + 'user': 'user2', + 'password': 'passw2', + 'database': 'db2'}) + }, + + { + 'env': { + 'PGUSER': 'user', + 'PGDATABASE': 'testdb', + 'PGPASSWORD': 'passw', + 'PGHOST': 'host', + 'PGPORT': '123' + }, + + 'dsn': 'postgres://user3:123123@localhost:5555/abcdef', + + 'result': (['localhost'], 5555, { + 'user': 'user3', + 'password': '123123', + 'database': 'abcdef'}) + }, + + { + 'dsn': 'postgres://user3:123123@localhost:5555/abcdef', + 'result': (['localhost'], 5555, { + 'user': 'user3', + 'password': '123123', + 'database': 'abcdef'}) + }, + + { + 'dsn': 'postgresql://user3:123123@localhost:5555/' + 'abcdef?param=sss¶m=123&host=testhost&user=testuser' + '&port=2222&database=testdb', + 'host': '127.0.0.1', + 'port': '888', + 'user': 'me', + 'password': 'ask', + 'database': 'db', + 'result': (['127.0.0.1'], 888, { + 'param': '123', + 'user': 'me', + 'password': 'ask', + 'database': 'db'}) + }, + + { + 'dsn': 'postgresql:///dbname?host=/unix_sock/test&user=spam', + 'result': (['/unix_sock/test'], 5432, { + 'user': 'spam', + 'database': 'dbname'}) + }, + + { + 'dsn': 'pq:///dbname?host=/unix_sock/test&user=spam', + 'error': (ValueError, 'invalid DSN') + }, + ] + + @contextlib.contextmanager + def environ(self, **kwargs): + old_vals = {} + for key in kwargs: + if key in os.environ: + old_vals[key] = os.environ[key] + + for key, val in kwargs.items(): + if val is None: + if key in os.environ: + del os.environ[key] + else: + os.environ[key] = val + + try: + yield + finally: + for key in kwargs: + if key in os.environ: + del os.environ[key] + for key, val in old_vals.items(): + os.environ[key] = val + + def run_testcase(self, testcase): + env = testcase.get('env', {}) + test_env = {'PGHOST': None, 'PGPORT': None, + 'PGUSER': None, 'PGPASSWORD': None, + 'PGDATABASE': None} + test_env.update(env) + + dsn = testcase.get('dsn') + opts = testcase.get('opts', {}) + user = testcase.get('user') + port = testcase.get('port') + host = testcase.get('host') + password = testcase.get('password') + database = testcase.get('database') + + expected = testcase.get('result') + expected_error = testcase.get('error') + if expected is None and expected_error is None: + raise RuntimeError( + 'invalid test case: either "result" or "error" key ' + 'has to be specified') + if expected is not None and expected_error is not None: + raise RuntimeError( + 'invalid test case: either "result" or "error" key ' + 'has to be specified, got both') + + with contextlib.ExitStack() as es: + es.enter_context(self.subTest(dsn=dsn, opts=opts, env=env)) + es.enter_context(self.environ(**test_env)) + + if expected_error: + es.enter_context(self.assertRaisesRegex(*expected_error)) + + result = _parse_connect_params( + dsn=dsn, host=host, port=port, user=user, password=password, + database=database, opts=opts) + + if expected is not None: + self.assertEqual(expected, result) + + def test_test_connect_params_environ(self): + self.assertNotIn('AAAAAAAAAA123', os.environ) + self.assertNotIn('AAAAAAAAAA456', os.environ) + self.assertNotIn('AAAAAAAAAA789', os.environ) + + try: + + os.environ['AAAAAAAAAA456'] = '123' + os.environ['AAAAAAAAAA789'] = '123' + + with self.environ(AAAAAAAAAA123='1', + AAAAAAAAAA456='2', + AAAAAAAAAA789=None): + + self.assertEqual(os.environ['AAAAAAAAAA123'], '1') + self.assertEqual(os.environ['AAAAAAAAAA456'], '2') + self.assertNotIn('AAAAAAAAAA789', os.environ) + + self.assertNotIn('AAAAAAAAAA123', os.environ) + self.assertEqual(os.environ['AAAAAAAAAA456'], '123') + self.assertEqual(os.environ['AAAAAAAAAA789'], '123') + + finally: + for key in {'AAAAAAAAAA123', 'AAAAAAAAAA456', 'AAAAAAAAAA789'}: + if key in os.environ: + del os.environ[key] + + def test_test_connect_params_run_testcase(self): + with self.environ(PGPORT='777'): + self.run_testcase({ + 'env': { + 'PGUSER': '__test__' + }, + 'host': 'abc', + 'result': (['abc'], 5432, {'user': '__test__'}) + }) + + with self.assertRaises(AssertionError): + self.run_testcase({ + 'env': { + 'PGUSER': '__test__' + }, + 'host': 'abc', + 'result': (['abc'], 5432, {'user': 'wrong_user'}) + }) + + def test_connect_params(self): + for testcase in self.TESTS: + self.run_testcase(testcase) diff --git a/tests/test_cursor.py b/tests/test_cursor.py new file mode 100644 index 0000000..fc85480 --- /dev/null +++ b/tests/test_cursor.py @@ -0,0 +1,151 @@ +# Copyright (C) 2016-present the ayncpg authors and contributors +# +# +# This module is part of asyncpg and is released under +# the Apache 2.0 License: http://www.apache.org/licenses/LICENSE-2.0 + + +import asyncpg +import inspect + +from asyncpg import _testbase as tb + + +class TestIterableCursor(tb.ConnectedTestCase): + + async def test_cursor_iterable_01(self): + st = await self.con.prepare('SELECT generate_series(0, 20)') + expected = await st.fetch() + + for prefetch in range(1, 25): + with self.subTest(prefetch=prefetch): + async with self.con.transaction(): + result = [] + async for rec in st.cursor(prefetch=prefetch): + result.append(rec) + + self.assertEqual( + result, expected, + 'result != expected for prefetch={}'.format(prefetch)) + + async def test_cursor_iterable_02(self): + # Test that it's not possible to create a cursor without hold + # outside of a transaction + s = await self.con.prepare( + 'DECLARE t BINARY CURSOR WITHOUT HOLD FOR SELECT 1') + with self.assertRaises(asyncpg.NoActiveSQLTransactionError): + await s.fetch() + + # Now test that statement.cursor() does not let you + # iterate over it outside of a transaction + st = await self.con.prepare('SELECT generate_series(0, 20)') + + it = st.cursor(prefetch=5).__aiter__() + if inspect.isawaitable(it): + it = await it + + with self.assertRaisesRegex(asyncpg.NoActiveSQLTransactionError, + 'cursor cannot be created.*transaction'): + await it.__anext__() + + async def test_cursor_iterable_03(self): + st = await self.con.prepare('SELECT generate_series(0, 20)') + + it = st.cursor().__aiter__() + if inspect.isawaitable(it): + it = await it + + st._state.mark_closed() + + with self.assertRaisesRegex(asyncpg.InterfaceError, + 'statement is closed'): + async for _ in it: # NOQA + pass + + async def test_cursor_iterable_04(self): + st = await self.con.prepare('SELECT generate_series(0, 20)') + st._state.mark_closed() + + with self.assertRaisesRegex(asyncpg.InterfaceError, + 'statement is closed'): + async for _ in st.cursor(): # NOQA + pass + + async def test_cursor_iterable_05(self): + st = await self.con.prepare('SELECT generate_series(0, 20)') + for prefetch in range(-1, 1): + with self.subTest(prefetch=prefetch): + with self.assertRaisesRegex(asyncpg.InterfaceError, + 'must be greater than zero'): + async for _ in st.cursor(prefetch=prefetch): # NOQA + pass + + async def test_cursor_iterable_06(self): + recs = [] + + async with self.con.transaction(): + async for rec in self.con.cursor( + 'SELECT generate_series(0, $1::int)', 10): + recs.append(rec) + + self.assertEqual(recs, [(i,) for i in range(11)]) + + +class TestCursor(tb.ConnectedTestCase): + + async def test_cursor_01(self): + st = await self.con.prepare('SELECT generate_series(0, 20)') + with self.assertRaisesRegex(asyncpg.NoActiveSQLTransactionError, + 'cursor cannot be created.*transaction'): + await st.cursor() + + async def test_cursor_02(self): + st = await self.con.prepare('SELECT generate_series(0, 20)') + async with self.con.transaction(): + cur = await st.cursor() + + for i in range(-1, 1): + with self.assertRaisesRegex(asyncpg.InterfaceError, + 'greater than zero'): + await cur.fetch(i) + + res = await cur.fetch(2) + self.assertEqual(res, [(0,), (1,)]) + + rec = await cur.fetchrow() + self.assertEqual(rec, (2,)) + + r = repr(cur) + self.assertTrue(r.startswith(' +# +# This module is part of asyncpg and is released under +# the Apache 2.0 License: http://www.apache.org/licenses/LICENSE-2.0 + + +import asyncpg +from asyncpg import _testbase as tb + + +class TestExceptions(tb.ConnectedTestCase): + + def test_exceptions_exported(self): + for err in ('PostgresError', 'SubstringError', 'InterfaceError'): + self.assertTrue(hasattr(asyncpg, err)) + self.assertIn(err, asyncpg.__all__) + + for err in ('PostgresMessage',): + self.assertFalse(hasattr(asyncpg, err)) + self.assertNotIn(err, asyncpg.__all__) + + self.assertIsNone(asyncpg.PostgresError.schema_name) + + async def test_exceptions_unpacking(self): + with self.assertRaises(asyncpg.UndefinedTableError): + try: + await self.con.execute('SELECT * FROM _nonexistent_') + except asyncpg.UndefinedTableError as e: + self.assertEqual(e.sqlstate, '42P01') + self.assertEqual(e.position, '15') + self.assertEqual(e.query, 'SELECT * FROM _nonexistent_') + self.assertIsNotNone(e.severity) + raise diff --git a/tests/test_execute.py b/tests/test_execute.py new file mode 100644 index 0000000..c471015 --- /dev/null +++ b/tests/test_execute.py @@ -0,0 +1,134 @@ +# Copyright (C) 2016-present the ayncpg authors and contributors +# +# +# This module is part of asyncpg and is released under +# the Apache 2.0 License: http://www.apache.org/licenses/LICENSE-2.0 + + +import asyncio +import asyncpg + +from asyncpg import _testbase as tb + + +class TestExecuteScript(tb.ConnectedTestCase): + + async def test_execute_script_1(self): + self.assertEqual(self.con._protocol.queries_count, 0) + status = await self.con.execute(''' + SELECT 1; + + SELECT true FROM pg_type WHERE false = true; + + SELECT generate_series(0, 9); + ''') + self.assertEqual(self.con._protocol.queries_count, 1) + self.assertEqual(status, 'SELECT 10') + + async def test_execute_script_2(self): + status = await self.con.execute(''' + CREATE TABLE mytab (a int); + ''') + self.assertEqual(status, 'CREATE TABLE') + + try: + status = await self.con.execute(''' + INSERT INTO mytab (a) VALUES ($1), ($2) + ''', 10, 20) + self.assertEqual(status, 'INSERT 0 2') + finally: + await self.con.execute('DROP TABLE mytab') + + async def test_execute_script_3(self): + with self.assertRaisesRegex(asyncpg.PostgresSyntaxError, + 'cannot insert multiple commands'): + + await self.con.execute(''' + CREATE TABLE mytab (a int); + INSERT INTO mytab (a) VALUES ($1), ($2); + ''', 10, 20) + + async def test_execute_script_check_transactionality(self): + with self.assertRaises(asyncpg.PostgresError): + await self.con.execute(''' + CREATE TABLE mytab (a int); + SELECT * FROM mytab WHERE 1 / 0 = 1; + ''') + + with self.assertRaisesRegex(asyncpg.PostgresError, + '"mytab" does not exist'): + + await self.con.prepare(''' + SELECT * FROM mytab + ''') + + async def test_execute_exceptions_1(self): + with self.assertRaisesRegex(asyncpg.PostgresError, + 'relation "__dne__" does not exist'): + + await self.con.execute('select * from __dne__') + + async def test_execute_script_interrupted_close(self): + fut = self.loop.create_task( + self.con.execute('''SELECT pg_sleep(10)''')) + + await asyncio.sleep(0.2, loop=self.loop) + + self.assertFalse(self.con.is_closed()) + await self.con.close() + self.assertTrue(self.con.is_closed()) + + with self.assertRaisesRegex(asyncpg.ConnectionDoesNotExistError, + 'closed in the middle'): + await fut + + async def test_execute_script_interrupted_terminate(self): + fut = self.loop.create_task( + self.con.execute('''SELECT pg_sleep(10)''')) + + await asyncio.sleep(0.2, loop=self.loop) + + self.assertFalse(self.con.is_closed()) + self.con.terminate() + self.assertTrue(self.con.is_closed()) + + with self.assertRaisesRegex(asyncpg.ConnectionDoesNotExistError, + 'closed in the middle'): + await fut + + self.con.terminate() + + async def test_execute_many_1(self): + await self.con.execute('CREATE TEMP TABLE exmany (a text, b int)') + + try: + result = await self.con.executemany(''' + INSERT INTO exmany VALUES($1, $2) + ''', [ + ('a', 1), ('b', 2), ('c', 3), ('d', 4) + ]) + + self.assertIsNone(result) + + result = await self.con.fetch(''' + SELECT * FROM exmany + ''') + + self.assertEqual(result, [ + ('a', 1), ('b', 2), ('c', 3), ('d', 4) + ]) + + # Empty set + result = await self.con.executemany(''' + INSERT INTO exmany VALUES($1, $2) + ''', ()) + + result = await self.con.fetch(''' + SELECT * FROM exmany + ''') + + self.assertEqual(result, [ + ('a', 1), ('b', 2), ('c', 3), ('d', 4) + ]) + finally: + await self.con.execute('DROP TABLE exmany') diff --git a/tests/test_listeners.py b/tests/test_listeners.py new file mode 100644 index 0000000..158a97a --- /dev/null +++ b/tests/test_listeners.py @@ -0,0 +1,76 @@ +# Copyright (C) 2016-present the ayncpg authors and contributors +# +# +# This module is part of asyncpg and is released under +# the Apache 2.0 License: http://www.apache.org/licenses/LICENSE-2.0 + + +import asyncio + +from asyncpg import _testbase as tb + + +class TestListeners(tb.ClusterTestCase): + + async def test_listen_01(self): + async with self.create_pool(database='postgres') as pool: + async with pool.acquire() as con: + + q1 = asyncio.Queue(loop=self.loop) + q2 = asyncio.Queue(loop=self.loop) + + def listener1(*args): + q1.put_nowait(args) + + def listener2(*args): + q2.put_nowait(args) + + await con.add_listener('test', listener1) + await con.add_listener('test', listener2) + + await con.execute("NOTIFY test, 'aaaa'") + + self.assertEqual( + await q1.get(), + (con, con.get_server_pid(), 'test', 'aaaa')) + self.assertEqual( + await q2.get(), + (con, con.get_server_pid(), 'test', 'aaaa')) + + await con.remove_listener('test', listener2) + + await con.execute("NOTIFY test, 'aaaa'") + + self.assertEqual( + await q1.get(), + (con, con.get_server_pid(), 'test', 'aaaa')) + with self.assertRaises(asyncio.TimeoutError): + await asyncio.wait_for(q2.get(), + timeout=0.05, loop=self.loop) + + await con.reset() + await con.remove_listener('test', listener1) + await con.execute("NOTIFY test, 'aaaa'") + + with self.assertRaises(asyncio.TimeoutError): + await asyncio.wait_for(q1.get(), + timeout=0.05, loop=self.loop) + with self.assertRaises(asyncio.TimeoutError): + await asyncio.wait_for(q2.get(), + timeout=0.05, loop=self.loop) + + async def test_listen_02(self): + async with self.create_pool(database='postgres') as pool: + async with pool.acquire() as con1, pool.acquire() as con2: + + q1 = asyncio.Queue(loop=self.loop) + + def listener1(*args): + q1.put_nowait(args) + + await con1.add_listener('ipc', listener1) + await con2.execute("NOTIFY ipc, 'hello'") + + self.assertEqual( + await q1.get(), + (con1, con2.get_server_pid(), 'ipc', 'hello')) diff --git a/tests/test_pool.py b/tests/test_pool.py new file mode 100644 index 0000000..a6faf9a --- /dev/null +++ b/tests/test_pool.py @@ -0,0 +1,223 @@ +# Copyright (C) 2016-present the ayncpg authors and contributors +# +# +# This module is part of asyncpg and is released under +# the Apache 2.0 License: http://www.apache.org/licenses/LICENSE-2.0 + + +import asyncio +import platform +import os +import unittest + +from asyncpg import _testbase as tb +from asyncpg import cluster as pg_cluster +from asyncpg import pool as pg_pool + +_system = platform.uname().system + + +class TestPool(tb.ConnectedTestCase): + + async def test_pool_01(self): + for n in {1, 3, 5, 10, 20, 100}: + with self.subTest(tasksnum=n): + pool = await self.create_pool(database='postgres', + min_size=5, max_size=10) + + async def worker(): + con = await pool.acquire() + self.assertEqual(await con.fetchval('SELECT 1'), 1) + await pool.release(con) + + tasks = [worker() for _ in range(n)] + await asyncio.gather(*tasks, loop=self.loop) + await pool.close() + + async def test_pool_02(self): + for n in {1, 3, 5, 10, 20, 100}: + with self.subTest(tasksnum=n): + async with self.create_pool(database='postgres', + min_size=5, max_size=5) as pool: + + async def worker(): + con = await pool.acquire(timeout=5) + self.assertEqual(await con.fetchval('SELECT 1'), 1) + await pool.release(con) + + tasks = [worker() for _ in range(n)] + await asyncio.gather(*tasks, loop=self.loop) + + async def test_pool_03(self): + pool = await self.create_pool(database='postgres', + min_size=1, max_size=1) + + con = await pool.acquire(timeout=1) + with self.assertRaises(asyncio.TimeoutError): + await pool.acquire(timeout=0.03) + + pool.terminate() + del con + + async def test_pool_04(self): + pool = await self.create_pool(database='postgres', + min_size=1, max_size=1) + + con = await pool.acquire(timeout=0.1) + con.terminate() + await pool.release(con) + + async with pool.acquire(timeout=0.1): + con.terminate() + + con = await pool.acquire(timeout=0.1) + self.assertEqual(await con.fetchval('SELECT 1'), 1) + + await pool.close() + + async def test_pool_05(self): + for n in {1, 3, 5, 10, 20, 100}: + with self.subTest(tasksnum=n): + pool = await self.create_pool(database='postgres', + min_size=5, max_size=10) + + async def worker(): + async with pool.acquire() as con: + self.assertEqual(await con.fetchval('SELECT 1'), 1) + + tasks = [worker() for _ in range(n)] + await asyncio.gather(*tasks, loop=self.loop) + await pool.close() + + async def test_pool_06(self): + fut = asyncio.Future(loop=self.loop) + + async def setup(con): + fut.set_result(con) + + async with self.create_pool(database='postgres', + min_size=5, max_size=5, + setup=setup) as pool: + con = await pool.acquire() + + self.assertIs(con, await fut) + + async def test_pool_auth(self): + if not self.cluster.is_managed(): + self.skipTest('unmanaged cluster') + + self.cluster.reset_hba() + + if _system != 'Windows': + self.cluster.add_hba_entry( + type='local', + database='postgres', user='pooluser', + auth_method='md5') + + self.cluster.add_hba_entry( + type='host', address='127.0.0.1/32', + database='postgres', user='pooluser', + auth_method='md5') + + self.cluster.add_hba_entry( + type='host', address='::1/128', + database='postgres', user='pooluser', + auth_method='md5') + + self.cluster.reload() + + try: + await self.con.execute(''' + CREATE ROLE pooluser WITH LOGIN PASSWORD 'poolpassword' + ''') + + pool = await self.create_pool(database='postgres', + user='pooluser', + password='poolpassword', + min_size=5, max_size=10) + + async def worker(): + con = await pool.acquire() + self.assertEqual(await con.fetchval('SELECT 1'), 1) + await pool.release(con) + + tasks = [worker() for _ in range(5)] + await asyncio.gather(*tasks, loop=self.loop) + await pool.close() + + finally: + await self.con.execute('DROP ROLE pooluser') + + # Reset cluster's pg_hba.conf since we've meddled with it + self.cluster.trust_local_connections() + self.cluster.reload() + + +@unittest.skipIf(os.environ.get('PGHOST'), 'using remote cluster for testing') +class TestHostStandby(tb.ConnectedTestCase): + @classmethod + def setUpClass(cls): + super().setUpClass() + + cls.master_cluster = cls.start_cluster( + pg_cluster.TempCluster, + server_settings={ + 'max_wal_senders': 10, + 'wal_level': 'hot_standby' + }) + + con = None + + try: + con = cls.loop.run_until_complete( + cls.master_cluster.connect(database='postgres', loop=cls.loop)) + + cls.loop.run_until_complete( + con.execute(''' + CREATE ROLE replication WITH LOGIN REPLICATION + ''')) + + cls.master_cluster.trust_local_replication_by('replication') + + conn_spec = cls.master_cluster.get_connection_spec() + + cls.standby_cluster = cls.start_cluster( + pg_cluster.HotStandbyCluster, + cluster_kwargs={ + 'master': conn_spec, + 'replication_user': 'replication' + }, + server_settings={ + 'hot_standby': True + }) + + finally: + if con is not None: + cls.loop.run_until_complete(con.close()) + + @classmethod + def tearDownMethod(cls): + cls.standby_cluster.stop() + cls.standby_cluster.destroy() + cls.master_cluster.stop() + cls.master_cluster.destroy() + + def create_pool(self, **kwargs): + conn_spec = self.standby_cluster.get_connection_spec() + conn_spec.update(kwargs) + return pg_pool.create_pool(loop=self.loop, **conn_spec) + + async def test_standby_pool_01(self): + for n in {1, 3, 5, 10, 20, 100}: + with self.subTest(tasksnum=n): + pool = await self.create_pool(database='postgres', + min_size=5, max_size=10) + + async def worker(): + con = await pool.acquire() + self.assertEqual(await con.fetchval('SELECT 1'), 1) + await pool.release(con) + + tasks = [worker() for _ in range(n)] + await asyncio.gather(*tasks, loop=self.loop) + await pool.close() diff --git a/tests/test_prepare.py b/tests/test_prepare.py new file mode 100644 index 0000000..d09187c --- /dev/null +++ b/tests/test_prepare.py @@ -0,0 +1,408 @@ +# Copyright (C) 2016-present the ayncpg authors and contributors +# +# +# This module is part of asyncpg and is released under +# the Apache 2.0 License: http://www.apache.org/licenses/LICENSE-2.0 + + +import asyncio +import asyncpg +import gc +import unittest + +from asyncpg import _testbase as tb + + +class TestPrepare(tb.ConnectedTestCase): + + async def test_prepare_01(self): + self.assertEqual(self.con._protocol.queries_count, 0) + st = await self.con.prepare('SELECT 1 = $1 AS test') + self.assertEqual(self.con._protocol.queries_count, 0) + self.assertEqual(st.get_query(), 'SELECT 1 = $1 AS test') + + rec = await st.fetchrow(1) + self.assertEqual(self.con._protocol.queries_count, 1) + self.assertTrue(rec['test']) + self.assertEqual(len(rec), 1) + + self.assertEqual(False, await st.fetchval(10)) + self.assertEqual(self.con._protocol.queries_count, 2) + + async def test_prepare_02(self): + with self.assertRaisesRegex(Exception, 'column "a" does not exist'): + await self.con.prepare('SELECT a') + + async def test_prepare_03(self): + cases = [ + ('text', ("'NULL'", 'NULL'), [ + 'aaa', + None + ]), + + ('decimal', ('0', 0), [ + 123, + 123.5, + None + ]) + ] + + for type, (none_name, none_val), vals in cases: + st = await self.con.prepare(''' + SELECT CASE WHEN $1::{type} IS NULL THEN {default} + ELSE $1::{type} END'''.format( + type=type, default=none_name)) + + for val in vals: + with self.subTest(type=type, value=val): + res = await st.fetchval(val) + if val is None: + self.assertEqual(res, none_val) + else: + self.assertEqual(res, val) + + async def test_prepare_04(self): + s = await self.con.prepare('SELECT $1::smallint') + self.assertEqual(await s.fetchval(10), 10) + + s = await self.con.prepare('SELECT $1::smallint * 2') + self.assertEqual(await s.fetchval(10), 20) + + s = await self.con.prepare('SELECT generate_series(5,10)') + self.assertEqual(await s.fetchval(), 5) + # Since the "execute" message was sent with a limit=1, + # we will receive a PortalSuspended message, instead of + # CommandComplete. Which means there will be no status + # message set. + self.assertIsNone(s.get_statusmsg()) + # Repeat the same test for 'fetchrow()'. + self.assertEqual(await s.fetchrow(), (5,)) + self.assertIsNone(s.get_statusmsg()) + + async def test_prepare_05_unknownoid(self): + s = await self.con.prepare("SELECT 'test'") + self.assertEqual(await s.fetchval(), 'test') + + async def test_prepare_06_interrupted_close(self): + stmt = await self.con.prepare('''SELECT pg_sleep(10)''') + fut = self.loop.create_task(stmt.fetch()) + + await asyncio.sleep(0.2, loop=self.loop) + + self.assertFalse(self.con.is_closed()) + await self.con.close() + self.assertTrue(self.con.is_closed()) + + with self.assertRaisesRegex(asyncpg.ConnectionDoesNotExistError, + 'closed in the middle'): + await fut + + # Test that it's OK to call close again + await self.con.close() + + async def test_prepare_07_interrupted_terminate(self): + stmt = await self.con.prepare('''SELECT pg_sleep(10)''') + fut = self.loop.create_task(stmt.fetchval()) + + await asyncio.sleep(0.2, loop=self.loop) + + self.assertFalse(self.con.is_closed()) + self.con.terminate() + self.assertTrue(self.con.is_closed()) + + with self.assertRaisesRegex(asyncpg.ConnectionDoesNotExistError, + 'closed in the middle'): + await fut + + # Test that it's OK to call terminate again + self.con.terminate() + + async def test_prepare_08_big_result(self): + stmt = await self.con.prepare('select generate_series(0,10000)') + result = await stmt.fetch() + + self.assertEqual(len(result), 10001) + self.assertEqual( + [r[0] for r in result], + list(range(10001))) + + async def test_prepare_09_raise_error(self): + # Stress test ReadBuffer.read_cstr() + msg = '0' * 1024 * 100 + query = """ + DO language plpgsql $$ + BEGIN + RAISE EXCEPTION '{}'; + END + $$;""".format(msg) + + stmt = await self.con.prepare(query) + with self.assertRaisesRegex(asyncpg.RaiseError, msg): + with tb.silence_asyncio_long_exec_warning(): + await stmt.fetchval() + + async def test_prepare_10_stmt_lru(self): + query = 'select {}' + cache_max = self.con._stmt_cache_max_size + iter_max = cache_max * 2 + 11 + + # First, we have no cached statements. + self.assertEqual(len(self.con._stmt_cache), 0) + + stmts = [] + for i in range(iter_max): + s = await self.con.prepare(query.format(i)) + self.assertEqual(await s.fetchval(), i) + stmts.append(s) + + # At this point our cache should be full. + self.assertEqual(len(self.con._stmt_cache), cache_max) + self.assertTrue( + all(not s.closed for s in self.con._stmt_cache.values())) + + # Since there are references to the statements (`stmts` list), + # no statements are scheduled to be closed. + self.assertEqual(len(self.con._stmts_to_close), 0) + + # Removing refs to statements and preparing a new statement + # will cause connection to cleanup any stale statements. + stmts.clear() + gc.collect() + + # Now we have a bunch of statements that have no refs to them + # scheduled to be closed. + self.assertEqual(len(self.con._stmts_to_close), iter_max - cache_max) + self.assertTrue(all(s.closed for s in self.con._stmts_to_close)) + self.assertTrue( + all(not s.closed for s in self.con._stmt_cache.values())) + + zero = await self.con.prepare(query.format(0)) + # Hence, all stale statements should be closed now. + self.assertEqual(len(self.con._stmts_to_close), 0) + + # The number of cached statements will stay the same though. + self.assertEqual(len(self.con._stmt_cache), cache_max) + self.assertTrue( + all(not s.closed for s in self.con._stmt_cache.values())) + + # After closing all statements will be closed. + await self.con.close() + self.assertEqual(len(self.con._stmts_to_close), 0) + self.assertEqual(len(self.con._stmt_cache), 0) + + # An attempt to perform an operation on a closed statement + # will trigger an error. + with self.assertRaisesRegex(asyncpg.InterfaceError, 'is closed'): + await zero.fetchval() + + async def test_prepare_11_stmt_gc(self): + # Test that prepared statements should stay in the cache after + # they are GCed. + + # First, we have no cached statements. + self.assertEqual(len(self.con._stmt_cache), 0) + self.assertEqual(len(self.con._stmts_to_close), 0) + + # The prepared statement that we'll create will be GCed + # right await. However, its state should be still in + # in the statements LRU cache. + await self.con.prepare('select 1') + gc.collect() + + self.assertEqual(len(self.con._stmt_cache), 1) + self.assertEqual(len(self.con._stmts_to_close), 0) + + async def test_prepare_12_stmt_gc(self): + # Test that prepared statements are closed when there is no space + # for them in the LRU cache and there are no references to them. + + # First, we have no cached statements. + self.assertEqual(len(self.con._stmt_cache), 0) + self.assertEqual(len(self.con._stmts_to_close), 0) + + cache_max = self.con._stmt_cache_max_size + + stmt = await self.con.prepare('select 100000000') + self.assertEqual(len(self.con._stmt_cache), 1) + self.assertEqual(len(self.con._stmts_to_close), 0) + + for i in range(cache_max): + await self.con.prepare('select {}'.format(i)) + + self.assertEqual(len(self.con._stmt_cache), cache_max) + self.assertEqual(len(self.con._stmts_to_close), 0) + + del stmt + gc.collect() + + self.assertEqual(len(self.con._stmt_cache), cache_max) + self.assertEqual(len(self.con._stmts_to_close), 1) + + async def test_prepare_13_connect(self): + v = await self.con.fetchval( + 'SELECT $1::smallint AS foo', 10, column='foo') + self.assertEqual(v, 10) + + r = await self.con.fetchrow('SELECT $1::smallint * 2 AS test', 10) + self.assertEqual(r['test'], 20) + + rows = await self.con.fetch('SELECT generate_series(0,$1::int)', 3) + self.assertEqual([r[0] for r in rows], [0, 1, 2, 3]) + + async def test_prepare_14_explain(self): + # Test simple EXPLAIN. + stmt = await self.con.prepare('SELECT typname FROM pg_type') + plan = await stmt.explain() + self.assertEqual(plan[0]['Plan']['Relation Name'], 'pg_type') + + # Test "EXPLAIN ANALYZE". + stmt = await self.con.prepare( + 'SELECT typname, typlen FROM pg_type WHERE typlen > $1') + plan = await stmt.explain(2, analyze=True) + self.assertEqual(plan[0]['Plan']['Relation Name'], 'pg_type') + self.assertIn('Actual Total Time', plan[0]['Plan']) + + # Test that 'EXPLAIN ANALYZE' is executed in a transaction + # that gets rollbacked. + tr = self.con.transaction() + await tr.start() + try: + await self.con.execute('CREATE TABLE mytab (a int)') + stmt = await self.con.prepare( + 'INSERT INTO mytab (a) VALUES (1), (2)') + plan = await stmt.explain(analyze=True) + self.assertEqual(plan[0]['Plan']['Operation'], 'Insert') + + # Check that no data was inserted + res = await self.con.fetch('SELECT * FROM mytab') + self.assertEqual(res, []) + finally: + await tr.rollback() + + async def test_prepare_15_stmt_gc_cache_disabled(self): + # Test that even if the statements cache is off, we're still + # cleaning up GCed statements. + + self.assertEqual(len(self.con._stmt_cache), 0) + self.assertEqual(len(self.con._stmts_to_close), 0) + # Disable cache + self.con._stmt_cache_max_size = 0 + + stmt = await self.con.prepare('select 100000000') + self.assertEqual(len(self.con._stmt_cache), 0) + self.assertEqual(len(self.con._stmts_to_close), 0) + + del stmt + gc.collect() + + # After GC, _stmts_to_close should contain stmt's state + self.assertEqual(len(self.con._stmt_cache), 0) + self.assertEqual(len(self.con._stmts_to_close), 1) + + # Next "prepare" call will trigger a cleanup + stmt = await self.con.prepare('select 1') + self.assertEqual(len(self.con._stmt_cache), 0) + self.assertEqual(len(self.con._stmts_to_close), 0) + + del stmt + + async def test_prepare_16_command_result(self): + async def status(query): + stmt = await self.con.prepare(query) + await stmt.fetch() + return stmt.get_statusmsg() + + try: + self.assertEqual( + await status('CREATE TABLE mytab (a int)'), + 'CREATE TABLE') + + self.assertEqual( + await status('INSERT INTO mytab (a) VALUES (1), (2)'), + 'INSERT 0 2') + + self.assertEqual( + await status('SELECT a FROM mytab'), + 'SELECT 2') + + self.assertEqual( + await status('UPDATE mytab SET a = 3 WHERE a = 1'), + 'UPDATE 1') + finally: + self.assertEqual( + await status('DROP TABLE mytab'), + 'DROP TABLE') + + async def test_prepare_17_stmt_closed_lru(self): + st = await self.con.prepare('SELECT 1') + st._state.mark_closed() + with self.assertRaisesRegex(asyncpg.InterfaceError, 'is closed'): + await st.fetch() + + st = await self.con.prepare('SELECT 1') + self.assertEqual(await st.fetchval(), 1) + + async def test_prepare_18_empty_result(self): + # test EmptyQueryResponse protocol message + st = await self.con.prepare('') + self.assertEqual(await st.fetch(), []) + self.assertIsNone(await st.fetchval()) + self.assertIsNone(await st.fetchrow()) + + self.assertEqual(await self.con.fetch(''), []) + self.assertIsNone(await self.con.fetchval('')) + self.assertIsNone(await self.con.fetchrow('')) + + async def test_prepare_19_concurrent_calls(self): + st = self.loop.create_task(self.con.fetchval( + 'SELECT ROW(pg_sleep(0.03), 1)')) + + # Wait for some time to make sure the first query is fully + # prepared (!) and is now awaiting the results (!!). + await asyncio.sleep(0.01, loop=self.loop) + + with self.assertRaisesRegex(asyncpg.InterfaceError, + 'another operation'): + await self.con.execute('SELECT 2') + + self.assertEqual(await st, (None, 1)) + + async def test_prepare_20_concurrent_calls(self): + expected = ((None, 1),) + + for methname, val in [('fetch', [expected]), + ('fetchval', expected[0]), + ('fetchrow', expected)]: + + with self.subTest(meth=methname): + + meth = getattr(self.con, methname) + + vf = self.loop.create_task( + meth('SELECT ROW(pg_sleep(0.03), 1)')) + + await asyncio.sleep(0.01, loop=self.loop) + + with self.assertRaisesRegex(asyncpg.InterfaceError, + 'another operation'): + await meth('SELECT 2') + + self.assertEqual(await vf, val) + + async def test_prepare_21_errors(self): + stmt = await self.con.prepare('SELECT 10 / $1::int') + + with self.assertRaises(asyncpg.DivisionByZeroError): + await stmt.fetchval(0) + + self.assertEqual(await stmt.fetchval(5), 2) + + async def test_prepare_22_empty(self): + # Support for empty target list was added in PostgreSQL 9.4 + if self.server_version < (9, 4): + raise unittest.SkipTest( + 'PostgreSQL servers < 9.4 do not support empty target list.') + + result = await self.con.fetchrow('SELECT') + self.assertEqual(result, ()) + self.assertEqual(repr(result), '') diff --git a/tests/test_record.py b/tests/test_record.py new file mode 100644 index 0000000..1ee1f8f --- /dev/null +++ b/tests/test_record.py @@ -0,0 +1,299 @@ +# Copyright (C) 2016-present the ayncpg authors and contributors +# +# +# This module is part of asyncpg and is released under +# the Apache 2.0 License: http://www.apache.org/licenses/LICENSE-2.0 + + +import contextlib +import collections +import gc +import pickle +import sys + +from asyncpg import _testbase as tb +from asyncpg.protocol.protocol import _create_record as Record + + +R_A = collections.OrderedDict([('a', 0)]) +R_AB = collections.OrderedDict([('a', 0), ('b', 1)]) +R_AC = collections.OrderedDict([('a', 0), ('c', 1)]) +R_ABC = collections.OrderedDict([('a', 0), ('b', 1), ('c', 2)]) + + +class TestRecord(tb.ConnectedTestCase): + + @contextlib.contextmanager + def checkref(self, *objs): + cnt = [sys.getrefcount(objs[i]) for i in range(len(objs))] + yield + for _ in range(3): + gc.collect() + for i in range(len(objs)): + before = cnt[i] + after = sys.getrefcount(objs[i]) + if before != after: + self.fail('refcounts differ for {!r}: {:+}'.format( + objs[i], after - before)) + + def test_record_gc(self): + elem = object() + mapping = {} + with self.checkref(mapping, elem): + r = Record(mapping, (elem,)) + del r + + key = 'spam' + val = int('101010') + mapping = {key: val} + with self.checkref(key, val): + r = Record(mapping, (0,)) + with self.assertRaises(KeyError): + r[key] + del r + + key = 'spam' + val = 'ham' + mapping = {key: val} + with self.checkref(key, val): + r = Record(mapping, (0,)) + with self.assertRaises(KeyError): + r[key] + del r + + def test_record_freelist_ok(self): + for _ in range(10000): + Record(R_A, (42,)) + Record(R_AB, (42, 42,)) + + def test_record_len_getindex(self): + r = Record(R_A, (42,)) + self.assertEqual(len(r), 1) + self.assertEqual(r[0], 42) + self.assertEqual(r['a'], 42) + + r = Record(R_AB, (42, 43)) + self.assertEqual(len(r), 2) + self.assertEqual(r[0], 42) + self.assertEqual(r[1], 43) + self.assertEqual(r['a'], 42) + self.assertEqual(r['b'], 43) + + with self.assertRaisesRegex(IndexError, + 'record index out of range'): + r[1000] + + with self.assertRaisesRegex(KeyError, 'spam'): + r['spam'] + + with self.assertRaisesRegex(KeyError, 'spam'): + Record(None, (1,))['spam'] + + with self.assertRaisesRegex(KeyError, 'spam'): + Record({'spam': 123}, (1,))['spam'] + + def test_record_slice(self): + r = Record(R_ABC, (1, 2, 3)) + self.assertEqual(r[:], (1, 2, 3)) + self.assertEqual(r[:1], (1,)) + self.assertEqual(r[::-1], (3, 2, 1)) + self.assertEqual(r[::-2], (3, 1)) + self.assertEqual(r[1:2], (2,)) + self.assertEqual(r[2:2], ()) + + def test_record_immutable(self): + r = Record(R_A, (42,)) + with self.assertRaisesRegex(TypeError, 'does not support item'): + r[0] = 1 + + def test_record_repr(self): + self.assertEqual( + repr(Record(R_A, (42,))), + '') + + self.assertEqual( + repr(Record(R_AB, (42, -1))), + '') + + # test invalid records just in case + with self.assertRaisesRegex(RuntimeError, 'invalid .* mapping'): + repr(Record(R_A, (42, 43))) + self.assertEqual(repr(Record(R_AB, (42,))), '') + + class Key: + def __str__(self): + 1 / 0 + + def __repr__(self): + 1 / 0 + + with self.assertRaises(ZeroDivisionError): + repr(Record({Key(): 0}, (42,))) + with self.assertRaises(ZeroDivisionError): + repr(Record(R_A, (Key(),))) + + def test_record_iter(self): + r = Record(R_AB, (42, 43)) + with self.checkref(r): + self.assertEqual(iter(r).__length_hint__(), 2) + self.assertEqual(tuple(r), (42, 43)) + + def test_record_values(self): + r = Record(R_AB, (42, 43)) + vv = r.values() + self.assertEqual(tuple(vv), (42, 43)) + self.assertTrue(repr(vv).startswith('') + self.assertEqual(str(r), '') + with self.assertRaisesRegex(KeyError, 'aaa'): + r['aaa'] + self.assertEqual(dict(r.items()), {}) + self.assertEqual(list(r.keys()), []) + self.assertEqual(list(r.values()), []) + + async def test_record_duplicate_colnames(self): + """Test that Record handles duplicate column names.""" + r = await self.con.fetchrow('SELECT 1 as a, 2 as a') + self.assertEqual(r['a'], 2) + self.assertEqual(r[0], 1) + self.assertEqual(repr(r), '') diff --git a/tests/test_test.py b/tests/test_test.py new file mode 100644 index 0000000..de19d30 --- /dev/null +++ b/tests/test_test.py @@ -0,0 +1,35 @@ +# Copyright (C) 2016-present the ayncpg authors and contributors +# +# +# This module is part of asyncpg and is released under +# the Apache 2.0 License: http://www.apache.org/licenses/LICENSE-2.0 + + +import asyncio +import types +import unittest + + +from asyncpg import _testbase as tb + + +class BaseSimpleTestCase: + + async def test_tests_zero_error(self): + await asyncio.sleep(0.01, loop=self.loop) + 1 / 0 + + +class TestTests(unittest.TestCase): + + def test_tests_fail_1(self): + SimpleTestCase = types.new_class('SimpleTestCase', + (BaseSimpleTestCase, tb.TestCase)) + + suite = unittest.TestSuite() + suite.addTest(SimpleTestCase('test_tests_zero_error')) + + result = unittest.TestResult() + suite.run(result) + + self.assertIn('ZeroDivisionError', result.errors[0][1]) diff --git a/tests/test_timeout.py b/tests/test_timeout.py new file mode 100644 index 0000000..5b0b3ad --- /dev/null +++ b/tests/test_timeout.py @@ -0,0 +1,125 @@ +# Copyright (C) 2016-present the ayncpg authors and contributors +# +# +# This module is part of asyncpg and is released under +# the Apache 2.0 License: http://www.apache.org/licenses/LICENSE-2.0 + + +import asyncio +import asyncpg + +from asyncpg import _testbase as tb + + +MAX_RUNTIME = 0.5 + + +class TestTimeout(tb.ConnectedTestCase): + + async def test_timeout_01(self): + for methname in {'fetch', 'fetchrow', 'fetchval', 'execute'}: + with self.assertRaises(asyncio.TimeoutError), \ + self.assertRunUnder(MAX_RUNTIME): + meth = getattr(self.con, methname) + await meth('select pg_sleep(10)', timeout=0.02) + self.assertEqual(await self.con.fetch('select 1'), [(1,)]) + + async def test_timeout_02(self): + st = await self.con.prepare('select pg_sleep(10)') + + for methname in {'fetch', 'fetchrow', 'fetchval'}: + with self.assertRaises(asyncio.TimeoutError), \ + self.assertRunUnder(MAX_RUNTIME): + meth = getattr(st, methname) + await meth(timeout=0.02) + self.assertEqual(await self.con.fetch('select 1'), [(1,)]) + + async def test_timeout_03(self): + task = self.loop.create_task( + self.con.fetch('select pg_sleep(10)', timeout=0.2)) + await asyncio.sleep(0.05, loop=self.loop) + task.cancel() + with self.assertRaises(asyncio.CancelledError), \ + self.assertRunUnder(MAX_RUNTIME): + await task + self.assertEqual(await self.con.fetch('select 1'), [(1,)]) + + async def test_timeout_04(self): + st = await self.con.prepare('select pg_sleep(10)', timeout=0.1) + with self.assertRaises(asyncio.TimeoutError), \ + self.assertRunUnder(MAX_RUNTIME): + async with self.con.transaction(): + async for _ in st.cursor(timeout=0.1): # NOQA + pass + self.assertEqual(await self.con.fetch('select 1'), [(1,)]) + + st = await self.con.prepare('select pg_sleep(10)', timeout=0.1) + async with self.con.transaction(): + cur = await st.cursor() + with self.assertRaises(asyncio.TimeoutError), \ + self.assertRunUnder(MAX_RUNTIME): + await cur.fetch(1, timeout=0.1) + self.assertEqual(await self.con.fetch('select 1'), [(1,)]) + + async def test_timeout_05(self): + # Stress-test timeouts - try to trigger a race condition + # between a cancellation request to Postgres and next + # query (SELECT 1) + for _ in range(500): + with self.assertRaises(asyncio.TimeoutError): + await self.con.fetch('SELECT pg_sleep(1)', timeout=1e-10) + self.assertEqual(await self.con.fetch('SELECT 1'), [(1,)]) + + async def test_timeout_06(self): + async with self.con.transaction(): + with self.assertRaises(asyncio.TimeoutError), \ + self.assertRunUnder(MAX_RUNTIME): + async for _ in self.con.cursor( # NOQA + 'select pg_sleep(10)', timeout=0.1): + pass + self.assertEqual(await self.con.fetch('select 1'), [(1,)]) + + async with self.con.transaction(): + cur = await self.con.cursor('select pg_sleep(10)') + with self.assertRaises(asyncio.TimeoutError), \ + self.assertRunUnder(MAX_RUNTIME): + await cur.fetch(1, timeout=0.1) + + async with self.con.transaction(): + cur = await self.con.cursor('select pg_sleep(10)') + with self.assertRaises(asyncio.TimeoutError), \ + self.assertRunUnder(MAX_RUNTIME): + await cur.forward(1, timeout=1e-10) + + async with self.con.transaction(): + cur = await self.con.cursor('select pg_sleep(10)') + with self.assertRaises(asyncio.TimeoutError), \ + self.assertRunUnder(MAX_RUNTIME): + await cur.fetchrow(timeout=0.1) + + async with self.con.transaction(): + cur = await self.con.cursor('select pg_sleep(10)') + with self.assertRaises(asyncio.TimeoutError), \ + self.assertRunUnder(MAX_RUNTIME): + await cur.fetchrow(timeout=0.1) + + with self.assertRaises(asyncpg.InFailedSQLTransactionError): + await cur.fetch(1) + + self.assertEqual(await self.con.fetch('select 1'), [(1,)]) + + +class TestConnectionCommandTimeout(tb.ConnectedTestCase): + + def getExtraConnectOptions(self): + return { + 'command_timeout': 0.02 + } + + async def test_command_timeout_01(self): + for methname in {'fetch', 'fetchrow', 'fetchval', 'execute'}: + with self.assertRaises(asyncio.TimeoutError), \ + self.assertRunUnder(MAX_RUNTIME): + meth = getattr(self.con, methname) + await meth('select pg_sleep(10)') + self.assertEqual(await self.con.fetch('select 1'), [(1,)]) diff --git a/tests/test_transaction.py b/tests/test_transaction.py new file mode 100644 index 0000000..2f60637 --- /dev/null +++ b/tests/test_transaction.py @@ -0,0 +1,141 @@ +# Copyright (C) 2016-present the ayncpg authors and contributors +# +# +# This module is part of asyncpg and is released under +# the Apache 2.0 License: http://www.apache.org/licenses/LICENSE-2.0 + + +import asyncpg + +from asyncpg import _testbase as tb + + +class TestTransaction(tb.ConnectedTestCase): + + async def test_transaction_regular(self): + self.assertIsNone(self.con._top_xact) + tr = self.con.transaction() + self.assertIsNone(self.con._top_xact) + + with self.assertRaises(ZeroDivisionError): + async with tr as with_tr: + self.assertIs(self.con._top_xact, tr) + + # We don't return the transaction object from __aenter__, + # to make it harder for people to use '.rollback()' and + # '.commit()' from within an 'async with' block. + self.assertIsNone(with_tr) + + await self.con.execute(''' + CREATE TABLE mytab (a int); + ''') + + 1 / 0 + + self.assertIsNone(self.con._top_xact) + + with self.assertRaisesRegex(asyncpg.PostgresError, + '"mytab" does not exist'): + await self.con.prepare(''' + SELECT * FROM mytab + ''') + + async def test_transaction_nested(self): + self.assertIsNone(self.con._top_xact) + tr = self.con.transaction() + self.assertIsNone(self.con._top_xact) + + with self.assertRaises(ZeroDivisionError): + async with tr: + self.assertIs(self.con._top_xact, tr) + + await self.con.execute(''' + CREATE TABLE mytab (a int); + ''') + + async with self.con.transaction(): + self.assertIs(self.con._top_xact, tr) + + await self.con.execute(''' + INSERT INTO mytab (a) VALUES (1), (2); + ''') + + self.assertIs(self.con._top_xact, tr) + + with self.assertRaises(ZeroDivisionError): + in_tr = self.con.transaction() + async with in_tr: + + self.assertIs(self.con._top_xact, tr) + + await self.con.execute(''' + INSERT INTO mytab (a) VALUES (3), (4); + ''') + + 1 / 0 + + st = await self.con.prepare('SELECT * FROM mytab;') + + recs = [] + async for rec in st.cursor(): + recs.append(rec) + + self.assertEqual(len(recs), 2) + self.assertEqual(recs[0][0], 1) + self.assertEqual(recs[1][0], 2) + + self.assertIs(self.con._top_xact, tr) + + 1 / 0 + + self.assertIs(self.con._top_xact, None) + + with self.assertRaisesRegex(asyncpg.PostgresError, + '"mytab" does not exist'): + await self.con.prepare(''' + SELECT * FROM mytab + ''') + + async def test_transaction_interface_errors(self): + self.assertIsNone(self.con._top_xact) + + tr = self.con.transaction(readonly=True, isolation='serializable') + with self.assertRaisesRegex(asyncpg.InterfaceError, + 'cannot start; .* already started'): + async with tr: + await tr.start() + + self.assertTrue(repr(tr).startswith( + '