Dry ORM - Feed

example-postgres postgres • 2 days, 8 hours

from django.db import models
from django.db.models import Count
from django.contrib.postgres.aggregates import ArrayAgg, StringAgg

class Person(models.Model):
    name = models.CharField(max_length=100)

    def __str__(self):
        return self.name

class Pet(models.Model):
    name = models.CharField(max_length=100)
    owner = models.ForeignKey(Person, related_name='pets', on_delete=models.CASCADE)
    
def run():
    # Create sample data
    person = Person.objects.create(name='John Doe')
    Pet.objects.bulk_create([
        Pet(name='Rex', owner=person),
        Pet(name='Mittens', owner=person),
        Pet(name='Fido', owner=person),
    ])

    # Aggregate all pet names into a single array and a string
    result = Person.objects.annotate(
        pet_count=Count('pets'),
        pet_names_array=ArrayAgg('pets__name'),
        pet_names_string=StringAgg('pets__name', delimiter=', ')
    ).get(id=person.id)

    print(f'{result.name} has {result.pet_count} pets.')
    print(f'Pet names (array): {result.pet_names_array}')
    print(f'Pet names (string): {result.pet_names_string}')

template-render sqlite • 2 days, 8 hours

import os
from django.conf import settings
from django.db import models
from django.shortcuts import render
from django.test import Client
from django.urls import path
from faker import Faker

fake = Faker()

class Person(models.Model):
    name = models.CharField(max_length=100)
    email = models.EmailField()
    job = models.CharField(max_length=100)
    address = models.TextField()
    company = models.CharField(max_length=100)


def show_person(request):
    people = Person.objects.all()
    return render(request, "person.html", {"people": people})

urlpatterns = [
    path("person/", show_person),
]

def run():

    # Bootstrap
    Person.objects.bulk_create([
        Person(
            name=fake.name(),
            email=fake.email(),
            job=fake.job(),
            address=fake.address(),
            company=fake.company()
        )
        for _ in range(10)
    ])

    # Template
    with open("templates/person.html", "w") as f:
        f.write("""
    {% extends 'base.html' %}
    {% block content %}
    <div class="p-6">
      <h1 class="text-2xl font-bold mb-4">People</h1>
      <div class="grid grid-cols-1 sm:grid-cols-2 md:grid-cols-3 lg:grid-cols-4 gap-4">
        {% for person in people %}
          <div class="p-4 border rounded shadow bg-white">
            <h2 class="text-xl font-semibold">{{ person.name }}</h2>
            <p class="text-gray-600 text-sm">{{ person.email }}</p>
            <p class="text-gray-700">{{ person.job }}</p>
            <p class="text-gray-500 text-sm">{{ person.company }}</p>
            <p class="text-xs text-gray-400 mt-2">{{ person.address }}</p>
          </div>
        {% endfor %}
      </div>
    </div>
    {% endblock %}
    """)

    return Client().get("/person/").content.decode()

all-features-example sqlite • 2 days, 19 hours

from django.db import models

# Tabulate and Faker are available.
from tabulate import tabulate
from faker import Faker

# You can place the models here
class Person(models.Model):
    name = models.CharField(max_length=100)

# You need a run function
def run():
    # At this point all migrations are created and applied
    john = Person.objects.create(name='John Doe')
    jane = Person.objects.create(name='Jane Doe')

    # Any "print" statements will be displayed in "Output"
    print(f'Hello, {john.name}!')

    # If you return a Dict[str, List[Dict[str, Any]]], it will be displayed
    # as a Table below the Output Section and will be given the key as title.
    return {
        'People': list(Person.objects.values()),
        'Other': [
            {'name': 'Cell 1', 'other': 'Cell 2'},
            {'name': 'Cell 3', 'other': 'Cell 4'},
        ]
    }

    # Alternatively, you can just return a list of dicts
    # to render a default "Data" table.
    # return list(Person.objects.all().values())

union-prefetch-v2 sqlite • 2 days, 23 hours

from django.db import models
from django.db.models import Prefetch, Q

class Network(models.Model):
    code = models.CharField(max_length=8)

class Station(models.Model):
    code = models.CharField(max_length=8)
    network = models.ForeignKey(Network, on_delete=models.PROTECT)

    def __str__(self):
        return self.code

def run():
    net1 = Network.objects.create(code='net1')
    net2 = Network.objects.create(code='net2')
    stat1 = Station.objects.create(
        network=net1, code='stat1',
    )
    stat25 = Station.objects.create(
        network=net2, code='stat25',
    )
    networks = list(Network.objects.filter(code='net1').prefetch_related(
        Prefetch(
            'station_set',
            queryset=Station.objects.filter(
                Q(network__code='net1', code='stat1')
                | Q(network__code='net2', code='stat25')
            )
        )
    ).union(
        Network.objects.filter(code='net2')
    ).order_by('pk'))
    print(networks[0].station_set.all())
    print(networks[1].station_set.all())

netstagerien sqlite • 2 days, 23 hours

from django.db import models
from django.db.models import Prefetch, Q

class Network(models.Model):
    code = models.CharField(max_length=8)
    
    def __str__(self) -> str:
        return self.code


class Station(models.Model):
    code = models.CharField(max_length=8)
    network = models.ForeignKey(Network, on_delete=models.PROTECT)
    
    class Meta:
        constraints = [
            models.UniqueConstraint(
                fields=["code", "network"], name="station_code_network_id_unique"
            )
        ]

    def __str__(self) -> str:
        return self.code
    
def run():
    net1 = Network.objects.create(code="net1")
    net2 = Network.objects.create(code="net2")
    stat1 = Station.objects.create(
        network=net1, code="stat1",
    )
    stat25 = Station.objects.create(
        network=net2, code="stat25",
    )
    networks = list(
        Network.objects.filter(code="net1").prefetch_related(
            Prefetch(
                "station_set",
                queryset=Station.objects.filter(code="stat1")
            )
        ).union(
            Network.objects.filter(code="net2").prefetch_related(
                Prefetch(
                    "station_set",
                    queryset=Station.objects.filter(code="stat25")
                )
            )
        )
    )
    print("with custom prefetch")
    print(networks[0].station_set.all())
    print(networks[1].station_set.all())
    networks = list(
        Network.objects.filter(code="net1").prefetch_related("station_set").union(
        Network.objects.filter(code="net2").prefetch_related("station_set")
    ))
    print("with regular prefetch")
    print(networks[0].station_set.all())
    print(networks[1].station_set.all())

ticket-36472 sqlite • 2 days, 23 hours

from django.db import models

class Foo(models.Model):
    field = models.IntegerField()
    field_db_default = models.IntegerField(
        db_default=models.Value(1)
    )
    field_generated = models.GeneratedField(
        expression=models.F("field"),
        db_persist=True,
        output_field=models.IntegerField()
    )

def run():
    instance = Foo()
    print(repr(instance.field))
    print(repr(instance.field_db_default))
    try:
        print(repr(instance.field_generated))
    except Exception as exc:
        print(f"Failed to access instance.field_generated: {exc}")

ticket-35381 sqlite • 2 days, 23 hours

from django.db import models

class Person(models.Model):
    name = models.CharField(max_length=100)
    data = models.JSONField(null=True)

    def __str__(self):
        return self.name

def run():
    Person.objects.get_or_create(name='Bob', data=None)
    Person.objects.get_or_create(
        name='Lana', data=models.Value(None, models.JSONField())
    )
    # Won't work as data=NULL is used instead of data IS NULL
    # remember that NULL != NULL!
    Person.objects.get_or_create(
        name='Phil', data=models.Value(None, models.Field())
    )
    Person.objects.get_or_create(
        name='Ari', data=None, data__isnull=True
    )

json-key-filter-none sqlite • 2 days, 23 hours

from django.db import models

class Report(models.Model):
    config = models.JSONField()

    def __str__(self):
        return self.config['name'] or '(Untitled Report)'

def run():
    instance = Report.objects.create(config={'name': None})
    qs1 = Report.objects.filter(config__name__exact=None)
    qs2 = Report.objects.filter(config__name__iexact=None)
    print(qs1)
    print(qs2)