I really want to use datatable for big data with runtime custom query .I have tried django-datatable but seem , it have only static custom query. thanks
I took a quick look at django-datatable; the only thing it seems to do if provide a template tag to render entire DB tables to HTML responses.
{% load table_tags %}
...
{% render_table people %}
If you want custom DB queries in django, the normal way is to use the ORM, i.e.
#!/usr/bin/env python
from models import Person
from django.shortcuts import render_to_response
...
def some_view(...):
a_people = Person.objects.filter(name__startswith="A")
return render_to_response(<template>, context={"people":a_people})
// HTML template
...
{% for person in people %}
<tr><td>{{ person.id }}</td><td>{{ person.name }</td></tr>
{% endfor %}
...
This allows you all freedom to define a dynamic DB query in your python code.
Related
I want to loop over all of the collections in my Jekyll site, and within that I want to sort and list all of the pages in that collection.
Based on this stackoverflow answer, I can loop through all the collections and items:
{% for collection in site.collections %}
<h2>Items from {{ collection.label }}</h2>
<ul>
{% assign pages = site[collection.label] %}
{% for item in pages %}
<li>{{ item.title }}</li>
{% endfor %}
</ul>
{% endfor %}
For a specific collection, I can also sort the update field from the frontmatter:
{% assign sorted = site.programming | sort: 'update' %}
But if I try to apply this to the 1st example, it fails:
{% assign pages = site[collection.label] | sort: 'update' %}
This gives a rather generically useless error:
Liquid Exception: Liquid error (line 30): comparison of Array with Array failed in index.md
Error: Liquid error (line 30): comparison of Array with Array failed
Error: Run jekyll build --trace for more information.
I'm guessing that somehow site[collection.label] returns something different than site.programming, but I'm not sure what, or how to solve this.
EDIT: I tried using collection.docs instead of site[collection.label] and got the same error.
The cause of this error turned out not to be the difference between collection.docs and site[collection.label]. Rather, in one of the collections, there was an item where the frontmatter did not contain the update field. As a result, it couldn't sort by this field because not all items had it. Similarly, you get the same error if the types are not comparable in all cases. In this case, they were all supposed to be dates; if one was not a valid date format, it failed.
I still think this is a terribly ambiguous error message.
i want to print the value of current item in list(which is a integer) and its successor(not the list item) but the actual integer successor) at the same time..i am using
{% for i in hour %}{{ i }}-{{i+1}}{% endfor %}
but this gives me an error of "Could not parse the remainder: '+1' from 'i+1'"
Try: {{ i }}-{{ i|add:"1" }}
See https://docs.djangoproject.com/en/1.8/ref/templates/builtins/#add
As far as I know there are three approaches:
Change to a different templating language that allows cleaner logic (Mako I believe though my knowledge is out of date)
Install a third party django package that allows you to do math in templates.
Create a template tag that accepts a value (i), does the calculation you want, and returns that value.
#3 is the one I would suggest.
I want something like:
---
my_var: "foo.bar.baz"
---
{{- site.data.header[page.my_var] -}}
Unfortunately, it doesn't work…
I know that I can use site.data.header.foo.bar.bazor site.data.header["foo"]["bar"]["baz"], but it's not that.
Also I know that I can split page.my_var to substrings and use them then as site.data.header["foo"]["bar"]["baz"]. But this increases Jekyll build time.
I guess I need some Ruby plugin, but don't know one and I don't know Ruby to write one.
If you know such plugin or can help me write one or know some native workaround, this would be sooo great!
Help :)
Also I know that I can split page.my_var to substrings and use them then as site.data["foo"]["bar"]["baz"]. But this increases Jekyll build time.
I'm not sure you can do this. And even if you can, I'm not sure that there is a real performance impact.
But you can do this :
_data/foo.yml
bar:
baz: 1
biz: 2
buz: 3
beer:
baz: 1
biz: 2
buz: 3
Then :
---
my_var: "foo.bar.baz"
---
{% assign keys = page.my_var | split: "." %}
{% assign object = site.data %}
{% for key in keys %}
{% assign object = object[key] %}
{% endfor %}
{{ object }}
What are hoping to do has been blocked by design.
site.data["foo.bar.baz"] implies that you need to have a data file named foo.bar.baz.yml or foo.bar.baz.json, ... etc.
But Jekyll sanitizes data files' names and therefore the resulting object would only have a key named "foobarbaz"
A plugin that purposely removes this sanitization can written but it wouldn't appear to be a benign or safe to end-users. So the chances of finding such a plugin in the wild is slim..
I have a problem on retrieving the data from database,
I'm using Mysql database and one table which contains 15 fields which I'm going to display it on template in a table.
It has more than 4 million records in the table,
def index(request):
args = {}
data = Mymodel.objects.all()
args['data'] = data
return render(request, 'index.html', args)
I tried this way but the data loads very very slowly,
and next approach I tried for database connections
def index(request):
args = {}
sql = "select * from mymodel"
cursor = connection.cursor()
cursor.execute(sql)
result = cursor.fetchall()
args['result'] = result
return render(request, 'index.html', args)
This also does the same, I need to load the data much faster. Please suggest to me any approach that would load the data faster.
One concept correction before the solution is that using raw sql doesn't do any better than django ORM and you also lost the ability to use ORM api to display the data easily.
The common solution is to use django built in pagination to show only certain amount of records per page. Django doc has very detailed explanation about the usage of pagination.
Since you're already executing a raw query, I don't think you'll be realistically able to do much better than what you have.
Is there any reason why you can't paginate the results? Normally you never return all the data available.
You can try and use a QuerySet.iterator to avoid having to load all your instances in memory at once. Also, QuerySet.values would return dictionaries instead of full-blown model instances, reducing memory usage.
If you absolutely need to and you get into request timeouts, one option is to run the actual data retrieval in the background. For example, you could use Celery and run the query as part of a task. Your view would trigger the Celery task and return a task identifier in the response. The consumer could then poll a "job status" endpoint passing such task id and retrieve the results when they are ready. You'd still need to store the results somewhere else (faster) than your db, i.e. Redis (which you can easily use as a Celery backend).
This approach is obviously more convoluted and would add a few moving parts to your system and you're likely to get into other issues anyway (e.g. the response size). Using pagination if possible would be a lot easier.
You can use pagination if you want your system to work for thousands of records. Django genaric ListView will help you in this case. They are easy to use. They works like this
class YourView(ListView):
template_name = 'books/acme_list.html'
context_object_name = 'object_list'
queryset = TableName.objects.all()
paginate_by = 50
Your template will be like this
<table id="exam">
{% for object in object_list %}
<tr>
<td>{{ object }}</td>
</tr>
{% endfor %}
</table>
And your paginate section will be like this
{% if is_paginated %}
<ul class="pagination">
{% if page_obj.has_previous %}
<li>
<span>Previous</span>
</li>
{% endif %}
<li class="">
<span>Page {{ page_obj.number }} of {{ page_obj.paginator.num_pages }}.</span>
</li>
{% if page_obj.has_next %}
<li>
<span>Next</span>
</li>
{% endif %}
</ul>
{% endif %}
You can find further detail in this link and Django documentation.
I'm trying to use a sandboxed Jinja2 environment to handle template customizations.
I've tried using both a DictLoader and FunctionLoader, but keep running into similar issues... I'm mostly concerned with FunctionLoader now.
I can't manage to include or import another template (which contains macros). The FuctionLoader's specified "load" function is never called for the referenced templates.
I've tried with no luck:
just expecting an import would hit the loader using basic 'import' and 'include' syntax
passing the loader into the context , seeing if it might pull in that way
passing a dict of templates into the context, also hoping it might pull in
a few more things , all of which I forgot
I'm sure there's got to be a way to support this - can someone point me in the right direction ?
The import syntax must use quoted strings.
Bad:
{% import utils %}
{% import utils.macros as macros %}
{% from utils.macros import macro_1 , macro_2 %}
Good:
{% import "utils" as utils %}
{% import "utils.macros" as macros %}
{% from "utils.macros" import macro_1 , macro_2 %}
The quoted string is passed into the FunctionLoader or used as the key with the DictLoader