Django 2.1 - Database Functions

डेटाबेस कार्य




django

डेटाबेस कार्य

नीचे प्रलेखित कक्षाएं उपयोगकर्ताओं के लिए एक तरीका प्रदान करती हैं जो अंतर्निहित डेटाबेस द्वारा प्रदान किए गए फ़ंक्शंस का उपयोग कर सकता है, जैसे कि Django में एनोटेशन, एकत्रीकरण या फ़िल्टर। फ़ंक्शंस भी expressions , इसलिए उनका उपयोग और अन्य अभिव्यक्तियों के साथ किया जा सकता है जैसे कुल कार्य

हम प्रत्येक फ़ंक्शन के उदाहरणों में निम्नलिखित मॉडल का उपयोग करेंगे:

class Author(models.Model):
    name = models.CharField(max_length=50)
    age = models.PositiveIntegerField(null=True, blank=True)
    alias = models.CharField(max_length=50, null=True, blank=True)
    goes_by = models.CharField(max_length=50, null=True, blank=True)

हम आमतौर पर CharField लिए null=True लिए अनुमति देने की सलाह नहीं देते हैं क्योंकि यह क्षेत्र को दो "रिक्त मान" की अनुमति देता है, लेकिन यह नीचे दिए गए Coalesce उदाहरण के लिए महत्वपूर्ण है।

तुलना और रूपांतरण कार्य

Cast

class Cast(expression, output_field) [source]

output_field प्रकार को expression लिए output_field करता है output_field से एक हो।

उपयोग उदाहरण:

>>> from django.db.models import FloatField
>>> from django.db.models.functions import Cast
>>> Value.objects.create(integer=4)
>>> value = Value.objects.annotate(as_float=Cast('integer', FloatField())).get()
>>> print(value.as_float)
4.0

Coalesce

class Coalesce(*expressions, **extra) [source]

कम से कम दो फ़ील्ड नामों या अभिव्यक्तियों की सूची को स्वीकार करता है और पहला गैर-शून्य मान लौटाता है (ध्यान दें कि रिक्त स्ट्रिंग को शून्य मान नहीं माना जाता है)। प्रत्येक तर्क एक समान प्रकार का होना चाहिए, इसलिए पाठ और संख्याओं को मिलाने से डेटाबेस में त्रुटि होगी।

उपयोग के उदाहरण:

>>> # Get a screen name from least to most public
>>> from django.db.models import Sum, Value as V
>>> from django.db.models.functions import Coalesce
>>> Author.objects.create(name='Margaret Smith', goes_by='Maggie')
>>> author = Author.objects.annotate(
...    screen_name=Coalesce('alias', 'goes_by', 'name')).get()
>>> print(author.screen_name)
Maggie

>>> # Prevent an aggregate Sum() from returning None
>>> aggregated = Author.objects.aggregate(
...    combined_age=Coalesce(Sum('age'), V(0)),
...    combined_age_default=Sum('age'))
>>> print(aggregated['combined_age'])
0
>>> print(aggregated['combined_age_default'])
None

चेतावनी

MySQL पर Coalesce को दिया गया पायथन मान एक गलत प्रकार में परिवर्तित किया जा सकता है जब तक कि स्पष्ट रूप से सही डेटाबेस प्रकार में नहीं डाला जाता है:

>>> from django.db.models import DateTimeField
>>> from django.db.models.functions import Cast, Coalesce
>>> from django.utils import timezone
>>> now = timezone.now()
>>> Coalesce('updated', Cast(now, DateTimeField()))

Greatest

class Greatest(*expressions, **extra) [source]

कम से कम दो फ़ील्ड नामों या अभिव्यक्तियों की सूची को स्वीकार करता है और सबसे बड़ा मान लौटाता है। प्रत्येक तर्क एक समान प्रकार का होना चाहिए, इसलिए पाठ और संख्याओं को मिलाने से डेटाबेस में त्रुटि होगी।

उपयोग उदाहरण:

class Blog(models.Model):
    body = models.TextField()
    modified = models.DateTimeField(auto_now=True)

class Comment(models.Model):
    body = models.TextField()
    modified = models.DateTimeField(auto_now=True)
    blog = models.ForeignKey(Blog, on_delete=models.CASCADE)

>>> from django.db.models.functions import Greatest
>>> blog = Blog.objects.create(body='Greatest is the best.')
>>> comment = Comment.objects.create(body='No, Least is better.', blog=blog)
>>> comments = Comment.objects.annotate(last_updated=Greatest('modified', 'blog__modified'))
>>> annotated_comment = comments.get()

annotated_comment.last_updated blog.modified और comment.modified का सबसे हाल का blog.modified

चेतावनी

जब एक या अधिक अभिव्यक्ति null हो सकती है तो Greatest का व्यवहार डेटाबेस में भिन्न होता है:

  • PostgreSQL: Greatest बड़ा गैर-अशक्त अभिव्यक्ति लौटाएगा, या यदि सभी भाव null हैं, तो null
  • SQLite, Oracle, और MySQL: यदि कोई भी अभिव्यक्ति null , तो Greatest null वापस आ जाएगा।

यदि आप एक डिफ़ॉल्ट के रूप में प्रदान करने के लिए एक समझदार न्यूनतम मूल्य जानते हैं तो पोस्टग्रेएसक्यूएल व्यवहार को Coalesce का उपयोग करके अनुकरण किया जा सकता है।

Least

class Least(*expressions, **extra) [source]

कम से कम दो फ़ील्ड नामों या अभिव्यक्तियों की सूची को स्वीकार करता है और कम से कम मान लौटाता है। प्रत्येक तर्क एक समान प्रकार का होना चाहिए, इसलिए पाठ और संख्याओं को मिलाने से डेटाबेस में त्रुटि होगी।

चेतावनी

डेटाबेस के बीच एक या एक से अधिक अभिव्यक्ति null होने पर व्यवहार भिन्न हो सकता है:

  • PostgreSQL: सभी अभिव्यक्तियों के null होने पर Least से Least सबसे छोटी गैर-अशक्त अभिव्यक्ति, या null लौटा देगा।
  • SQLite, Oracle, और MySQL: यदि कोई भी अभिव्यक्ति null , तो Least null हो जाएगा।

यदि आप एक डिफ़ॉल्ट के रूप में प्रदान करने के लिए एक समझदार अधिकतम मूल्य जानते हैं तो पोस्टग्रेएसक्यूएल व्यवहार को Coalesce का उपयोग करके अनुकरण किया जा सकता है।

दिनांक कार्य

हम प्रत्येक फ़ंक्शन के उदाहरणों में निम्नलिखित मॉडल का उपयोग करेंगे:

class Experiment(models.Model):
    start_datetime = models.DateTimeField()
    start_date = models.DateField(null=True, blank=True)
    start_time = models.TimeField(null=True, blank=True)
    end_datetime = models.DateTimeField(null=True, blank=True)
    end_date = models.DateField(null=True, blank=True)
    end_time = models.TimeField(null=True, blank=True)

Extract

class Extract(expression, lookup_name=None, tzinfo=None, **extra) [source]

संख्या के रूप में किसी दिनांक का एक घटक निकालता है।

एक DateField , DateTimeField , TimeField , या DurationField और एक lookup_name प्रतिनिधित्व करने वाला एक expression लेता है, और एक lookup_name रूप में IntegerField द्वारा संदर्भित तिथि का हिस्सा IntegerField । Django आमतौर पर डेटाबेस के एक्स्ट्रेक्ट फ़ंक्शन का उपयोग करता है, इसलिए आप अपने डेटाबेस का समर्थन करने वाले किसी भी lookup_name उपयोग कर सकते हैं। एक tzinfo उपवर्ग, आमतौर पर pytz द्वारा प्रदान किया pytz , एक विशिष्ट समयक्षेत्र में एक मान निकालने के लिए पारित किया जा सकता है।

Django 2.0 में बदला:

DurationField लिए समर्थन जोड़ा गया था।

2015-06-15 23:30:01.000321+00:00 को देखते हुए, अंतर्निहित lookup_name s वापसी:

  • "वर्ष": 2015
  • "तिमाही": 2
  • "महीना": 6
  • "दिन": 15
  • "सप्ताह": 25
  • "सप्ताह_दिन": 2
  • "घंटा": 23
  • "मिनट": 30
  • "दूसरा": 1

यदि Australia/Melbourne जैसा एक अलग समयक्षेत्र Django में सक्रिय है, तो मान को निकाले जाने से पहले डेटाटाइम को समयक्षेत्र में बदल दिया जाता है। उपरोक्त उदाहरण तिथि में मेलबर्न के लिए समय क्षेत्र ऑफसेट +10: 00 है। इस समयक्षेत्र के सक्रिय होने पर दिए गए मान निम्न को छोड़कर ऊपर के समान होंगे:

  • "दिन": 16
  • "सप्ताह_दिन": 3
  • "घंटा": 9

week_day मान

week_day lookup_type की गणना अधिकांश डेटाबेस और पायथन के मानक कार्यों से अलग-अलग की जाती है। यह फ़ंक्शन रविवार के लिए 1 , सोमवार को 2 , शनिवार को 7 लिए वापस आएगा।

पायथन में बराबर गणना है:

>>> from datetime import datetime
>>> dt = datetime(2015, 6, 15)
>>> (dt.isoweekday() % 7) + 1
2

week मूल्य

week lookup_type की गणना ISO-8601 आधार पर की जाती है, यानी सोमवार को एक सप्ताह शुरू होता है। एक वर्ष का पहला सप्ताह वह होता है जिसमें वर्ष का पहला गुरुवार होता है, अर्थात पहले सप्ताह में वर्ष में इसके दिनों का बहुमत (चार या अधिक) होता है। लौटाया गया मान 1 से 52 या 53 की सीमा में है।

प्रत्येक lookup_name ऊपर एक समान Extract उपवर्ग (नीचे सूचीबद्ध) होता है जिसे आमतौर पर अधिक वर्बोज़ समकक्ष के बजाय उपयोग किया जाना चाहिए, जैसे Extract(..., lookup_name='year') बजाय Extract(..., lookup_name='year')

उपयोग उदाहरण:

>>> from datetime import datetime
>>> from django.db.models.functions import Extract
>>> start = datetime(2015, 6, 15)
>>> end = datetime(2015, 7, 2)
>>> Experiment.objects.create(
...    start_datetime=start, start_date=start.date(),
...    end_datetime=end, end_date=end.date())
>>> # Add the experiment start year as a field in the QuerySet.
>>> experiment = Experiment.objects.annotate(
...    start_year=Extract('start_datetime', 'year')).get()
>>> experiment.start_year
2015
>>> # How many experiments completed in the same year in which they started?
>>> Experiment.objects.filter(
...    start_datetime__year=Extract('end_datetime', 'year')).count()
1

DateField अर्क

class ExtractYear(expression, tzinfo=None, **extra) [source]
lookup_name = 'year'
class ExtractMonth(expression, tzinfo=None, **extra) [source]
lookup_name = 'month'
class ExtractDay(expression, tzinfo=None, **extra) [source]
lookup_name = 'day'
class ExtractWeekDay(expression, tzinfo=None, **extra) [source]
lookup_name = 'week_day'
class ExtractWeek(expression, tzinfo=None, **extra) [source]
lookup_name = 'week'
class ExtractQuarter(expression, tzinfo=None, **extra) [source]
Django 2.0 में नया:
lookup_name = 'quarter'

ये तार्किक रूप से Extract('date_field', lookup_name) बराबर हैं। प्रत्येक वर्ग भी DateField और DateTimeField पर __(lookup_name) रूप में पंजीकृत है, जैसे __year

चूंकि DateField पास एक समय घटक नहीं है, केवल उप-अंश Extract जो दिनांक-भागों के साथ DateField करते हैं DateField साथ उपयोग किया जा सकता है:

>>> from datetime import datetime
>>> from django.utils import timezone
>>> from django.db.models.functions import (
...     ExtractDay, ExtractMonth, ExtractQuarter, ExtractWeek,
...     ExtractWeekDay, ExtractYear,
... )
>>> start_2015 = datetime(2015, 6, 15, 23, 30, 1, tzinfo=timezone.utc)
>>> end_2015 = datetime(2015, 6, 16, 13, 11, 27, tzinfo=timezone.utc)
>>> Experiment.objects.create(
...    start_datetime=start_2015, start_date=start_2015.date(),
...    end_datetime=end_2015, end_date=end_2015.date())
>>> Experiment.objects.annotate(
...     year=ExtractYear('start_date'),
...     quarter=ExtractQuarter('start_date'),
...     month=ExtractMonth('start_date'),
...     week=ExtractWeek('start_date'),
...     day=ExtractDay('start_date'),
...     weekday=ExtractWeekDay('start_date'),
... ).values('year', 'quarter', 'month', 'week', 'day', 'weekday').get(
...     end_date__year=ExtractYear('start_date'),
... )
{'year': 2015, 'quarter': 2, 'month': 6, 'week': 25, 'day': 15, 'weekday': 2}

DateTimeField अर्क

निम्नलिखित के अलावा, ऊपर सूचीबद्ध DateField लिए सभी DateField DateTimeField s पर भी उपयोग किए जा सकते हैं।

class ExtractHour(expression, tzinfo=None, **extra) [source]
lookup_name = 'hour'
class ExtractMinute(expression, tzinfo=None, **extra) [source]
lookup_name = 'minute'
class ExtractSecond(expression, tzinfo=None, **extra) [source]
lookup_name = 'second'

ये तार्किक रूप से Extract('datetime_field', lookup_name) बराबर हैं। प्रत्येक वर्ग DateTimeField पर __(lookup_name) रूप में पंजीकृत एक Transform भी है, जैसे __minute

DateTimeField उदाहरण:

>>> from datetime import datetime
>>> from django.utils import timezone
>>> from django.db.models.functions import (
...     ExtractDay, ExtractHour, ExtractMinute, ExtractMonth,
...     ExtractQuarter, ExtractSecond, ExtractWeek, ExtractWeekDay,
...     ExtractYear,
... )
>>> start_2015 = datetime(2015, 6, 15, 23, 30, 1, tzinfo=timezone.utc)
>>> end_2015 = datetime(2015, 6, 16, 13, 11, 27, tzinfo=timezone.utc)
>>> Experiment.objects.create(
...    start_datetime=start_2015, start_date=start_2015.date(),
...    end_datetime=end_2015, end_date=end_2015.date())
>>> Experiment.objects.annotate(
...     year=ExtractYear('start_datetime'),
...     quarter=ExtractQuarter('start_datetime'),
...     month=ExtractMonth('start_datetime'),
...     week=ExtractWeek('start_datetime'),
...     day=ExtractDay('start_datetime'),
...     weekday=ExtractWeekDay('start_datetime'),
...     hour=ExtractHour('start_datetime'),
...     minute=ExtractMinute('start_datetime'),
...     second=ExtractSecond('start_datetime'),
... ).values(
...     'year', 'month', 'week', 'day', 'weekday', 'hour', 'minute', 'second',
... ).get(end_datetime__year=ExtractYear('start_datetime'))
{'year': 2015, 'quarter': 2, 'month': 6, 'week': 25, 'day': 15, 'weekday': 2,
 'hour': 23, 'minute': 30, 'second': 1}

जब USE_TZ True तो डेटाबेस में UTC में USE_TZ जमा हो जाता है। यदि Django में एक अलग टाइमज़ोन सक्रिय है, तो वैल्यू निकाले जाने से पहले डेटाटाइम उस टाइमज़ोन में बदल जाता है। नीचे दिए गए उदाहरण मेलबॉर्न टाइमज़ोन (यूटीसी +10: 00) में परिवर्तित हो जाते हैं, जो दिन, सप्ताह के दिनों और घंटे के मूल्यों को बदल देता है:

>>> import pytz
>>> melb = pytz.timezone('Australia/Melbourne')  # UTC+10:00
>>> with timezone.override(melb):
...    Experiment.objects.annotate(
...        day=ExtractDay('start_datetime'),
...        weekday=ExtractWeekDay('start_datetime'),
...        hour=ExtractHour('start_datetime'),
...    ).values('day', 'weekday', 'hour').get(
...        end_datetime__year=ExtractYear('start_datetime'),
...    )
{'day': 16, 'weekday': 3, 'hour': 9}

Extract फंक्शन के लिए समय-समय पर उत्तीर्ण करना उसी तरह से व्यवहार करता है, और एक सक्रिय टाइमज़ोन पर प्राथमिकता लेता है:

>>> import pytz
>>> melb = pytz.timezone('Australia/Melbourne')
>>> Experiment.objects.annotate(
...     day=ExtractDay('start_datetime', tzinfo=melb),
...     weekday=ExtractWeekDay('start_datetime', tzinfo=melb),
...     hour=ExtractHour('start_datetime', tzinfo=melb),
... ).values('day', 'weekday', 'hour').get(
...     end_datetime__year=ExtractYear('start_datetime'),
... )
{'day': 16, 'weekday': 3, 'hour': 9}

Now

class Now [source]

डेटाबेस सर्वर की वर्तमान तिथि और समय जब क्वेरी निष्पादित होती है, तो आमतौर पर SQL CURRENT_TIMESTAMP का उपयोग करके वापस आ जाता है।

उपयोग उदाहरण:

>>> from django.db.models.functions import Now
>>> Article.objects.filter(published__lte=Now())
<QuerySet [<Article: How to Django>]>

PostgreSQL के विचार

PostgreSQL पर, SQL CURRENT_TIMESTAMP , उस समय को लौटाता है, जब वर्तमान लेनदेन शुरू हुआ था। इसलिए क्रॉस-डेटाबेस संगतता के लिए, Now() इसके बजाय STATEMENT_TIMESTAMP का उपयोग करता है। यदि आपको लेनदेन टाइमस्टैम्प की आवश्यकता है, तो django.contrib.postgres.functions.TransactionNow उपयोग django.contrib.postgres.functions.TransactionNow

Trunc

class Trunc(expression, kind, output_field=None, tzinfo=None, **extra) [source]

एक महत्वपूर्ण घटक तक एक तारीख को काट देता है।

जब आप केवल इस बात की परवाह करते हैं कि कोई विशेष वर्ष, घंटा, या दिन में कुछ हुआ है, लेकिन सटीक दूसरा नहीं है, तो Trunc (और उसके उपवर्ग) आपके डेटा को फ़िल्टर या एकत्र करने के लिए उपयोगी हो सकते हैं। उदाहरण के लिए, आप प्रति दिन बिक्री की संख्या की गणना करने के लिए Trunc का उपयोग कर सकते हैं।

Trunc एक एकल expression लेता है, एक DateField , TimeField , या DateTimeField , दिनांक या समय भाग का प्रतिनिधित्व करने वाला एक kind , और एक output_field जो या तो DateTimeField() , TimeField() , या DateField() । यह अपने न्यूनतम मूल्य पर सेट किए गए फ़ील्ड के साथ, output_field आधार पर output_field , दिनांक या समय देता है। यदि output_field को छोड़ा गया है, तो यह expression के output_field को डिफ़ॉल्ट करेगा। एक tzinfo उपवर्ग, आमतौर पर pytz द्वारा प्रदान किया pytz , एक विशिष्ट समयक्षेत्र में एक मूल्य को कम करने के लिए पारित किया जा सकता है।

2015-06-15 14:30:50.000321+00:00 को देखते हुए 2015-06-15 14:30:50.000321+00:00 , बिल्ट-इन kind रिटर्न:

  • "वर्ष": 2015-01-01 00: 00: 00 + 00: 00
  • "तिमाही": 2015-04-01 00: 00: 00 + 00: 00
  • "महीना": 2015-06-01 00: 00: 00 + 00: 00
  • "सप्ताह": 2015-06-15 00: 00: 00 + 00: 00
  • "दिन": 2015-06-15 00: 00: 00 + 00: 00
  • "घंटा": 2015-06-15 14: 00: 00 + 00: 00
  • "मिनट": 2015-06-15 14: 30: 00 + 00: 00
  • "दूसरा": 2015-06-15 14: 30: 50 + 00: 00

यदि Australia/Melbourne जैसा एक अलग समय क्षेत्र Django में सक्रिय है, तो मूल्य को काट दिया जाने से पहले डेटाटाइम को नए टाइमज़ोन में बदल दिया जाता है। उपरोक्त उदाहरण तिथि में मेलबर्न के लिए समय क्षेत्र ऑफसेट +10: 00 है। इस समयक्षेत्र के सक्रिय होने पर लौटे मान निम्न होंगे:

  • "वर्ष": 2015-01-01 00: 00: 00 + 11: 00
  • "तिमाही": 2015-04-01 00: 00: 00 + 10: 00
  • "महीना": 2015-06-01 00: 00: 00 + 10: 00
  • "सप्ताह": 2015-06-16 00: 00: 00 + 10: 00
  • "दिन": 2015-06-16 00: 00: 00 + 10: 00
  • "घंटा": 2015-06-16 00: 00: 00 + 10: 00
  • "मिनट": 2015-06-16 00: 30: 00 + 10: 00
  • "दूसरा": 2015-06-16 00: 30: 50 + 10: 00

इस वर्ष +11: 00 की भरपाई होती है क्योंकि परिणाम दिन के समय की बचत में परिवर्तित हो जाता है।

प्रत्येक kind ऊपर एक Trunc उपवर्ग (नीचे सूचीबद्ध) होता है जिसे आमतौर पर अधिक TruncYear(...) समतुल्य के बजाय उपयोग किया जाना चाहिए, उदाहरण के लिए Trunc(..., kind='year') बजाय TruncYear(...) उपयोग करें।

उपवर्गों को सभी परिवर्तनों के रूप में परिभाषित किया गया है, लेकिन वे किसी भी फ़ील्ड के साथ पंजीकृत नहीं हैं, क्योंकि स्पष्ट लुकअप नाम पहले से ही Extract उपवर्गों द्वारा आरक्षित हैं।

उपयोग उदाहरण:

>>> from datetime import datetime
>>> from django.db.models import Count, DateTimeField
>>> from django.db.models.functions import Trunc
>>> Experiment.objects.create(start_datetime=datetime(2015, 6, 15, 14, 30, 50, 321))
>>> Experiment.objects.create(start_datetime=datetime(2015, 6, 15, 14, 40, 2, 123))
>>> Experiment.objects.create(start_datetime=datetime(2015, 12, 25, 10, 5, 27, 999))
>>> experiments_per_day = Experiment.objects.annotate(
...    start_day=Trunc('start_datetime', 'day', output_field=DateTimeField())
... ).values('start_day').annotate(experiments=Count('id'))
>>> for exp in experiments_per_day:
...     print(exp['start_day'], exp['experiments'])
...
2015-06-15 00:00:00 2
2015-12-25 00:00:00 1
>>> experiments = Experiment.objects.annotate(
...    start_day=Trunc('start_datetime', 'day', output_field=DateTimeField())
... ).filter(start_day=datetime(2015, 6, 15))
>>> for exp in experiments:
...     print(exp.start_datetime)
...
2015-06-15 14:30:50.000321
2015-06-15 14:40:02.000123

DateField ट्रंकेशन

class TruncYear(expression, output_field=None, tzinfo=None, **extra) [source]
kind = 'year'
class TruncMonth(expression, output_field=None, tzinfo=None, **extra) [source]
kind = 'month'
class TruncWeek(expression, output_field=None, tzinfo=None, **extra) [source]
Django 2.1 में नया:

सप्ताह के सोमवार को मध्यरात्रि तक चलता है।

kind = 'week'
class TruncQuarter(expression, output_field=None, tzinfo=None, **extra) [source]
Django 2.0 में नया:
kind = 'quarter'

ये तार्किक रूप से Trunc('date_field', kind) समतुल्य हैं। वे तिथि के सभी हिस्सों को उस kind काट देते हैं जो कम सटीकता के साथ तिथियों को समूहीकृत या फ़िल्टर करने की अनुमति देता है। expression DateField या DateTimeField दोनों में से एक output_field हो सकता है।

चूंकि DateField पास कोई समय घटक नहीं है, केवल Trunc उप-वर्ग जो कि दिनांक-भागों के साथ सौदा करते हैं, का उपयोग किया जा सकता है:

>>> from datetime import datetime
>>> from django.db.models import Count
>>> from django.db.models.functions import TruncMonth, TruncYear
>>> from django.utils import timezone
>>> start1 = datetime(2014, 6, 15, 14, 30, 50, 321, tzinfo=timezone.utc)
>>> start2 = datetime(2015, 6, 15, 14, 40, 2, 123, tzinfo=timezone.utc)
>>> start3 = datetime(2015, 12, 31, 17, 5, 27, 999, tzinfo=timezone.utc)
>>> Experiment.objects.create(start_datetime=start1, start_date=start1.date())
>>> Experiment.objects.create(start_datetime=start2, start_date=start2.date())
>>> Experiment.objects.create(start_datetime=start3, start_date=start3.date())
>>> experiments_per_year = Experiment.objects.annotate(
...    year=TruncYear('start_date')).values('year').annotate(
...    experiments=Count('id'))
>>> for exp in experiments_per_year:
...     print(exp['year'], exp['experiments'])
...
2014-01-01 1
2015-01-01 2

>>> import pytz
>>> melb = pytz.timezone('Australia/Melbourne')
>>> experiments_per_month = Experiment.objects.annotate(
...    month=TruncMonth('start_datetime', tzinfo=melb)).values('month').annotate(
...    experiments=Count('id'))
>>> for exp in experiments_per_month:
...     print(exp['month'], exp['experiments'])
...
2015-06-01 00:00:00+10:00 1
2016-01-01 00:00:00+11:00 1
2014-06-01 00:00:00+10:00 1

DateTimeField ट्रंकेशन

class TruncDate(expression, **extra) [source]
lookup_name = 'date'
output_field = DateField()

TruncDate अंतर्निहित SQL TruncDate का उपयोग करने के बजाय किसी दिनांक को expression देता है। यह __date रूप में DateTimeField पर एक रूपांतरण के रूप में भी पंजीकृत है।

class TruncTime(expression, **extra) [source]
lookup_name = 'time'
output_field = TimeField()

TruncTime अंतर्निहित SQL TruncTime का उपयोग करने के बजाय एक समय के लिए expression देता है। यह DateTimeField पर __time रूप में भी __time

class TruncDay(expression, output_field=None, tzinfo=None, **extra) [source]
kind = 'day'
class TruncHour(expression, output_field=None, tzinfo=None, **extra) [source]
kind = 'hour'
class TruncMinute(expression, output_field=None, tzinfo=None, **extra) [source]
kind = 'minute'
class TruncSecond(expression, output_field=None, tzinfo=None, **extra) [source]
kind = 'second'

ये तार्किक रूप से Trunc('datetime_field', kind) समतुल्य हैं। वे तिथि के सभी हिस्सों को छाँटते हैं और कम सटीकता के साथ समूहन या फ़िल्टरिंग डेटाइम की अनुमति देते हैं। expression में DateTimeField का एक output_field होना चाहिए।

उपयोग उदाहरण:

>>> from datetime import date, datetime
>>> from django.db.models import Count
>>> from django.db.models.functions import (
...     TruncDate, TruncDay, TruncHour, TruncMinute, TruncSecond,
... )
>>> from django.utils import timezone
>>> import pytz
>>> start1 = datetime(2014, 6, 15, 14, 30, 50, 321, tzinfo=timezone.utc)
>>> Experiment.objects.create(start_datetime=start1, start_date=start1.date())
>>> melb = pytz.timezone('Australia/Melbourne')
>>> Experiment.objects.annotate(
...     date=TruncDate('start_datetime'),
...     day=TruncDay('start_datetime', tzinfo=melb),
...     hour=TruncHour('start_datetime', tzinfo=melb),
...     minute=TruncMinute('start_datetime'),
...     second=TruncSecond('start_datetime'),
... ).values('date', 'day', 'hour', 'minute', 'second').get()
{'date': datetime.date(2014, 6, 15),
 'day': datetime.datetime(2014, 6, 16, 0, 0, tzinfo=<DstTzInfo 'Australia/Melbourne' AEST+10:00:00 STD>),
 'hour': datetime.datetime(2014, 6, 16, 0, 0, tzinfo=<DstTzInfo 'Australia/Melbourne' AEST+10:00:00 STD>),
 'minute': 'minute': datetime.datetime(2014, 6, 15, 14, 30, tzinfo=<UTC>),
 'second': datetime.datetime(2014, 6, 15, 14, 30, 50, tzinfo=<UTC>)
}

TimeField ट्रंकेशन

class TruncHour(expression, output_field=None, tzinfo=None, **extra) [source]
kind = 'hour'
class TruncMinute(expression, output_field=None, tzinfo=None, **extra) [source]
kind = 'minute'
class TruncSecond(expression, output_field=None, tzinfo=None, **extra) [source]
kind = 'second'

ये तार्किक रूप से Trunc('time_field', kind) समतुल्य हैं। वे समय के सभी भागों को kind जो कम सटीकता के साथ समूह बनाने या फ़िल्टर करने की अनुमति देता है। expression TimeField या DateTimeField दोनों में से एक output_field हो सकता है।

चूंकि TimeField पास कोई डेट कंपोनेंट नहीं है, केवल Trunc जो समय-भागों के साथ TimeField करते हैं, TimeField साथ प्रयोग किया जा सकता है:

>>> from datetime import datetime
>>> from django.db.models import Count, TimeField
>>> from django.db.models.functions import TruncHour
>>> from django.utils import timezone
>>> start1 = datetime(2014, 6, 15, 14, 30, 50, 321, tzinfo=timezone.utc)
>>> start2 = datetime(2014, 6, 15, 14, 40, 2, 123, tzinfo=timezone.utc)
>>> start3 = datetime(2015, 12, 31, 17, 5, 27, 999, tzinfo=timezone.utc)
>>> Experiment.objects.create(start_datetime=start1, start_time=start1.time())
>>> Experiment.objects.create(start_datetime=start2, start_time=start2.time())
>>> Experiment.objects.create(start_datetime=start3, start_time=start3.time())
>>> experiments_per_hour = Experiment.objects.annotate(
...    hour=TruncHour('start_datetime', output_field=TimeField()),
... ).values('hour').annotate(experiments=Count('id'))
>>> for exp in experiments_per_hour:
...     print(exp['hour'], exp['experiments'])
...
14:00:00 2
17:00:00 1

>>> import pytz
>>> melb = pytz.timezone('Australia/Melbourne')
>>> experiments_per_hour = Experiment.objects.annotate(
...    hour=TruncHour('start_datetime', tzinfo=melb),
... ).values('hour').annotate(experiments=Count('id'))
>>> for exp in experiments_per_hour:
...     print(exp['hour'], exp['experiments'])
...
2014-06-16 00:00:00+10:00 2
2016-01-01 04:00:00+11:00 1

पाठ कार्य

Chr

class Chr(expression, **extra) [source]
Django 2.1 में नया:

एक संख्यात्मक क्षेत्र या अभिव्यक्ति को स्वीकार करता है और एक एकल चरित्र के रूप में अभिव्यक्ति का पाठ प्रतिनिधित्व लौटाता है। यह पायथन के chr() फ़ंक्शन के समान काम करता है।

Length तरह, इसे IntegerField पर रूपांतरण के रूप में पंजीकृत किया जा सकता है। डिफ़ॉल्ट लुकअप नाम chr

उपयोग उदाहरण:

>>> from django.db.models.functions import Chr
>>> Author.objects.create(name='Margaret Smith')
>>> author = Author.objects.filter(name__startswith=Chr(ord('M'))).get()
>>> print(author.name)
Margaret Smith

Concat

class Concat(*expressions, **extra) [source]

कम से कम दो पाठ फ़ील्ड या अभिव्यक्तियों की एक सूची स्वीकार करता है और संक्षिप्त पाठ लौटाता है। प्रत्येक तर्क एक पाठ या चार प्रकार का होना चाहिए। यदि आप एक TextField() को एक CharField() TextField() साथ जोड़ना चाहते हैं, तो Django को बताना सुनिश्चित करें कि output_field एक TextField() होना चाहिए। जब output_field को नीचे दिए उदाहरण में Value जाता है, तो एक output_field निर्दिष्ट करना भी आवश्यक होता है।

इस फ़ंक्शन का कभी भी अशक्त परिणाम नहीं होगा। बैकएंड पर जहां एक अशक्त तर्क पूरे अभिव्यक्ति में अशक्त होने का परिणाम देता है, Django यह सुनिश्चित करेगा कि प्रत्येक नल भाग को पहले खाली स्ट्रिंग में बदल दिया जाए।

उपयोग उदाहरण:

>>> # Get the display name as "name (goes_by)"
>>> from django.db.models import CharField, Value as V
>>> from django.db.models.functions import Concat
>>> Author.objects.create(name='Margaret Smith', goes_by='Maggie')
>>> author = Author.objects.annotate(
...     screen_name=Concat(
...         'name', V(' ('), 'goes_by', V(')'),
...         output_field=CharField()
...     )
... ).get()
>>> print(author.screen_name)
Margaret Smith (Maggie)

Left

class Left(expression, length, **extra) [source]
Django 2.1 में नया:

दिए गए पाठ क्षेत्र या अभिव्यक्ति की पहली length अक्षर देता है।

उपयोग उदाहरण:

>>> from django.db.models.functions import Left
>>> Author.objects.create(name='Margaret Smith')
>>> author = Author.objects.annotate(first_initial=Left('name', 1)).get()
>>> print(author.first_initial)
M

Length

class Length(expression, **extra) [source]

किसी एकल पाठ फ़ील्ड या अभिव्यक्ति को स्वीकार करता है और उन वर्णों की संख्या देता है जिनका मूल्य है। यदि अभिव्यक्ति अशक्त है, तो लंबाई भी अशक्त होगी।

उपयोग उदाहरण:

>>> # Get the length of the name and goes_by fields
>>> from django.db.models.functions import Length
>>> Author.objects.create(name='Margaret Smith')
>>> author = Author.objects.annotate(
...    name_length=Length('name'),
...    goes_by_length=Length('goes_by')).get()
>>> print(author.name_length, author.goes_by_length)
(14, None)

इसे एक परिवर्तन के रूप में भी पंजीकृत किया जा सकता है। उदाहरण के लिए:

>>> from django.db.models import CharField
>>> from django.db.models.functions import Length
>>> CharField.register_lookup(Length)
>>> # Get authors whose name is longer than 7 characters
>>> authors = Author.objects.filter(name__length__gt=7)

Lower

class Lower(expression, **extra) [source]

किसी एकल पाठ क्षेत्र या अभिव्यक्ति को स्वीकार करता है और लोअरकेस प्रतिनिधित्व को लौटाता है।

इसे Length में वर्णित परिवर्तन के रूप में भी पंजीकृत किया जा सकता है।

उपयोग उदाहरण:

>>> from django.db.models.functions import Lower
>>> Author.objects.create(name='Margaret Smith')
>>> author = Author.objects.annotate(name_lower=Lower('name')).get()
>>> print(author.name_lower)
margaret smith

LPad

class LPad(expression, length, fill_text=Value(' '), **extra) [source]
Django 2.1 में नया:

दिए गए टेक्स्ट फ़ील्ड या अभिव्यक्ति के मूल्य को fill_text साथ बाईं ओर गद्देदार fill_text ताकि परिणामी मान length वर्ण लंबा हो। डिफ़ॉल्ट fill_text एक स्थान है।

उपयोग उदाहरण:

>>> from django.db.models import Value
>>> from django.db.models.functions import LPad
>>> Author.objects.create(name='John', alias='j')
>>> Author.objects.update(name=LPad('name', 8, Value('abc')))
1
>>> print(Author.objects.get(alias='j').name)
abcaJohn

LTrim

class LTrim(expression, **extra) [source]
Django 2.1 में नया:

Trim समान है, लेकिन केवल प्रमुख स्थानों को हटा देता है।

Ord

class Ord(expression, **extra) [source]
Django 2.1 में नया:

किसी एकल पाठ क्षेत्र या अभिव्यक्ति को स्वीकार करता है और उस अभिव्यक्ति के पहले चरित्र के लिए यूनिकोड कोड बिंदु मान लौटाता है। यह पायथन के ord() फ़ंक्शन के समान काम करता है, लेकिन यदि एक से अधिक वर्ण लंबे होते हैं तो अपवाद नहीं उठाया जाता है।

इसे Length में वर्णित परिवर्तन के रूप में भी पंजीकृत किया जा सकता है। डिफ़ॉल्ट लुकअप नाम ord

उपयोग उदाहरण:

>>> from django.db.models.functions import Ord
>>> Author.objects.create(name='Margaret Smith')
>>> author = Author.objects.annotate(name_code_point=Ord('name')).get()
>>> print(author.name_code_point)
77

Repeat

class Repeat(expression, number, **extra) [source]
Django 2.1 में नया:

दिए गए पाठ क्षेत्र या अभिव्यक्ति के मूल्य को number बार दोहराया जाता है।

उपयोग उदाहरण:

>>> from django.db.models.functions import Repeat
>>> Author.objects.create(name='John', alias='j')
>>> Author.objects.update(name=Repeat('name', 3))
1
>>> print(Author.objects.get(alias='j').name)
JohnJohnJohn

Replace

class Replace(expression, text, replacement=Value(''), **extra) [source]
Django 2.1 में नया:

expression में replacement साथ text की सभी घटनाओं को replacement है। डिफ़ॉल्ट प्रतिस्थापन पाठ खाली स्ट्रिंग है। फ़ंक्शन के तर्क केस-संवेदी होते हैं।

उपयोग उदाहरण:

>>> from django.db.models import Value
>>> from django.db.models.functions import Replace
>>> Author.objects.create(name='Margaret Johnson')
>>> Author.objects.create(name='Margaret Smith')
>>> Author.objects.update(name=Replace('name', Value('Margaret'), Value('Margareth')))
2
>>> Author.objects.values('name')
<QuerySet [{'name': 'Margareth Johnson'}, {'name': 'Margareth Smith'}]>
class Right(expression, length, **extra) [source]
Django 2.1 में नया:

दिए गए पाठ क्षेत्र या अभिव्यक्ति के अंतिम length अक्षर देता है।

उपयोग उदाहरण:

>>> from django.db.models.functions import Right
>>> Author.objects.create(name='Margaret Smith')
>>> author = Author.objects.annotate(last_letter=Right('name', 1)).get()
>>> print(author.last_letter)
h

RPad

class RPad(expression, length, fill_text=Value(' '), **extra) [source]
Django 2.1 में नया:

LPad समान, लेकिन दाईं ओर पैड।

RTrim

class RTrim(expression, **extra) [source]
Django 2.1 में नया:

Trim समान है, लेकिन केवल अनुगामी रिक्त स्थान को निकालता है।

StrIndex

class StrIndex(string, substring, **extra) [source]
Django 2.0 में नया:

substring अंदर substring की पहली घटना की 1-अनुक्रमित स्थिति के अनुरूप एक सकारात्मक पूर्णांक लौटाता है, या अगर substring नहीं मिला है।

उपयोग उदाहरण:

>>> from django.db.models import Value as V
>>> from django.db.models.functions import StrIndex
>>> Author.objects.create(name='Margaret Smith')
>>> Author.objects.create(name='Smith, Margaret')
>>> Author.objects.create(name='Margaret Jackson')
>>> Author.objects.filter(name='Margaret Jackson').annotate(
...     smith_index=StrIndex('name', V('Smith'))
... ).get().smith_index
0
>>> authors = Author.objects.annotate(
...    smith_index=StrIndex('name', V('Smith'))
... ).filter(smith_index__gt=0)
<QuerySet [<Author: Margaret Smith>, <Author: Smith, Margaret>]>

चेतावनी

MySQL में, एक डेटाबेस टेबल का collation निर्धारित करता है कि क्या स्ट्रिंग तुलना (जैसे इस फ़ंक्शन की expression और substring ) केस-संवेदी हैं। तुलनात्मक रूप से मामले असंवेदनशील हैं।

Substr

class Substr(expression, pos, length=None, **extra) [source]

क्षेत्र या स्थिति pos से शुरू होने वाली अभिव्यक्ति से लंबाई की length का एक विकल्प देता है। स्थिति 1-अनुक्रमित है, इसलिए स्थिति 0. से अधिक होनी चाहिए। यदि length None , तो बाकी स्ट्रिंग वापस आ जाएगी।

उपयोग उदाहरण:

>>> # Set the alias to the first 5 characters of the name as lowercase
>>> from django.db.models.functions import Lower, Substr
>>> Author.objects.create(name='Margaret Smith')
>>> Author.objects.update(alias=Lower(Substr('name', 1, 5)))
1
>>> print(Author.objects.get(name='Margaret Smith').alias)
marga

Trim

class Trim(expression, **extra) [source]
Django 2.1 में नया:

दिए गए पाठ क्षेत्र या अभिव्यक्ति के मूल्य को प्रमुख और अनुगामी रिक्त स्थान से हटा देता है।

उपयोग उदाहरण:

>>> from django.db.models.functions import Trim
>>> Author.objects.create(name='  John  ', alias='j')
>>> Author.objects.update(name=Trim('name'))
1
>>> print(Author.objects.get(alias='j').name)
John

Upper

class Upper(expression, **extra) [source]

किसी एकल पाठ फ़ील्ड या अभिव्यक्ति को स्वीकार करता है और अपरकेस प्रतिनिधित्व लौटाता है।

इसे Length में वर्णित परिवर्तन के रूप में भी पंजीकृत किया जा सकता है।

उपयोग उदाहरण:

>>> from django.db.models.functions import Upper
>>> Author.objects.create(name='Margaret Smith')
>>> author = Author.objects.annotate(name_upper=Upper('name')).get()
>>> print(author.name_upper)
MARGARET SMITH

विंडो फ़ंक्शन

Django 2.0 में नया:

तत्वों की रैंक या कुछ पंक्तियों के Ntile की गणना के लिए Window अभिव्यक्ति में उपयोग करने के लिए कई फ़ंक्शन हैं।

CumeDist

class CumeDist(*expressions, **extra) [source]

एक खिड़की या विभाजन के भीतर एक मूल्य के संचयी वितरण की गणना करता है। संचयी वितरण को वर्तमान पंक्तियों की संख्या के रूप में परिभाषित किया गया है या फ्रेम में पंक्तियों की कुल संख्या से विभाजित वर्तमान पंक्ति के साथ peered है।

DenseRank

class DenseRank(*expressions, **extra) [source]

Rank बराबर लेकिन अंतराल नहीं है।

FirstValue

class FirstValue(expression, **extra) [source]

उस मान का मूल्यांकन उस पंक्ति पर करता है जो विंडो फ़्रेम की पहली पंक्ति है, या None यदि ऐसा कोई मान मौजूद नहीं है।

Lag

class Lag(expression, offset=1, default=None, **extra) [source]

ऑफसेट द्वारा मान की गणना करता है, और यदि कोई पंक्ति वहां मौजूद नहीं है, तो default वापस आती default

default में expression के समान प्रकार होना चाहिए, हालांकि, यह केवल डेटाबेस द्वारा मान्य है और पायथन में नहीं।

LastValue

class LastValue(expression, **extra) [source]

FirstValue , यह किसी दिए गए फ्रेम क्लॉज में अंतिम मान की गणना करता है।

Lead

class Lead(expression, offset=1, default=None, **extra) [source]

किसी दिए गए frame में अग्रणी मूल्य की गणना करता है। वर्तमान पंक्ति के संबंध में offset और default दोनों का मूल्यांकन किया जाता है।

default में expression के समान प्रकार होना चाहिए, हालांकि, यह केवल डेटाबेस द्वारा मान्य है और पायथन में नहीं।

NthValue

class NthValue(expression, nth=1, **extra) [source]

nth खिड़की के भीतर ऑफसेट के सापेक्ष पंक्ति की गणना करता है (एक सकारात्मक मूल्य होना चाहिए)। None यदि कोई पंक्ति मौजूद नहीं है, तो लौटाता है।

कुछ डेटाबेस अलग-अलग बिना किसी नंस्टेबल nth-value को संभाल सकते हैं। उदाहरण के लिए, Oracle None चरित्र-आधारित अभिव्यक्तियों के बजाय एक रिक्त स्ट्रिंग देता है । Django इन मामलों में कोई रूपांतरण नहीं करता है।

Ntile

class Ntile(num_buckets=1, **extra) [source]

फ्रेम क्लॉज में प्रत्येक पंक्तियों के लिए एक विभाजन की गणना करता है, संख्याओं को 1 और के बीच समान रूप से वितरित करता है num_buckets । यदि पंक्तियाँ समान रूप से बकेट की संख्या में विभाजित नहीं होती हैं, तो एक या अधिक बकेट का प्रतिनिधित्व अधिक बार किया जाएगा।

PercentRank

class PercentRank(*expressions, **extra) [source]

फ्रेम क्लॉज में पंक्तियों के पर्सेंटाइल रैंक की गणना करता है। यह गणना मूल्यांकन के बराबर है:

(rank - 1) / (total rows - 1)

निम्न तालिका एक पंक्ति के प्रतिशतक रैंक के लिए गणना बताती है:

पंक्ति # मूल्य श्रेणी हिसाब प्रतिशत रैंक
1 15 1 (1-1) / (7-1) 0.0000
2 20 2 (2-1) / (7-1) 0.1666
3 20 2 (2-1) / (7-1) 0.1666
4 20 2 (2-1) / (7-1) 0.1666
5 30 5 (5-1) / (7-1) 0.6666
6 30 5 (5-1) / (7-1) 0.6666
7 40 7 (7-1) / (7-1) 1.0000

Rank

class Rank(*expressions, **extra) [source]

तुलना करने के लिए RowNumber , यह फ़ंक्शन विंडो में पंक्तियों को रैंक करता है। गणना की गई रैंक में अंतराल होता है। DenseRank अंतराल के बिना रैंक की गणना करने के लिए उपयोग करें ।

RowNumber

class RowNumber(*expressions, **extra) [source]

यदि frame का कोई विभाजन नहीं है, तो फ्रेम क्लॉज या पूरे क्वेरी के ऑर्डर के अनुसार पंक्ति संख्या की गणना करता है ।

Original text