Acces to db made easy

- Home
- Sqlkit
  - Sqlkit
  - Widgets
    - Mask view
    - Table view
  - Browsing data
    - Constraints
    - Filters
    - Totals
  - Editing data
    - Completion
    - Validation
    - Relationships
  - Printing
  - 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...

- ## Sqledit

  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.

- ## Table's list

  Each table of the database can be opened in Mask or Table way or introspected.

- ## The model (optional)

  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.

- ## Table view

  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.

- ## Relationships

  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)

- ## Filters

  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.

- ## Contraints

  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.

- ## Mask View

  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.

- ## Mask view from any row

  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.

- ## Registered layout

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

- ## Completion

  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)

- ## Group by on completion

  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

- ## Totals

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

- ## Trees

  Rows can be displayed with a hierarchy

- ## Editing joins

  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 )

- ## Computed fields

  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.

- ## Printing

  Sqlkit provides a very powerful template system that allows to compose the layout with OpenOffice.org. No programming know-how is required to create an effective template, no more headache to get the right layout using OpenOffice's `writer`.

- ## 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.