mythic | generation starter theme designed to help theme authors | Theme library

You can use custom converter to be able to deserialize to different types in same hierarchy. Also I highly recommend using properties instead of fields. So small reproducer can look like this:

I was suggested to use Smart Plugins for modular system instead of my solution, which solves it.

Since you want to count Aniplex and Magic only, you should put it in the if block and then after loops write it to the file:

You might be thinking of this the wrong way. Speaking to your specific concerns...

4 separate round trips to the database

Yes, that's true but ideally these would be happening simultaneously. Ie. you shouldn't be waiting for query 1 to return before you fire off query 2. Running the queries in parallel effectively makes the round-trip latency a constant.

How you achieve this comes down to the platform/language your app (the thing issuing these queries) is built in. You many need to reach for some async/await or threading tooling.

4 separate queries that must be made from scratch. The results of some queries should be able to be reused for others. Query 3 < Query 2 < Query 1, and Query 4 < Query 2. That is, the rows of query 2 are a subset of the rows of query 1. So having to go through all the rows again seems bad to me.

It's tempting to think this when you see multiple queries with similar conditions. The (sometimes counter-intuitive) fact is, database are pretty good at resolving queries against a well indexed table and, generally, the simpler the query, the easier it is for the query planner to build a query that will resolve quickly. Trying to be clever by building more complex queries can sometime backfire.

For example, pulling all the records where "championId" = 1 out then performing multiple queries against it might seem like a good idea but, in reality this may require the DB to copy a huge amount of data to memory. Plus, this temporary dataset may not be indexed the same way the original table was, meaning the subsequent queries, although they're running against a smaller dataset, may still be slower.

There definitely are times when isolating a small set of expensive data then querying it multiple ways is the right solution but the example you've given isn't one of them. Put another way, you might be overthinking it. Postgres is a powerful and mature platform that's entire job is consuming queries. Simple comparisons that hit indexed columns will generally be surprisingly fast.

(It all depends on your specifics though so if in doubt, benchmark it.)

Still want to combine multiple queries together even though it's probably not necessary? Ok, let's try it..

A single query is always going to return a single record set. That is, you're always going to get back a "rectangular" set of data, where each row has a value for each column (even if it's null). As such, there's 2 was you can add additional data into a query: by adding more rows or by adding more columns.

First lets setup some test data:

I am not sure about what you want to do exactly.

Let say your have a JSON data file accessible by a simple GET request (as it seems to be) and want to convert it into an XML file using PHP.

First, you can convert your json to array with json_decode. Then, you can SimpleXML extension to generate an XML output.

As an example:

This should do it:

pricing_cards.objects.filter(card_id__rarity='mythic').order_by('card_id', '-datetime').distinct('card_id').values_list('nonfoil', flat=True)

I've tried your code snippet with my service account JSON file and dataset in my project. It worked as expected. Not clear why it's not working in your case.

Hovewer you can try to use service account JSON file directly like that:

There are various approaches to this problem. A rather more traditional and exact (but also prone to issues with new words) is to use a thesaurus for French and English and check if the phrase is found in one or the other (full match or more words matching).

Another one is to use a package for language detection.

Yet another one would be to use an ML language model to classify phrases (e.g. SpaCy lang_detect model).

I guess in your case it is best to use the usual line continuation method using a backslash \: