async def run_transaction():
try:
async with Band._meta.db.transaction():
Manager.create_table()
Band.create_table()
Band.raw("MALFORMED QUERY ... SHOULD ERROR")
except Exception:
pass
def test_set_default(self):
Manager.alter().set_default(Manager.name, "Pending").run_sync()
# Bypassing the ORM to make sure the database default is present.
Band.raw("INSERT INTO manager (id, name) VALUES (DEFAULT, DEFAULT);"
).run_sync()
manager = Manager.objects().first().run_sync()
self.assertEqual(manager.name, "Pending")
def test_set_null(self):
query = """
SELECT is_nullable FROM information_schema.columns
WHERE table_name = 'band'
AND table_catalog = 'piccolo'
AND column_name = 'popularity'
"""
Band.alter().set_null(Band.popularity, boolean=True).run_sync()
response = Band.raw(query).run_sync()
self.assertEqual(response[0]["is_nullable"], "YES")
Band.alter().set_null(Band.popularity, boolean=False).run_sync()
response = Band.raw(query).run_sync()
self.assertEqual(response[0]["is_nullable"], "NO")
def _test_drop(self, column: str):
self.insert_row()
Band.alter().drop_column(column).run_sync()
response = Band.raw("SELECT * FROM band").run_sync()
column_names = response[0].keys()
self.assertNotIn("popularity", column_names)
def test_raw_without_args(self):
self.insert_row()
response = Band.raw("select * from band").run_sync()
self.assertDictEqual(
response[0],
{"id": 1, "name": "Pythonistas", "manager": 1, "popularity": 1000},
)
def _test_add_column(self, column: Column, column_name: str,
expected_value: t.Any):
self.insert_row()
Band.alter().add_column(column_name, column).run_sync()
response = Band.raw("SELECT * FROM band").run_sync()
column_names = response[0].keys()
self.assertIn(column_name, column_names)
self.assertEqual(response[0][column_name], expected_value)
def test_set_length(self):
query = """
SELECT character_maximum_length FROM information_schema.columns
WHERE table_name = 'band'
AND table_catalog = 'piccolo'
AND column_name = 'name'
"""
for length in (5, 20, 50):
Band.alter().set_length(Band.name, length=length).run_sync()
response = Band.raw(query).run_sync()
self.assertEqual(response[0]["character_maximum_length"], length)
def test_multiple(self):
self.insert_row()
query = (Manager.alter().add_column("column_a",
Integer(default=0,
null=True)).add_column(
"column_b",
Integer(default=0,
null=True)))
query.run_sync()
response = Band.raw("SELECT * FROM manager").run_sync()
column_names = response[0].keys()
self.assertIn("column_a", column_names)
self.assertIn("column_b", column_names)
def test_error(self):
"""
Make sure queries in a transaction aren't committed if a query fails.
"""
transaction = Band._meta.db.atomic()
transaction.add(
Manager.create_table(),
Band.create_table(),
Band.raw("MALFORMED QUERY ... SHOULD ERROR"),
)
try:
transaction.run_sync()
except Exception:
pass
self.assertTrue(not Band.table_exists().run_sync())
self.assertTrue(not Manager.table_exists().run_sync())
def _test_rename(
self,
existing_column: t.Union[Column, str],
new_column_name: str = "rating",
):
self.insert_row()
rename_query = Band.alter().rename_column(existing_column,
new_column_name)
rename_query.run_sync()
select_query = Band.raw("SELECT * FROM band")
response = select_query.run_sync()
column_names = response[0].keys()
existing_column_name = (existing_column._meta.name if isinstance(
existing_column, Column) else existing_column)
self.assertTrue((new_column_name in column_names)
and (existing_column_name not in column_names))
def test_rename(self):
Band.alter().rename_table("act").run_sync()
self.assertEqual(Band.raw("SELECT * FROM act").run_sync(), [])
