mirror of
https://github.com/django/django.git
synced 2024-11-22 11:57:34 +01:00
189 lines
7.4 KiB
Python
189 lines
7.4 KiB
Python
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")
|
|
|
|
# Silence "Truncated incorrect CHAR(1) value: 'Bob'".
|
|
@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",
|
|
)
|