Acces to db made easy

- Home
- Sqlkit
  - Sqlkit
  - Widgets
    - Mask view
    - Table view
  - Browsing data
    - Constraints
    - Filters
    - Totals
  - Editing data
    - Completion
    - Validation
    - Relationships
  - Advanced configuration
    - Fields
    - Views
- Sqledit GUI
- Support & Tutorials
  - Sqledit - the application
  - Sqlkit - features' tour
  - Installing instructions
- Layout
- Download
  - Download
  - Changelog
  - Backward incompatibilities

# Sqledit for end users

The easiest possible way to browse the data of your database

You can customize the way data are presented in a very simple way. The ideal tool to edit your personal databases or to browse data of an application you're developing with other languages/tools.

Filtering data has never been so easy, no SQL knowledge required. Read more...

# Sqlkit for Python developers

A powerful framework to create any application from simple to very rich and complex ones.

Sqlkit provides 2 widgets to edit data as form or table. It's based on PyGTK and sqlalchemy to provide maximum flexibility.

Key points are the way to design form layout with relationship, completions, validation and filter capabilities that can be done w/o any effort. More than 80 examples ready to use! Read more...

- The application 'sqledit' can open a great variety of different backends as it's base on SqlAlchemy: PostgreSQL, MySQL, sqlite, firebird... You can use it to browse your data or to debug an application you're developing. The rich configuration capability of sqledit can make it grow in a gentle way toward a true application what starts as a simple shortcut to some data.
- Each table of the database can be opened in Mask or Table way or introspected.
- Table fields can be automatically reflected from the database or set using sqlalchemy's standard way. Here the example used in the demo for directors and the way to set the relation with 'movie' table.
- Each database table can be opened in table or mask mode. The image shows table mode where each column can be sorted and it's field can be added to a filter tool.
- Create a form to edit relations is as easy as writing a text layout (clearly you must define relations in the model):

      	 lay = """last_name
       	          first_name nation
      	          o2m=movies"""
      	 SqlMask(Movie, layout=lay, dbproxy=db)

- Each field of a table/mask even of a related table can be filtered on. Just click on the label and a filter panel will be presented. A smart and efficent way to express dates in a relative way lets you great flexibility. Here date_release >= 'y-5' means a film released after Jan, 1^ 5 years ago, whenever you run the filter.

- Filters and constraints can be programmatically added using a syntax derived from django orm. User are allowed to play with filters while constraints are used to limit the visibility of some records.

- The SqlMask widget shows one record at a time. Any field type will be rendered in a proper way. Images are varchar field for which a `render='image'` is set when defining the model. The layout can be set in a incredibly simple way w/o any programming knowledge.

- Right click on a record offers a variety of different actions. The most important is the ability to open a SqlMask to view/edit that record the record pointed to by the foreign key.

- A mask that displays a single record can use a registered layout and will follow the selection of the underneath table.

- Any foreign key is automatically detected and a widget that implements completion on the foreign table is used. Completion is triggered by 'Return' and the search on the foreign key is done in a customizable field and represented in a customizable way (here: first_name + last_name)
- Completion can be programmed in a group-by fasion or constrained in a dinamic way so that the value of a field is used to filter the possible completions:

      	t = SqlTable(Invoice, ...)
      	t.completions.project_id.filter(client_id='$client_id') # dynamic
      	t.completions.client_id.group_by = 'category' # group-by

- Table can display totals and subtotals. Here subtotals w/o totals where requested.

- Rows can be displayed with a hierarchy

- Tables and Masks can show any selectable that you may define with sqlalchemy. Here a join between two columns is displayed and fields from both tables retain the possibility to be edited.

               m = mapper(Join, model.Movie.__table__.join(model.Director.__table__),
                 properties={
                       'movie_id' : model.Movie.__table__.c.id
                  })
               t = SqlTable(m, dbproxy=db )

- You can add computed fields as in this case where the number of movie is computed for each director, you can further sum and sort on those fields.

- ## HOOKS & signals

  Many signals and hooks are available to the programmer for a powerful level of customization.

  A "hook" class can be registered globally so that its attached to any SqlWidget open in any situation, both in form or table view. That's the "controller" part in the MVC implementation.

  Hooks allow you to customize almost any part as are called on validation, on completion, on record display, on value change so that it's very easy to create a very interactive interface.