SchemaCrawler 17.8.1
Database schema discovery and comprehension tool
https://www.schemacrawler.com/
Copyright (c) 2000-2026, Sualeh Fatehi <sualeh@hotmail.com>.

You can search for database schema objects using regular expressions,
and output the schema and data in a readable text format. You can find
potential schema design issues with lint. The output serves for
database documentation is designed to be diff-ed against other database
schemas. SchemaCrawler also generates schema diagrams.



** Turn logging on or off
Shell Command:
log

Options:
      --log-level=<loglevel>
         Set log level using one of OFF, SEVERE, WARNING, INFO, CONFIG, FINE,
           FINER, FINEST, ALL
         Optional, defaults to OFF


** Load SchemaCrawler configuration from the classpath and file
Shell Command:
config-file

For more information, see https://www.schemacrawler.com/config.html

Options:
  -g, --config-file=<configfile>
         Read SchemaCrawler configuration properties from <configfile>
         <configfile> is the full path to the configuration file
         Optional


** Connect to the database
Shell Command:
connect

For database connections, please read
https://www.schemacrawler.com/database-support.html
first, before running SchemaCrawler

Options:

For connecting to specific databases, use
      --database=<database>
                          Database name
      --host=<host>       Database server host
      --port=<port>       Database server port
      --server=<database system identifier>
                          Where <database system identifier> is a database for
                            which a SchemaCrawler plug-in is available
                          Use one of test-db
      --urlx=<String=String>
                          JDBC URL additional properties

If your database does not have a SchemaCrawler plug-in, use
      --url=<connectionUrl>
                          JDBC connection URL to the database
Specify the database user name using one of these options
      --user=<user>       Database user name
      --user:env=<environment variable name>
                          Database user name, from an environmental variable
                            value
      --user:file=<path to user file>
                          Database user name, read from a file
      --user:prompt       Database user name, prompted from the console
Specify the database password using one of these options
      --password=<password>
                          Database password
      --password:env=<environment variable name>
                          Database password, from an environmental variable
                            value
      --password:file=<path to password file>
                          Database password, read from a file
      --password:prompt   Database password, prompted from the console

For additional options, specific to individual database server plugins,
run SchemaCrawler with: `-h servers`


** Limit database object metadata
Shell Command:
limit

When you limit database object metadata, it reduces SchemaCrawler's visibility
into other database objects.
From SchemaCrawler's perspective, the other database objects do not exist.

Options:
      --exclude-columns=<excludecolumns>
                            <excludecolumns> is a regular expression to match
                              fully qualified column names, in the form
                              "CATALOGNAME.SCHEMANAME.TABLENAME.COLUMNNAME" -
                              for example, --exclude-columns=.*\.STREET|.*\.
                              PRICE matches columns named STREET or PRICE in
                              any table
                            Columns that match the pattern are not displayed
                            Optional, default is to show all columns
      --exclude-parameters=<excludeparameters>
                            <excludeparameters> is a regular expression to
                              match fully qualified parameter names - for
                              example, --exclude-parameters=@p1|@p2 matches
                              parameters named @p1 or @p2 in any procedure
                            Parameters that match the pattern are not displayed
                            Optional, default is to show all parameters
      --routine-types=<routinetypes>[,<routinetypes>...]
                            <routinetypes> is a comma-separated list of routine
                              types of PROCEDURE,FUNCTION
                            Optional, defaults to PROCEDURE,FUNCTION
      --routines=<routines> <routines> is a regular expression to match fully
                              qualified stored procedure or function names, in
                              the form "CATALOGNAME.SCHEMANAME.ROUTINENAME" -
                              for example, --routines=.*\.C.*|.*\.P.* matches
                              any routines whose names start with C or P
                            Routines that do not match the pattern are not
                              displayed
                            Use --routines= to omit routines
                            Optional, defaults to showing no routines
      --schemas=<schemas>   <schemas> is a regular expression to match fully
                              qualified schema names, in the form "CATALOGNAME.
                              SCHEMANAME" - for example, --schemas=.*\.C.*|.*\.
                              P.* matches any schemas whose names start with C
                              or P
                            Schemas that do not match the pattern are not
                              displayed
                            Optional, defaults to showing all schemas
      --sequences=<sequences>
                            <sequences> is a regular expression to match fully
                              qualified sequence names, in the form
                              "CATALOGNAME.SCHEMANAME.SEQUENCENAME" - for
                              example, --sequences=.*\.C.*|.*\.P.* matches any
                              sequences whose names start with C or P
                            Sequences that do not match the pattern are not
                              displayed
                            Use --sequences= to omit sequences
                            Sequences will only be shown when -infolevel=maximum
                            Optional, defaults to showing no sequences
      --synonyms=<synonyms> <synonyms> is a regular expression to match fully
                              qualified synonym names, in the form "CATALOGNAME.
                              SCHEMANAME.SYNONYMNAME" - for example,
                              --synonyms=.*\.C.*|.*\.P.* matches any synonyms
                              whose names start with C or P
                            Synonyms that do not match the pattern are not
                              displayed
                            Synonyms will only be shown when -infolevel=maximum
                            Use --synonyms= to omit synonyms
                            Optional, defaults to showing no synonyms
      --table-types=<tabletypes>[,<tabletypes>...]
                            <tabletypes> is a comma-separated list of table
                              types supported by the database
                            If no value is specified, all types of tables are
                              shown
                            Optional, defaults to TABLE,VIEW
      --tables=<tables>     <regular-expression> is a regular expression to
                              match fully qualified table names, in the form
                              "CATALOGNAME.SCHEMANAME.TABLENAME" - for example,
                              --tables=.*\.C.*|.*\.P.* matches any tables whose
                              names start with C or P
                            Tables that do not match the pattern are not
                              displayed
                            Use with care, since --tables= actually takes
                              tables out of consideration from the perspective
                              of SchemaCrawler - to filter tables, look into
                              the grep options
                            Optional, defaults to showing all tables


** Grep for database object metadata
Shell Command:
grep

Options:
      --grep-columns=<grepcolumns>
                             <grepcolumns> is a regular expression to match
                               fully qualified column names, in the form
                               "CATALOGNAME.SCHEMANAME.TABLENAME.COLUMNNAME" -
                               for example, --grep-columns=.*\.STREET|.*\.PRICE
                               matches columns named STREET or PRICE in any
                               table
                             Optional, default is no grep
      --grep-def=<grepdef>   <grepdef> is a regular expression to match text
                               within remarks and definitions of views, stored
                               proedures and triggers, if available
                             Optional, default is no grep
      --grep-parameters=<grepparameters>
                             <grepparameters> is a regular expression to match
                               fully qualified routine parameter names, in the
                               form "CATALOGNAME.SCHEMANAME.ROUTINENAME.
                               INOUTNAME" - for example, --grep-parameters=.*\.
                               STREET|.*\.PRICE matches routine parameters
                               named STREET or PRICE in any routine
                             Optional, default is no grep
      --grep-tables=<greptables>
                             <greptables> is a regular expression to match
                               fully qualified table names, in the form
                               "CATALOGNAME.SCHEMANAME.TABLENAME" - for
                               example, --grep-tables=.*\.COUPONS|.*\.BOOKS
                               matches tables named COUPONS or BOOKS
                             Optional, default is no grep
      --[no-]invert-match    Inverts the sense of matching, and shows
                               non-matching tables and columns
                             Optional, default is false


** Filter database object metadata
Shell Command:
filter

Options:
      --children=<children> <children> is the number of generations of
                              descendants for the tables selected by grep, and
                              shown in the results
                            Optional, default is 0
      --parents=<parents>   <parents> is the number of generations of ancestors
                              for the tables selected by grep, and shown in the
                              results
                            Optional, default is 0


** Loader for table row counts
Command:
loader:countsloader

Options:
      --load-row-counts   Loads row counts for each table
                          This can be a time consuming operation
                          Optional, defaults to false
      --no-empty-tables   Includes only tables that have rows of data
                          Requires table row counts to be loaded
                          Optional, default is false
Add loader options to the `load` command in the SchemaCrawler Shell


** Loader for ER model notes, such as remarks or tags and implicit associations
Command:
loader:attributesloader

Options:
      --attributes-file=<attributes-file>
         Path to a YAML file with table and column attributes to add to the
           schema
Add loader options to the `load` command in the SchemaCrawler Shell


** Loader for implicit associations in ER Model
Command:
loader:implicitassociationsloader

Options:
      --implicit-associations
         Analyzes the schema to find implicit associations between entities,
           based on naming patterns
         This can be a time consuming operation
         Optional, defaults to false
      --infer-extension-tables
         Infers extension tables that have similarly named primary keys, and
           reports them as implicit associations
         Optional, defaults to false
Add loader options to the `load` command in the SchemaCrawler Shell


** Load database metadata into memory using a chain of catalog loaders
Shell Command:
load

Options:
  -i, --info-level=<infolevel>
         <infolevel> is one of unknown, minimum, standard, detailed, maximum
         The info level determines the amount of database metadata retrieved,
           and also determines the time taken to crawl the schema
         Optional, defaults to standard

For additional options, specific to individual catalog loaders,
run SchemaCrawler with: `-h loaders`


** Show the commonly needed detail of the schema, including details of tables,
views and routines, columns, primary keys, indexes, foreign keys, and triggers
Command:
command:schema
Applies to all commands that show schema information
Options:
      --no-info         Hide or show SchemaCrawler header and database
                          information
                        --no-info=<boolean>
                        <boolean> can be true or false
                        Optional, defaults to false
      --no-remarks      Hide or show table and column remarks
                        --no-remarks=<boolean>
                        <boolean> can be true or false
                        Optional, defaults to false
      --portable=<portable>
                        Allow for easy comparison between databases, by hiding
                          or showing foreign key names, constraint names,
                          trigger names, specific names for routines, or index
                          and primary key names, and fully-qualified table names
                        Use one of [none] Show fully-qualified names for
                          database objects, [names] Do not show fully-qualified
                          names, so that output can be diff-ed with other
                          databases of the same type, [broad] Do not show
                          fully-qualified names, and hide trigger action
                          statements, so that output can be diff-ed with
                          different types of databases
      --sort-columns    Sort columns in a table alphabetically
                        --sort-columns=<sortcolumns>
                        <sortcolumns> can be true or false
                        Optional, defaults to false
      --sort-routines   Sort routines alphabetically
                        --sort-routines=<sortroutines>
                        <sortroutines> can be true or false
                        Optional, defaults to true
      --sort-tables     Sort tables alphabetically
                        --sort-tables=<sorttables>
                        <sorttables> can be true or false
                        Optional, defaults to true
Add command options to the `execute` command in the SchemaCrawler Shell


** Test command which is not deployed with the release
Command:
command:test-command

Options:
      --test-command-parameter=<test-command-parameter>
         Parameter for test command
Add command options to the `execute` command in the SchemaCrawler Shell


** Execute a SchemaCrawler command
Shell Command:
execute

Options:
  -c, --command=<command>   SchemaCrawler command
  -F, --output-format=<outputFormatValue>
                            Format of the SchemaCrawler output
                            Supported formats are dependent on the
                              SchemaCrawler command being executed

                            For the schema output commands, <outputformat> is
                              one of:
                              text - For text output (default)
                              html - For HTML5 output

                            You can generate a database diagram using Graphviz
                            For a diagram <outputformat> is one of dot, svg, or
                              png
                            For a complete list Graphviz output formats, see
                              http://www.graphviz.org/
                            You can generate HTML output format with an
                              embedded SVG diagram with an <outputformat> of
                              htmlx
                            IMPORTANT: Graphviz needs to be installed, and
                              available on the system PATH
                            http://www.graphviz.org/
                            If Graphviz is not installed, a DOT file is
                              produced.
                            Or, use:
                              scdot - For Graphviz DOT output, for schema
                              commands only

                            Optional, defaults to the format specified by the
                              output file, otherwise, text
  -m, --title=<title>       Shows the title on the output
                            Optional, defaults to no title being shown
  -o, --output-file=<outputFile>
                            Generate output in a named file
                            <outputfile> is the path to the output file
                            Optional, defaults to the console (stdout) for text
                              output, and a random file in the current
                              directory for binary output

For additional options, specific to individual SchemaCrawler commands,
run SchemaCrawler with: `-h commands`


