Database Design: Easy to Use Design Environment
                                      ModelRight  adds functionality to support many of your database's most advanced features.  Its the answer when you need a database modeling tool that surpasses the  least common denominator approach taken by others. 
                                        
                                            - General Features
 
                                               
                                              
    
                                        
                                          � Undo/Redo 
                                            unlimited or user-defined number of levels. 
                                                                                        | 
                                           | 
                                         
                                        
                                          � Copy/Paste and Drag/Drop 
                                            within or between models.  Careful.  You'ld be surprised how many other products either don't have this or it doesn't work as advertised. 
                                                                                        | 
                                           | 
                                         
                                        
                                          � Find 
                                            Find any object in the model by its type, name
     
                                            or any other property. Search using regular expressions and other common
     
                                            search criteria.  A Search control is provided in the mail toolbar for quick access to common searches. 
                                                                                        | 
                                           | 
                                         
                                        
                                          � Reporting 
                                            maximum reporting flexibility by using XSLT
     
                                            Templates to generate reports.  Click on the icon on the right to view an actual generated report. 
                                                                                        | 
                                            | 
                                         
                                        
                                          � Impact Analysis 
                                            the transaction history shows the full
     
                                            impact of any change that you make as you make it.  View, save or print this info or use it
     
                                            to roll back changes. 
                                                                                        | 
                                           | 
                                         
                                        
                                          � Scalable Printing 
                                            simply drag the page bounds to specify how much of your Diagram you want on each printed page. 
                                                                                        | 
                                           | 
                                         
                                        
                                          � Custom Print Dialog 
                                            lets you select specific pages to print and change the print scale 
                                                                                        | 
                                           | 
                                         
                                        
                                          � Self-Validating Foundation 
                                            Building on over 15 years
     
                                            of experience developing database design software, ModelRight
     
                                            has been written from scratch with a framework that
     
                                            offers significant design tool functionality and a solid
     
                                            foundation on which to provide current service and to move forward. 
                                                                                        | 
                                           | 
                                         
                                        
                                          � ActiveX/Scripting 
                                            used internally to generate the database schema, a scripting interface
     
                                            (using any COM-based scripting languages like VBScript, Javascript in an HTML page, or any .NET language) provides transparent access to model objects
     
                                            and properties for any purpose - like creating custom features.  There's no need for a proprietary API. 
                                                                                        | 
                                           | 
                                         
                                               
                                             
                                            - 
                                            User Interface Features
 
                                               
                                              
                                               
                                        
                                          � Diagram Display 
                                            ModelRight provides unprecedented levels of control and flexibility when it comes to your Diagram's display.  You can display and on-diagram edit any object and any property.
                                             
                                                                                        | 
                                           | 
                                         
                                        
                                          � Model Explorer 
                                            an expandable/collapsible, categorized
     
                                            tree view of all your model objects. 
                                                                                        | 
                                           | 
                                         
                                        
                                          � Explorer Lists 
                                            An "Explorer List" is just a list of some type of object - like Tables.  However with ModelRight, you can also create a list of secondary (tertiary, etc) level objects - like Key Constraints.  At each level, you can include all objects or restrict them by specifying a "Filter".
                                             
                                                                                        | 
                                           | 
                                         
                                        
                                          � Mode-less 
                                            Our innovative mode-less style of
     
                                            interaction is simple and intuitive. Just click on an object in either the Model Explorer or Diagram to
     
                                            edit its properties.  No need to pop
     
                                            up dialog on top of dialog to make changes. 
                                                                                        | 
                                           | 
                                         
                                        
                                          � Hyperlinked Navigation 
                                            Like a Web browser, you can navigate to related objects
     
                                            by clicking hyperlinks on property pages.
     
                                            Navigate backwards and forwards in the selection history using >the navigate back/forward controls.  Define your own on-Diagram links to quickly navigate to other model objects or even websites. 
                                                                                        | 
                                           | 
                                         
                                        
                                          � Display Options 
                                            More display options than you can shake a stick at.  Change font,
     
                                            color, 2D or 3D outlining, solid or gradient fill.  Display table columns in Pk/non-Pk or generation order,  Pk
     
                                            columns only or table comment. Display
     
                                            any child category (i.e. column, index, key, trigger, etc) along with the
     
                                            table. Hide/display,
     
                                            expand/collapse the table display. 
                                                                                        | 
                                            | 
                                         
                                        
                                          � Diagram Navigator 
                                            gives you a bird's eye view of your Diagram.  The Diagram Navigator shows you a scaled down view of the current diagram so you can see exactly where you are within the overall Diagram.  Move the red rectangle/navigator to quickly pan around the diagram.  Scale it to quickly zoom in or out.  
                                                                                        | 
                                           | 
                                         
                                        
                                          � On-diagram Editing 
                                            create, delete, rename objects
     
                                            right on the Diagram. For columns,
     
                                            you can also change datatype, domain, PK option, and null option right on
     
                                            the Diagram. 
                                                                                        | 
                                           | 
                                         
                                        
                                          � Used-By Page 
                                            Reusable objects like storage objects (Tablespaces, Filegroups), Schemas, Types, User-defined Properties, Domains, etc... have a Used By Property Page.  This page displays and lets you edit which other Model objects use the selected object.  
                                            
  | 
                                           | 
                                         
                                        
                                          � Misc. Graphics 
                                            add text, rectangles, images, lines,
     
                                            circles, etc as a backdrop to or to add interest to your Diagram. 
                                                                                        | 
                                            | 
                                         
                                        
                                          � Multiple Notations 
                                            Barker (Oracle*Case), IE, IDEF1X, and UML notations are all
     
                                            supported. 
                                                                                        | 
                                            | 
                                         
                                        
                                          � Auto Layout 
                                            an expandable/collapsible, categorized
     
                                            tree view of all your model objects. 
                                                                                        | 
                                           | 
                                         
                                               
                                             
                                            - 
                                            Modeling Features
                                            
 
                                               
                                              
                                        
                                          � Domains 
                                            Domains are simply reusable objects - that can be used to define, categorize and organize the objects in your Model.  They simply define properties
     
                                            that can be "inherited" by other objects of that type.
     
                                            For example, you might have many Columns in your Model that are some type of ID (Customer ID, Employee ID, etc...).  Instead of having to assign common properties to them individually (a datatype of NUMBER, NOT NULL, etc..), you could create a Domain named ID, assign to it the common properties and then assign it to all of your ID Columns.  That way you are assured consistency of those properties across all of your ID Columns and you can easily change their properties simply by changing the ID Domain.  
                                             
                                            Other products might define something like a
     
                                            Column Domain, but only ModelRight extends this capability to many more types of
     
                                            objects - like Tables, Relations, Indexes, Diagrams, Graphics, Tablespaces, Materialized Views, etc...  
                                             
                                            For each type of Domain, ModelRight always provides a "default" Domain that
     
                                            objects of that type inherit from by default.  You can set Model-wide defaults on any object's property by setting them on the default Domain.  
                                                                                        | 
                                           | 
                                         
                                        
                                          � Relations 
                                            display,
     
                                            edit, and generate many types of relations - table relations, view relations, select from
     
                                            relations, and REF relations. 
                                                                                        | 
                                           | 
                                         
                                        
                                          � Compare with Model 
                                            compare models to see their differences and exchange information. 
                                                                                        | 
                                           | 
                                         
                                        
                                          � Naming 
                                            naming
     
                                            options let you specify how to handle non-unique name conflicts, max name
     
                                            lengths, case sensitivity and special characters. 
                                                                                        | 
                                           | 
                                         
                                        
                                          � Model Subsets 
                                            organize
     
                                            your tables and/or views into different subsets for display or other purposes. 
                                                                                        | 
                                           | 
                                         
                                        
                                          � Auto Model Subsets 
            Model Subsets" provide a basic organizational framework for your Model.  They let you break your model into more manageable pieces of related tables and views.  With ModelRight, you can create Model Subsets that are automatically maintained based on some generic criteria that you define. 
                                                                                        | 
                                           | 
                                         
                                        
                                        
                                          � Revision History 
                                            ModelRight adds the capability to maintain a list of Revision notes on any object - to document the changes to the object over time.  ModelRight also provides the capability to automatically add a revision note whenever an object changes.
                                             
                                                                                        | 
                                           | 
                                         
                                        
                                          � Key Migration 
                                            specify whether you would like to migrate the columns
     
                                            of a key (alternate or primary), define which columns to migrate manually, or
     
                                            specify no migration. 
                                                                                        | 
                                           | 
                                         
                                        
                                          � Unification 
                                            migrated
     
                                            columns are unified in the child table with other columns that have the same
     
                                            name. 
                                                                                        | 
                                           | 
                                         
                                        
                                          � Rolenaming 
                                            By
     
                                            default, a migrated column has the same name as it has in the parent
     
                                            column. This is maintained
     
                                            automatically. So if the parent column
     
                                            name changes, the child column will also.
     
                                            With rolenaming, you can specify that a migrated column should have a
     
                                            different name than it does in the parent table. 
                                                                                        | 
                                           | 
                                         
                                        
                                          � User-defined Properties 
                                            create your own properties and associate them with different types
     
                                            of model objects. 
                                                                                        | 
                                           | 
                                         
                                        
                                          � Model Validation 
                                            run an interactive report to
     
                                            show invalid and incomplete model objects.
     
                                            Click on the report items to correct the issue. 
                                                                                        | 
                                           | 
                                         
                                        
                                          � Incomplete objects 
                                            objects that have not been fully specified are colored red in the Model Explorer
     
                                            for quick identification.  Display a
     
                                            message box or run Model Validation to see why. 
                                                                                        | 
                                           | 
                                         
                                        
                                          � Alias Types 
                                            define your own datatypes as an alias for a built-in datatype  
                                                                                        | 
                                           | 
                                         
                                               
                                             
                                            - Database Features
                                            
 
                                               
                                              
                                        
                                          � Schema Generation 
                                            ModelRight makes the schema generation process completely transparent and user-extensible. VB
     
                                            scripts (or any COM enabled program) access the model's objects and properties
     
                                            to generate the database schema. Use
     
                                            the scripts we provide or overwrite them at the table, model, or cross-model
     
                                            level. 
                                                                                        | 
                                            | 
                                         
                                        
                                          � Reverse Engineering 
                                            connects directly to using a native driver.
     
                                            Filter by schema, storage, object type and expression to pick exactly
     
                                            what you want from your database. 
                                                                                        | 
                                            | 
                                         
                                        
                                          � Reverse Engineering into Model 
                                            allows you to add objects from the database to an existing model.   You can also do 
     
                                            this with the Database Compare feature, however, if you know what objects you want to add, this feature
     
                                            makes it easier and quicker. 
                                                                                        | 
                                           | 
                                         
                                        
                                          � Database Compare 
                                            You can compare your model with the current database to
     
                                            update the database with an ALTER script or to update your model from the database. 
                                                                                        | 
                                            | 
                                         
                                        
                                          � Change Script Wizard 
                                            ModelRight provides the ability to generate SQL DDL based on recent Model changes.  This can be very useful if you want to change the database to reflect the changes you recently made to your Model.  If you know that your database hasn't changed and you just want to change it to reflect changes you just made in your Model, you can do so without having to go through the Compare with Database process/wizard.  
                                            
  | 
                                           | 
                                         
                                        
                                          � Modeless Database Compare 
                                            shows you a comparison of your Model with the Database as you Model.  
     
                                            Keep it open as you model and changes made to the Model will be automatically reflected in the 
     
                                            Database Compare window - so you can always have a view of how your Model differs from the database.  
     
                                            You can import or export differences without having to restart the compare process.  
                                            
  | 
                                           | 
                                         
                                        
                                          � Oracle support - 8i, 9i, 10g and 11g 
                                            ModelRight supports the usual database objects like Table, View, Index, Constraint (PK,
     
                                            FK, UK) and Oracle specific features like, Materialized Views, 
     
                                            Tablespaces, Clusters, Sequences, Packages, Procedures, Functions, Triggers, Synonyms, Schemas, Index-organized tables, Table and Index (Local and Global)
     
                                            Partitions, LOB storage options, REF columns, Function-based indexes, etc 
                                                                                        | 
                                           | 
                                         
                                        
                                          � SQL Server - 2000, 2005, 2008, 2012, 2014, 2016, 2017, 2019 
                                            provides in-depth support - including many SQL Server-specific features like Fulltext Indexes, Filestreams, Computed Columns, Partitioning, etc..  
                                                                                        | 
                                           | 
                                         
                                        
                                          � MySQL support - 5.x and 6 
                                            ModelRight supports the usual database objects like Table, View, Index, Constraint (PK,
     
                                            FK, UK) - plus MySQL specific features like Collations, Character Sets, Engines, Logfile Groups, Databases, Tablespaces, Datafiles, and many MySQL-specific properties.  
                                                                                        | 
                                           | 
                                         
                                        
                                          � ODBC 
                                            if you need to connect to a database that is not explicitly supported, you can use the ODBC database.  ModelRight can Reverse Engineer, Forward Engineer, and Synchronize with any ODBC compliant database. While ODBC support does not have the in-depth support for physical details, it does support basic objects like Schemas, Tables, Views, Columns, Indexes, Key and Foreign Key Constraints and all the database functions (Reverse/Forward Engineer and Compare/Alter).  
                                                                                        | 
                                           | 
                                         
                                        
                                          � Object-Relational (Oracle only) 
                                            create new Types, attributes, object tables, object views, etc 
                                                                                        | 
                                           | 
                                         
                                        
                                          � Views (and Oracle Materialized Views) 
                                            keeps the view up to date even when the referenced objects
     
                                            change. Changes made to the underlying objects
     
                                            are automatically reflected in the View definition. 
                                                                                        | 
                                           | 
                                         
                                        
                                          � Infer Options 
                                            If your database does not contain Key Constraint or Referential Constraints, then you can use ModelRight's Infer Options to automatically create them.
                                                                                       
                                          Entity Relationship Model Tools
Supports Large Data Warehouse Projects
                                             | 
                                          
     | 
                                         
                                               
                                             
                                         
                                         |