SchemaCrawler 16.2.4
Database schema discovery and comprehension tool
Copyright (c) 2000-2020, 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.

System Information:
Windows 10 10.0
Oracle Corporation Java HotSpot(TM) 64-Bit Server VM 1.8.0_191-b12

Available SchemaCrawler commands:
 brief          Shows basic schema information, for tables, views and routines,
                  columns, primary keys, and foreign keys
 count          Shows counts of rows in the tables
 details        Shows maximum possible detail of the schema, including
                  privileges, and details of privileges, triggers, and check
                  constraints
 dump           Shows data from all rows in the tables
 list           Shows a list of schema objects
 quickdump      Shows data from all rows in the tables, but row order is not
                  guaranteed - this can be used with a minimum info-level for
                  speed
 schema         Shows the commonly needed detail of the schema, including
                  details of tables, views and routines, columns, primary keys,
                  indexes, foreign keys, and triggers
 test-command   Test command which is not deployed with the release
 <query_name>   Shows results of query <query_name>, as specified in the
                  configuration properties file
 <query>        Shows results of SQL <query>
                The query itself can contain the variables ${table}, ${columns}
                  and ${tabletype}, or system properties referenced as
                  ${<system-property-name>}
                Queries without any variables are executed exactly once
                Queries with variables are executed once for each table, with
                  the variables substituted


Available SchemaCrawler database plugins:
 test-db        Test Database



** 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

SchemaCrawler configuration reads a resource called schemacrawler.config.
properties from the CLASSPATH, which includes the lib/ folder. You can modify
the default settings in this file.

The order of loading configuration settings is:
1. From a CLASSPATH resource called schemacrawler.config.properties
2. Which can be overridden by settings in a configuration file (see below)
3. Which can be overridden by other command-line options

Command-line options will override configuration file options.

Options:
  -g, --config-file=<configfile>
         Read SchemaCrawler configuration properties from <configfile>
         <configfile> is the full path to the configuration file
         Optional, uses the default schemacrawler.config.properties file in the
           current directory, or in-built default options


** Connect to the database
Shell Command:
connect

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

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
      --user=<user>       Database user name

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


** 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
                               "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 "SCHEMANAME.ROUTINENAME.INOUTNAME" - for
                               example, --grep-parameters=.*\.STREET|.*\.PRICE
                               matches routine parameters named STREET or PRICE
                               in any routine
                             Optional, default is no grep
      --[no-]invert-match    Inverts the sense of matching, and shows
                               non-matching tables and columns
                             Optional, default is false
      --[no-]only-matching   Shows only matching tables, and does not show
                               foreign keys that reference other non-matching
                               tables
                             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
      --[no-]empty-tables   Includes only tables that have rows of data
                            Will work only if infolevel is maximum
                            Optional, default is false
      --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


** Load database metadata into memory
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



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

Options:
      --test-command-parameter=<test-command-parameter>
         Parameter for test command


** Show information in output
Shell Command:
show

Options:
      --[no-]info      Hide or show 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
      --[no-]portable-names
                       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
                       --portable-names=<boolean>
                       <boolean> can be true or false
                       Optional, defaults to false
      --[no-]weak-associations
                       Hide or show inferred relationships between tables,
                         based on common table and column naming conventions
                       --weak-associations=<boolean>
                       <boolean> can be true or false
                       Optional, defaults to false


** Sort database objects in output
Shell Command:
sort

Options:
      --[no-]sort-columns    Sort columns in a table alphabetically
                             --sort-columns=<sortcolumns>
                             <sortcolumns> can be true or false
                             Optional, defaults to false
      --[no-]sort-parameters Sort parameters in a routine alphabetically
                             --sort-parameters=<sortparameters>
                             <sortparameters> can be true or false
                             Optional, defaults to false
      --[no-]sort-routines   Sort routines alphabetically
                             --sort-routines=<sortroutines>
                             <sortroutines> can be true or false
                             Optional, defaults to true
      --[no-]sort-tables     Sort tables alphabetically
                             --sort-tables=<sorttables>
                             <sorttables> can be true or false
                             Optional, defaults to true


** 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, eps,
                              gif, jpg, 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 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


