Simpycity: A Quick Tutorial
Posted Wednesday Jan 21st, 2009 04:20pm
by Aurynn Shaw | Permalink



Using Simpycity is as easy as its name suggests - quick, easy. Simple.

In keeping with that philosophy, Simpycity offers 3 constructs for
database access: Function, Query, and Raw.

Read more...

---

Simple PostgreSQL Database Mapping
Posted Wednesday Jan 21st, 2009 04:16pm
by Aurynn Shaw | Permalink



With everyone and their mothers trying to build the next awesome website
and next amazing web service, you'll probably find that SQL databases
are getting more and more popular. As it turns out though, writing
complex software on databases is harder than it looks. Hard enough that
database abstractions are growing in popularity, pushing "database
agnosticism" and turning the database into a dumb, interchangable data
store.

As a database developer, trying to write app code in this environment is
really frustrating. I know how to design a DB schema. I know how to
abstract that schema with views and stored procedures. When I try to use
an ORM? All it does is get in my way, especially when you lose most of
the ORM functionality by going to raw SQL.

Writing SQL straight against the PostgreSQL DB API isn't much better - I
end up writing the same boilerplate connection code, return handling and
other management that comes with working with low-level interfaces.

Honestly, this is more trouble than it's worth.

Simpycity changes that.

Model definition? Unnecessary. One line to declare a function signature.
One line to declare a simple query. One line to declare raw SQL.
Returned rows are nothing but standard Python dicts.

Got a model definition? All three support wrapping returned rows in any
arbitrary model definition.

Need to change your data model? Update your app by doing nothing more
than adhering to the same API you developed the first time. A minor
change in the database is a minor change in Simpycity.

Instead of designing your entire API in terms of Python, you seamlessly
connect your well-structured database to the Pythonic representation of
your choice, cleanly and easily maintaining separation of logic and
duty.

It's simplicity.

Here's how it works:

>>> from simpycity.core import Function
>>> function_def = Function("get_rows")
>>> results = function_def()
>>> function_def.query
SELECT * FROM get_rows()

>>> function_def = Function("get_row",['id'])
>>> function_def.query
SELECT * FROM get_row(%s)

>>> results = function_def(1) 

- or -

>>> results = function_def(id=1)

That's it. That's Simpycity. Simple, easy, seamless mapping of
PostgreSQL stored procedures to Python.

Simpycity is a Commandprompt Open Source project, licensed under
the terms of the Lesser GPL and you can get it from
https://projects.commandprompt.com/public/simpycity/

---