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_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_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_succeeds(self):
transaction = Band._meta.db.atomic()
transaction.add(Manager.create_table(), Band.create_table())
transaction.run_sync()
self.assertTrue(Band.table_exists().run_sync())
self.assertTrue(Manager.table_exists().run_sync())
transaction.add(Band.alter().drop_table(),
Manager.alter().drop_table())
transaction.run_sync()
def test_using_expression(self):
"""
Test the `using_expression` option, which can be used to tell Postgres
how to convert certain column types.
"""
Band(name="1").save().run_sync()
alter_query = Band.alter().set_column_type(
old_column=Band.name,
new_column=Integer(),
using_expression="name::integer",
)
alter_query.run_sync()
popularity = Band.select(Band.name).first().run_sync()["name"]
self.assertEqual(popularity, 1)
def test_integer_to_varchar(self):
"""
Test converting an Integer column to Varchar.
"""
self.insert_row()
alter_query = Band.alter().set_column_type(old_column=Band.popularity,
new_column=Varchar())
alter_query.run_sync()
self.assertEqual(
self.get_postgres_column_type(tablename="band",
column_name="popularity"),
"CHARACTER VARYING",
)
popularity = (Band.select(
Band.popularity).first().run_sync()["popularity"])
self.assertEqual(popularity, "1000")
def test_integer_to_bigint(self):
"""
Test converting an Integer column to BigInt.
"""
self.insert_row()
alter_query = Band.alter().set_column_type(old_column=Band.popularity,
new_column=BigInt())
alter_query.run_sync()
self.assertEqual(
self.get_postgres_column_type(tablename="band",
column_name="popularity"),
"BIGINT",
)
popularity = (Band.select(
Band.popularity).first().run_sync()["popularity"])
self.assertEqual(popularity, 1000)
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(), [])
def tearDown(self) -> None:
Band.alter().drop_table(if_exists=True).run_sync()
Manager.alter().drop_table(if_exists=True).run_sync()
