DbSchema vs DbVisualizer
DbVisualizer and DbSchema are two powerful tools for designing and managing databases. Further, we will compare both tools
focusing on 5 main points:
- Connectivity
- Interface
- Schema & Diagram
- Query Tools
- Managing Data
- Price
Connectivity
Both DbSchema and DbVisualizer can connect to any SQL, NoSQL and Cloud database using JDBC drivers.
Interface
DbVisualizer
DbVisualizer offers an interface that enables users to interact with database objects. It integrates a tree menu on the
left side of the screen from which the user can browse the objects and open them in the middle working area.
The working area can contain multiple Object View tabs or SQL Commander tabs. The first category opens a database object
that can be modified or browsed. In the SQL Commander, the user can run simple queries or scripts.
DbSchema
The interface on DbSchema offers more of a visual approach to database browsing. On the left side of the screen, there is
a classic tree menu from which the user will browse databases, schemas, and tables. The tables can be dragged to the center and arranged in a layout.
A user can open multiple layouts, each focused on any part of the database. A table can be opened in multiple layouts at the same time.
The layouts are interactive and any database object can be modified directly in the schema (tables, columns, foreign keys, indexes, etc.).
The layout contains the query tools that open at the bottom of the screen.
Query Tools
DbVisualizer
SQL Editor
The SQL editor can run single queries and scripts. A frequently used query can be saved to a template and re-executed
when needed. For complex scripts, DbVisualizer offers options that save memory and prevent the app from crashing.
Also, the user can select specific SQL blocks from the script and run them separately.
Visual Query Builder
The Visual Query Builder runs as an extension of the SQL editor. It can create queries using all types of Joins with
Aggregate and Group functions. At the bottom of the editor, there are 4 columns that provide a detailed view of the query.
From here, the user can modify the Aggregate & Group functions, Conditions and sort the results.
The visual query can be copied and executed in the SQL editor and the results will be shown at the bottom.
The results from the queries can be exported to various formats.
The queries themselves can be saved and compared. In the case of an error, this will be displayed in the results panel.
DbSchema
SQL Editor
The tool integrates an SQL editor that can also run single queries or scripts. It can run Groovy or JavaScript.
In the case of a complex script, the powerful engine will handle the parsing and execution smoothly.
The user can select a single part of a script and run it. The SQL History shows every query executed in the application
(visual or in the SQL editor). The user can re-execute e query from there by copying it to the editor.
Visual Query Builder
DbSchema offers a Visual Query Builder in which the tables can be added by drag & drop.
From an added table, the user can right-click on the header and add another one based on foreign keys. The tool can create
visual queries using any type of Joins with Aggregate and Group functions. On the right side of the screen, the
Preview tab shows the visual query in SQL language. After executing, the results will be shown at the bottom of the screen.
Both SQL editor and Visual Query Builder can explain a script and export the result in various formats.
Relational Data Editor
DbSchema integrates another query tool named Relational Data Editor. Users can visualize & edit data from multiple tables
simultaneously. Once a table is open in Relational Data Editor, the user can cascade into further tables based on foreign keys.
When a table selection changed, the referenced data from the other tables change accordingly.
Data can be edited just by double-clicking on a cell.
Schemas & Diagrams
DbVisualizer
In DbVisualizer, the user mainly interacts with the schema and the objects from the left menu. A table can be altered by
right-clicking on it in the node. From there the user can alter its columns, primary keys, foreign keys, and indexes.
For every change made, the SQL syntax will be shown below.
DbVisualizer can open the ERD diagram by right-clicking on the node and opening it in object view. The objects can be
arranged in many different layouts and the diagram can be exported to JPEG, SVG, PNG, PDF, GIF or GML.
Although DbVisualizer can’t compare the schemas in terms of objects and data, the user can select the items one by one
and compare them. For example, two table nodes can be opened in separate tabs and compared.
DbSchema
DbSchemas’ whole workflow is based on the diagram. Once a layout is created and filled with tables, the user can interact
with the objects in the diagram. Tables and columns can be modified by double-clicking on them. Once clicked a new window
appears with all the details that can be edited.
Foreign keys can be created either from the table editing dialog or by drag & dropping a column over another. In DbSchema
every object from the diagram is interactive. The user can see where a foreign key is pointing by hovering it with the
mouse or change it’s pointing direction from the top menu. It is possible to create a virtual foreign key that exists only in the
model file and doesn’t affect the database.
For Mongo DB, DbSchema can deduce the database diagram by analyzing the JSON objects.
DbSchema saves everything to a local model file that can be reopened even without database connectivity.
When in offline mode, the user can modify every aspect of the schema. After reconnecting to the database, the local schema will be compared &
synchronized with the database schema.
Working with model files makes it very easy to work in a team. Two different versions of the same model file can be
compared, synchronized and shared in a team using GIT.
DbSchema can export interactive HTML5 or PDF documentation.
Working with data
DbVisualizer
To interact with the data in DbVisualizer, the user has to open the table and select the data tab. Cells can be modified
by clicking on them. The grid view is pretty straightforward and solid. The tool can read & format text, JSON files or images.
The user can compare the DDL and data of two tables. DbVisualizer can import data from CSV format and Excel (.xsl and .xslx).
DbSchema
DbSchema has a more visual approach to browsing & editing data. First, the tool integrates a quick view function that
can be opened by clicking on a table header while holding CTRL + SHIFT keys. This will open a floating window of the table.
From here the data can be edited by clicking on the cell.
Another way of browsing the table data is with the Relational Data Editor explained in a chapter above. This feature offers
an overview of the relations between data.
DbSchema can load data from delimited text files, CSV and Excel (.xsl, xlsx) formats. The user can do this through a simple
Data Loader wizard.
For generating test data, DbSchema integrates a powerful Data Generator that uses configurable, random and reverse
regular expressions. The user can choose data patterns from the integrated library or configure its own data patterns.
Price
DbVisualizer
The price for a DbVisualizer Pro license starts at $195/ user with an additional $69 for yearly licence renewal. The tool also comes with a
free version.
DbVisualizer offers discount for academic institutions and for bundle purchase.
DbSchema
DbSchema offers 3 types of licenses:
- Academic - $98
- Personal (for individuals) - $196
- Commercial (for companies) - $294
Discounts will be applied for bundle purchase.
Conclusion
When to use DbVisualizer
DbVisualizer has a more technical approach to database design. If you don’t mind writing and reading complex SQL syntax, than DbVisualizer can
be a good tool. It has some nice features such as SQL templates or Query Monitoring, but lacks others like Schema Comparison or Random Data
Generator.
When to use DbSchema
DbSchema offers a more visual approach to database design. You can easily interact with the diagram and execute queries only by drag & drop or
double-click. Working with the model files makes it very easy to compare different versions of the schema or work in a team.
