Hi,

> About Left Outer Joins:
>
> Would the use of a custom Q object in Django to perform a LEFT OUTER
> JOIN require programming in raw SQL or can it be done programming with
> the ORM API only? In the first case it does not count as explained in
> the document. In the second case I will be happy to amend the slides.

See the custom Q object code here if you're interested:
http://www.djangosnippets.org/snippets/274/

As you can see, it does not use raw SQL statements at all. It makes
use of a well-defined/documented Django ORM API (custom Q objects)
that helps a developer extend the ORM functionality.

>
> About ByteCode compilation:
>
> Although I agree with your observation below you are comparing apples
> with oranges. It is true that you can bytecode compile any python
> application but what about templates for example?

But that's because, as you said, we are comparing apples with oranges:
Django's templating language is not Python-based. So, a discussion of
Python byte-code compilation of a Django template is irrelevant.
Perhaps you should consider stating a conditional "Yes - available for
models and views but not for templates" against Django in that slide?

Django templates can be easily cached so that the parsing effort is
not required on every request. Template caching at various layers is
already documented as well.

> With one click,
> web2py collapses the template hierarchy for each page into a single py
> file, then bytecode compiles all models, controllers and templates and
> zips everything into a single plug-in package. The main purposes of
> this are ease of deplyment and speed since there is no more template
> parsing at runtime.

Django does not have this one-click feature.

As many owners of high-performance Django apps will attest, template
rendering in Django is already very fast especially with gracious use
of caching. So template parsing at each request is easily avoided.

>
> The web2py binary distribution is compiled with py2exe (for widnows)
> and py2app (for Mac). That is what cx_freeze can be compared with.
>
> Anyway, if you post an example of a Django bytecode compiled
> application and documentation on how to create and deploy it, I will
> amend my document to reflect that. If a feature is not tested and not
> documented it does not count.

As we both agree, byte code compilation is a Python feature and as
such it is well-documented and well-tested. The documentation for
deploying a pre-compiled Django app would be:

1. Precompile your Django app using:

import compileall
compileall.compile_dir(APP_ROOT_DIR_PATH, force=1)

2. Optionally delete *.py source files from the app.

3. Deploy it as you would deploy any other Django app. This is already
documented by Django.

>
> Let me say once again: I like Django and I took inspiration from it.

Welcome to the club :)

-Rajesh D
--~--~---------~--~----~------------~-------~--~----~
You received this message because you are subscribed to the Google Groups 
"Django users" group.
To post to this group, send email to django-users@googlegroups.com
To unsubscribe from this group, send email to [EMAIL PROTECTED]
For more options, visit this group at 
http://groups.google.com/group/django-users?hl=en
-~----------~----~----~----~------~----~------~--~---

Reply via email to