1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
|
import random
from sqlalchemy import Column
from sqlalchemy import exc
from sqlalchemy import Integer
from sqlalchemy import MetaData
from sqlalchemy import String
from sqlalchemy import Table
from sqlalchemy import testing
from sqlalchemy.dialects.postgresql import ENUM
from sqlalchemy.ext.asyncio import create_async_engine
from sqlalchemy.testing import async_test
from sqlalchemy.testing import engines
from sqlalchemy.testing import fixtures
class AsyncPgTest(fixtures.TestBase):
__requires__ = ("async_dialect",)
__only_on__ = "postgresql+asyncpg"
@testing.fixture
def async_engine(self):
return create_async_engine(testing.db.url)
@testing.fixture()
def metadata(self):
# TODO: remove when Iae6ab95938a7e92b6d42086aec534af27b5577d3
# merges
from sqlalchemy.testing import engines
from sqlalchemy.sql import schema
metadata = schema.MetaData()
try:
yield metadata
finally:
engines.drop_all_tables(metadata, testing.db)
@async_test
async def test_detect_stale_ddl_cache_raise_recover(
self, metadata, async_engine
):
async def async_setup(engine, strlen):
metadata.clear()
t1 = Table(
"t1",
metadata,
Column("id", Integer, primary_key=True),
Column("name", String(strlen)),
)
# conn is an instance of AsyncConnection
async with engine.begin() as conn:
await conn.run_sync(metadata.drop_all)
await conn.run_sync(metadata.create_all)
await conn.execute(
t1.insert(),
[{"name": "some name %d" % i} for i in range(500)],
)
meta = MetaData()
t1 = Table(
"t1",
meta,
Column("id", Integer, primary_key=True),
Column("name", String),
)
await async_setup(async_engine, 30)
second_engine = engines.testing_engine(asyncio=True)
async with second_engine.connect() as conn:
result = await conn.execute(
t1.select()
.where(t1.c.name.like("some name%"))
.where(t1.c.id % 17 == 6)
)
rows = result.fetchall()
assert len(rows) >= 29
await async_setup(async_engine, 20)
async with second_engine.connect() as conn:
with testing.expect_raises_message(
exc.NotSupportedError,
r"cached statement plan is invalid due to a database schema "
r"or configuration change \(SQLAlchemy asyncpg dialect "
r"will now invalidate all prepared caches in response "
r"to this exception\)",
):
result = await conn.execute(
t1.select()
.where(t1.c.name.like("some name%"))
.where(t1.c.id % 17 == 6)
)
# works again
async with second_engine.connect() as conn:
result = await conn.execute(
t1.select()
.where(t1.c.name.like("some name%"))
.where(t1.c.id % 17 == 6)
)
rows = result.fetchall()
assert len(rows) >= 29
@async_test
async def test_detect_stale_type_cache_raise_recover(
self, metadata, async_engine
):
async def async_setup(engine, enums):
metadata = MetaData()
Table(
"t1",
metadata,
Column("id", Integer, primary_key=True),
Column("name", ENUM(*enums, name="my_enum")),
)
# conn is an instance of AsyncConnection
async with engine.begin() as conn:
await conn.run_sync(metadata.drop_all)
await conn.run_sync(metadata.create_all)
t1 = Table(
"t1",
metadata,
Column("id", Integer, primary_key=True),
Column(
"name",
ENUM(
*("beans", "means", "keens", "faux", "beau", "flow"),
name="my_enum"
),
),
)
await async_setup(async_engine, ("beans", "means", "keens"))
second_engine = engines.testing_engine(
asyncio=True,
options={"connect_args": {"prepared_statement_cache_size": 0}},
)
async with second_engine.connect() as conn:
await conn.execute(
t1.insert(),
[
{"name": random.choice(("beans", "means", "keens"))}
for i in range(10)
],
)
await async_setup(async_engine, ("faux", "beau", "flow"))
async with second_engine.connect() as conn:
with testing.expect_raises_message(
exc.InternalError, "cache lookup failed for type"
):
await conn.execute(
t1.insert(),
[
{"name": random.choice(("faux", "beau", "flow"))}
for i in range(10)
],
)
# works again
async with second_engine.connect() as conn:
await conn.execute(
t1.insert(),
[
{"name": random.choice(("faux", "beau", "flow"))}
for i in range(10)
],
)
|
