| import datetime |
| import decimal |
| import unittest |
|
|
| from django.db import connection, models |
| from django.db.models.functions import Cast |
| from django.test import TestCase, ignore_warnings, skipUnlessDBFeature |
| from django.test.utils import CaptureQueriesContext |
|
|
| from ..models import Author, DTModel, Fan, FloatModel |
|
|
|
|
| class CastTests(TestCase): |
| @classmethod |
| def setUpTestData(self): |
| Author.objects.create(name="Bob", age=1, alias="1") |
|
|
| def test_cast_from_value(self): |
| numbers = Author.objects.annotate( |
| cast_integer=Cast(models.Value("0"), models.IntegerField()) |
| ) |
| self.assertEqual(numbers.get().cast_integer, 0) |
|
|
| def test_cast_from_field(self): |
| numbers = Author.objects.annotate( |
| cast_string=Cast("age", models.CharField(max_length=255)), |
| ) |
| self.assertEqual(numbers.get().cast_string, "1") |
|
|
| def test_cast_to_char_field_without_max_length(self): |
| numbers = Author.objects.annotate(cast_string=Cast("age", models.CharField())) |
| self.assertEqual(numbers.get().cast_string, "1") |
|
|
| |
| @ignore_warnings(module="django.db.backends.mysql.base") |
| @skipUnlessDBFeature("supports_cast_with_precision") |
| def test_cast_to_char_field_with_max_length(self): |
| names = Author.objects.annotate( |
| cast_string=Cast("name", models.CharField(max_length=1)) |
| ) |
| self.assertEqual(names.get().cast_string, "B") |
|
|
| @skipUnlessDBFeature("supports_cast_with_precision") |
| def test_cast_to_decimal_field(self): |
| FloatModel.objects.create(f1=-1.934, f2=3.467) |
| float_obj = FloatModel.objects.annotate( |
| cast_f1_decimal=Cast( |
| "f1", models.DecimalField(max_digits=8, decimal_places=2) |
| ), |
| cast_f2_decimal=Cast( |
| "f2", models.DecimalField(max_digits=8, decimal_places=1) |
| ), |
| ).get() |
| self.assertEqual(float_obj.cast_f1_decimal, decimal.Decimal("-1.93")) |
| self.assertEqual(float_obj.cast_f2_decimal, decimal.Decimal("3.5")) |
| author_obj = Author.objects.annotate( |
| cast_alias_decimal=Cast( |
| "alias", models.DecimalField(max_digits=8, decimal_places=2) |
| ), |
| ).get() |
| self.assertEqual(author_obj.cast_alias_decimal, decimal.Decimal("1")) |
|
|
| def test_cast_to_integer(self): |
| for field_class in ( |
| models.AutoField, |
| models.BigAutoField, |
| models.SmallAutoField, |
| models.IntegerField, |
| models.BigIntegerField, |
| models.SmallIntegerField, |
| models.PositiveBigIntegerField, |
| models.PositiveIntegerField, |
| models.PositiveSmallIntegerField, |
| ): |
| with self.subTest(field_class=field_class): |
| numbers = Author.objects.annotate(cast_int=Cast("alias", field_class())) |
| self.assertEqual(numbers.get().cast_int, 1) |
|
|
| def test_cast_to_integer_foreign_key(self): |
| numbers = Author.objects.annotate( |
| cast_fk=Cast( |
| models.Value("0"), |
| models.ForeignKey(Author, on_delete=models.SET_NULL), |
| ) |
| ) |
| self.assertEqual(numbers.get().cast_fk, 0) |
|
|
| def test_cast_to_duration(self): |
| duration = datetime.timedelta(days=1, seconds=2, microseconds=3) |
| DTModel.objects.create(duration=duration) |
| dtm = DTModel.objects.annotate( |
| cast_duration=Cast("duration", models.DurationField()), |
| cast_neg_duration=Cast(-duration, models.DurationField()), |
| ).get() |
| self.assertEqual(dtm.cast_duration, duration) |
| self.assertEqual(dtm.cast_neg_duration, -duration) |
|
|
| def test_cast_from_db_datetime_to_date(self): |
| dt_value = datetime.datetime(2018, 9, 28, 12, 42, 10, 234567) |
| DTModel.objects.create(start_datetime=dt_value) |
| dtm = DTModel.objects.annotate( |
| start_datetime_as_date=Cast("start_datetime", models.DateField()) |
| ).first() |
| self.assertEqual(dtm.start_datetime_as_date, datetime.date(2018, 9, 28)) |
|
|
| def test_cast_from_db_datetime_to_time(self): |
| dt_value = datetime.datetime(2018, 9, 28, 12, 42, 10, 234567) |
| DTModel.objects.create(start_datetime=dt_value) |
| dtm = DTModel.objects.annotate( |
| start_datetime_as_time=Cast("start_datetime", models.TimeField()) |
| ).first() |
| rounded_ms = int( |
| round(0.234567, connection.features.time_cast_precision) * 10**6 |
| ) |
| self.assertEqual( |
| dtm.start_datetime_as_time, datetime.time(12, 42, 10, rounded_ms) |
| ) |
|
|
| def test_cast_from_db_date_to_datetime(self): |
| dt_value = datetime.date(2018, 9, 28) |
| DTModel.objects.create(start_date=dt_value) |
| dtm = DTModel.objects.annotate( |
| start_as_datetime=Cast("start_date", models.DateTimeField()) |
| ).first() |
| self.assertEqual( |
| dtm.start_as_datetime, datetime.datetime(2018, 9, 28, 0, 0, 0, 0) |
| ) |
|
|
| def test_cast_from_db_datetime_to_date_group_by(self): |
| author = Author.objects.create(name="John Smith", age=45) |
| dt_value = datetime.datetime(2018, 9, 28, 12, 42, 10, 234567) |
| Fan.objects.create(name="Margaret", age=50, author=author, fan_since=dt_value) |
| fans = ( |
| Fan.objects.values("author") |
| .annotate( |
| fan_for_day=Cast("fan_since", models.DateField()), |
| fans=models.Count("*"), |
| ) |
| .values() |
| ) |
| self.assertEqual(fans[0]["fan_for_day"], datetime.date(2018, 9, 28)) |
| self.assertEqual(fans[0]["fans"], 1) |
|
|
| def test_cast_from_python_to_date(self): |
| today = datetime.date.today() |
| dates = Author.objects.annotate(cast_date=Cast(today, models.DateField())) |
| self.assertEqual(dates.get().cast_date, today) |
|
|
| def test_cast_from_python_to_datetime(self): |
| now = datetime.datetime.now() |
| dates = Author.objects.annotate(cast_datetime=Cast(now, models.DateTimeField())) |
| time_precision = datetime.timedelta( |
| microseconds=10 ** (6 - connection.features.time_cast_precision) |
| ) |
| self.assertAlmostEqual(dates.get().cast_datetime, now, delta=time_precision) |
|
|
| def test_cast_from_python(self): |
| numbers = Author.objects.annotate( |
| cast_float=Cast(decimal.Decimal(0.125), models.FloatField()) |
| ) |
| cast_float = numbers.get().cast_float |
| self.assertIsInstance(cast_float, float) |
| self.assertEqual(cast_float, 0.125) |
|
|
| @unittest.skipUnless(connection.vendor == "postgresql", "PostgreSQL test") |
| def test_expression_wrapped_with_parentheses_on_postgresql(self): |
| """ |
| The SQL for the Cast expression is wrapped with parentheses in case |
| it's a complex expression. |
| """ |
| with CaptureQueriesContext(connection) as captured_queries: |
| list( |
| Author.objects.annotate( |
| cast_float=Cast(models.Avg("age"), models.FloatField()), |
| ) |
| ) |
| self.assertIn( |
| '(AVG("db_functions_author"."age"))::double precision', |
| captured_queries[0]["sql"], |
| ) |
|
|
| def test_cast_to_text_field(self): |
| self.assertEqual( |
| Author.objects.values_list( |
| Cast("age", models.TextField()), flat=True |
| ).get(), |
| "1", |
| ) |
|
|
