3 Running Repository Creation Utility from the Command Line

This chapter describes how to run RCU from the command line.

The command-line interface (CLI) is necessary for integration with both the Oracle Fusion Middleware installer and Enterprise Manager during application deployment. Additionally, you can use the CLI in cases where Xserver is not configured or if you are using a telnet terminal that does not have proper display capabilities.

This chapter contains the following topics:

3.1 Command Line Syntax and Parameters

The syntax for the RCU command line interface is:

rcu mode operation {parameters}

There are two modes (-silent and -interactive) and seven operations (-generateResponseFile, -responseFile, -createRepository, -generateScript, -dataLoad, -dropRepository, and -listComponents). So, the command can be written out as follows:

rcu [-silent | -interactive] [-generateResponseFile | -responseFile | -createRepository | -generateScript | -dataLoad | -dropRepository | -listComponents] 
{parameters}

The following topics describe each of the modes, operations, and parameters:

3.1.1 RCU Modes Available from the Command Line

This topic lists and describes the RCU modes available from the command line.

Table 3-1 RCU Modes Available from the Command Line

Command Description

Command	Description
`-silent`	Run RCU with minimal or no interaction from the command line. For more information, see Using the -silent Command.
`-interactive`	Run the RCU graphical interface. This is the default if neither `-silent` nor `-interactive` is specified. This command (whether specified or not) allows you to pre-populate certain screens with information as specified from the response file or from the command line. You can pre-populate the Create Repository and Database Connection Details screens. For more information, see Using the -interactive Command.

-silent

Run RCU with minimal or no interaction from the command line.

For more information, see Using the -silent Command.

-interactive

Run the RCU graphical interface. This is the default if neither -silent nor -interactive is specified.

This command (whether specified or not) allows you to pre-populate certain screens with information as specified from the response file or from the command line. You can pre-populate the Create Repository and Database Connection Details screens.

For more information, see Using the -interactive Command.

3.1.2 RCU Operations Available from the Command Line

This topic lists and describes the RCU operations available from the command line.

Table 3-2 RCU Operations Available from the Command Line

Command	Description
`-generateResponseFile`	Run RCU with `-silent` to generate a RCU response file that contains all valid RCU command line parameters. For more information, see Creating a RCU Response File from the Command Line
`-responseFile`	Run RCU with either `-silent` or `-interactive` to perform a RCU operation using a response file. For more information, see Performing RCU Operations Using a Response File
`-createRepository`	Run RCU with either `-silent` or `-interactive` to create a repository. For more information, see Creating a Repository from the Command Line.
`-generateScript`	Run RCU with either `-silent` or `-interactive` to generate a script for system load. For more information, see Generating a System Load Script From the Command Line.
`-dataLoad`	Run RCU with either `-silent` or `-interactive` to load data into the repository. For more information, see Loading Data Into the Repository From the Command Line.
`-dropRepository`	Run RCU with either `-silent` or `-interactive` to drop a repository. For more information, see Dropping a Repository from the Command Line.
`-listComponents`	Run RCU with `-silent` to generate a list of components for a given Oracle home. For more information, see Generating a List of Components in an Oracle Home from the Command Line

3.1.3 RCU Command Line Parameters

This topic lists and describes the various command line parameters. These parameters can be passed to RCU as input by directly entering the parameters on the command line or by using a response file.

Table 3-3 RCU Command Line Parameters and Descriptions

Parameter	Required?	Valid for Which Operation?	Description
`-compInfoXMLLocation`	No	`-createRepository` `-generateScript` `-dataLoad` `-dropRepository`	Full path to the location of the `ComponentInfo.xml` file. The default location is `ORACLE_HOME/oracle_common/rcu/config` (on UNIX operating systems) or `ORACLE_HOME\oracle_common\rcu\config` (on Windows operating systems).
`-storageXMLLocation`	No	`-createRepository` `-generateScript` `-dataLoad` `-dropRepository`	Full path to the location of the `StorageInfo.xml` file. The default location is `ORACLE_HOME/oracle_common/rcu/config` (on UNIX operating systems) or `ORACLE_HOME\oracle_common\rcu\config` (on Windows operating systems).
`-databaseType`	No	`-createRepository` `-generateScript` `-dataLoad` `-dropRepository`	Type of database to which you are connecting. If you are performing the system load and product load concurrently as a user with full DBA privileges, the valid options are `ORACLE`, `SQLSERVER`, `IBMBD2`, `MYSQL`, or `EBR`. If you do not have permissions to perform system load and product load concurrently and need to generate a script, you can only use the `ORACLE` and `EBR` database types. For more information about system load and product load, see Understanding System Load and Product Load.
`-connectString`	Yes	`-createRepository` `-generateScript` `-dataLoad` `-dropRepository`	Credentials for connecting to your database. For Oracle or EBR-enabled databases, use the following format: host:port:sid For all other database types, use: server_name/host:port:database_name
`-edition`	No	`-createRepository` `-generateScript` `-dataLoad` `-dropRepository`	Edition name. This is only valid if you specify `databaseType=EBR`.
`-dbUser`	Yes	`-createRepository` `-generateScript` `-dataLoad` `-dropRepository` `-generateResponseFile`	Database user name (for example, the default user name on Oracle databases is `SYS`). This parameter is required if the `—createWallet` parameter is provided during the `-generateResponseFile` operation. RCU uses the database user name as the key/alias to store the database user password when generating wallet. If the `—createWallet` parameter is not provided, the database user name is optional.
`-dbRole`	No	`-createRepository` `-generateScript` `-dataLoad` `-dropRepository`	Database user role (for example, `SYSDBA` for the `SYS` user on Oracle databases).
`-unicodeSupport`	No	`-createRepository` -`dropRepository`	Specify `Yes` or `No` for unicode support. Default is `Yes`. This is only valid if you specify `databaseType=SQLSERVER`.
`-skipCleanupOnFailure`	No	`-createRepository` `-generateScript` `-dataLoad`	Whether or not you want to skip the schema cleanup if schema creation fails. Valid values are `Yes` or `No`. The default is `No`.
`-scriptLocation`	No	`-generateScript`	Specify the location to save the generated script for system load repository.
`-useSamePasswordForAllSchemaUsers`	No	`-createRepository` `-dataLoad` `-generateResponseFile`	Whether or not you want to use the same password for all schemas. Valid values are `true` or `false`. The default is `false`.
`-selectDependentsForComponents`	No	`-createRepository` `-generateScript` `-dataLoad` `-dropRepository` `-generateResponseFile`	Whether or not you want to have RCU automatically select dependent schemas for your components. Valid values are `true` or `false`. The default is `false`.
`-honorOMF`	No	`-createRepository` `-generateScript`	If value is set to `true`, RCU creates datafiles using Oracle-Managed Files (OMF) naming format. Valid values are `true` or `false`. The default is `false`.
`-encryptTablespace`	No	`-createRepository` `-generateScript`	Whether or not you want to encrypt all new tablespaces that will be created by RCU. This option is valid only if you have TDE (Transparent Data Encryption) enabled in the database (Oracle or Oracle EBR) when you start RCU. TDE tablespace encryption allows you to encrypt sensitive data stored in tablespaces. Valid values are `true` or `false`. The default is `false`. If value is set to `true`, all new tablespaces created by RCU will be encrypted only if TDE is enabled in the database. Tablespaces that were created before RCU was launched cannot be encrypted using this option.
`-skipTablespaceDrop`	No	`-dropRepository`	This parameter allows you to skip dropping tablespaces during the `-dropRepository` operation. Valid values are `Yes` or `No`. Specify `Yes` to skip tablespace drop. The default is `No`.
`-variables`	No	`-createRepository` `-generateScript` `-dataLoad` `-dropRepository`	Comma separated variables in the format variablename`=`value. See RCU Environment Variables for a list of RCU environment variables.
`-schemaPrefix`	No	`-createRepository` `-generateScript` `-dataLoad` `-dropRepository` `-generateResponseFile`	Prefix for your schemas. For more information about schema prefixes, refer to Planning Your Schema Creation and Select Components (for Create Operation). This parameter is required if the `—createWallet` parameter is provided during the `-generateResponseFile` operation. RCU uses the prefixed schema name as the key/alias to store schema passwords when generating wallet. If the `—createWallet` parameter is not provided, the schema prefix is optional.
`-component`	Yes	`-createRepository` `-generateScript` `-dataLoad` `-dropRepository`	ID of the component(s) you want to add or drop. To specify a single component, use the format: -component component_ID To specify multiple components, use the format: -component component_ID -component component_ID For a list of valid component (schema) IDs, refer to Understanding Repository Creation Utility Schemas, IDs, and Tablespaces. Multiple components are sometimes necessary because of dependencies; for example, you cannot create the Oracle Platform Security Services (`OPSS`) schema if the Audit Services (`IAU`) schema does not already exist. In this case, you must specify both schemas: -component OPSS -component IAU
`-tablespace`	No	`-createRepository` `-generateScript`	Tablespace name of the component. This tablespace must exist in the database if you are using this option.
`-tempTablespace`	No	`-createRepository` `-generateScript`	TEMP tablespace name of the component. This tablespace must exist in the database if you are using this option.
`-createWallet`	No	`-generateResponseFile`	Provide this parameter if you want to create a wallet file to securely store your RCU passwords, such as the database user password, schema passwords, and custom variable passwords. RCU accepts password credentials stored in an Oracle Wallet. That is, you can use the generated wallet later in silent situations to provide your passwords to RCU without having to directly enter passwords on the command line. The wallet will be generated in the same directory as the response file.
`-walletDir`	No	`-createRepository` `-generateScript` `-dataLoad` `-dropRepository`	Absolute path of wallet directory where your RCU passwords used for creating or dropping schemas are stored. If you choose to use a wallet to provide passwords to RCU, RCU will retrieve the required passwords from the specified directory. This option is valid for silent mode only. The wallet must already exist and contain the required passwords if you are using this option. If the wallet does not contain the required passwords, RCU will prompt you for the missing passwords on the command line. This directory should contain a valid `cwallet.sso` file. RCU supports auto-login wallets only (password is not needed to open wallet).
`-responseFileDir`	No	`-generateResponseFile`	Absolute path of RCU response file directory. If specified, RCU generates a response file named `rcuResponseFile.properties` in the given directory. If not specified, RCU generates a response file in the `$HOME/.rcu` directory by default.
`-ComponentList`	No	`-generateResponseFile`	Comma-separated list of component IDs for the components in the Oracle home that you want to add to the response file. To generate a list of valid component IDs for a specific Oracle home, see Generating a List of Components in an Oracle Home from the Command Line. If not specified, all valid components in the Oracle home will be added to the response file by default.

3.2 Using the -silent Command

Specify -silent if you want to run RCU with minimal interaction once you have entered the command.

You must specify all mandatory command line parameters in the command. For example:

rcu -silent -createRepository -connectString database_connect_string -dbUser -database_user -component component

In this scenario, RCU will prompt you for the database and component schema passwords from the command line. If you specify multiple components, you will be prompted for the passwords in the order in which the components are specified.

Instead of directly entering all the RCU parameters on the command line, you can provide the location and name of a file containing certain input values. This file (called a response file) allows you to provide values for all valid RCU command-line parameters to RCU via a text file. When you run RCU, all values will be read from the response file to create or drop schemas. For more information, see Using Response Files.

If you want to avoid all interaction from the command line, you can create a text file containing all the necessary passwords (one password per line) and then use the -f option to pass this password file to RCU. For example, if you create a file called passwordfile.txt, you can use the command below:

rcu -silent -createRepository -connectString database_connect_string -dbUser -database_user -component component1_name -component 
component2_name -f < passwordfile.txt

The passwordfile.txt file would contain, in order:

database_password
component1_schema_password
component2_schema_password

It is important to make sure that the passwords in the file are specified in the same order as the components on the command line.

Once the installation is complete the password file must be removed. The passwords are maintained in cleartext format and therefore present a security risk if the password file is left in place after installation.

Instead of using a plain text password file, you can create an Oracle Wallet file containing all the necessary passwords and then use the -walletDir parameter to pass this file to RCU. For more information, see Using a Wallet to Store Passwords.

3.2.1 Using a Wallet to Store Passwords

If you are running RCU from the command line, password credentials (for example, schema passwords) can be stored and provided to RCU in an Oracle Wallet file.

When you run RCU from the command line, RCU prompts you to enter values for any required passwords by default. To avoid entering passwords on the command line, you can create a wallet file to securely store and encrypt any necessary passwords. You can then pass the wallet to RCU by providing the wallet location with the walletDir parameter.

Creating a Wallet Using RCU

A wallet for providing RCU passwords can be generated by RCU as part of response file creation:

To create a wallet using the RCU graphical interface, see Creating a RCU Response File from the Graphical Interface.
To create a wallet using the RCU command line interface, see Creating a RCU Response File from the Command Line.

Once the wallet is created, this file can be reused to store and provide passwords for multiple sessions.

Note that RCU only supports auto-login wallets (no password is needed to open a wallet). Password-protected wallets are not supported.

When the wallet is generated by RCU, RCU uses the prefixed schema name as the key/alias for storing schema passwords, which allows you to more easily reuse the same wallet for multiple sessions. For database user password, the alias is the database user name (for example, SYS). If the same password is used for all the schemas, then RCU uses the alias prefix_COMMON_SCHEMA_PASSWORD to save the password in the wallet.

Example 3-1 Using the —walletDir Parameter

After the wallet is created and contains the necessary passwords, use the —walletDir parameter to pass this file to RCU so that you do not have to directly enter your passwords on the command line. Alternatively, the wallet location can be provided to RCU via a response file.

For example:

./rcu -silent -createRepository -connectString examplehost.exampledomain.com:1521:example_sid -dbUser sys -dbRole sysdba 
-schemaPrefix DEV -component MDS -component STB -walletDir /home/exampleuser/wallet

When you pass the wallet to RCU, RCU expects all the necessary passwords to be in the wallet, which include:

Database user password
Schema passwords
Custom Variable passwords (for Oracle Data Integrator)

In this example, the wallet should contain passwords for the database user (sys), the Metadata Services (MDS) schema, and the Service Table (STB) schema. If a wallet does not contain all the necessary passwords, you will be prompted to enter the missing passwords on the command line.

3.3 Using the -interactive Command

Specify -interactive to run the RCU graphical interface.

This is the default if neither -silent nor -interactive is specified.

You can specify information from the command line that would be populated in the graphical interface to expedite your RCU operation. For example, if you run RCU with the following command:

./rcu

The Database Connection Details page contains blank fields, as shown below:

Description of the RCU Database Connection Details Screen

But if you run RCU with a few parameters from the command line:

./rcu -interactive -createRepository -connectString examplehost.exampledomain.com:1521:example_sid -dbUser SYS -component MDS

The Database Connection Details page contains the information supplied from the command line:

Description of the RCU Database Connection Details Screen

When you run the RCU graphical interface, you can provide the location and name of a file (called a response file) containing certain input values (for example, database connection details). These are the values that are asked for during a typical session using the graphical interface. The values you enter in the response file can be used to populate certain RCU screens. For more information, see Using Response Files.

3.4 Using Response Files

Before running RCU, you can provide information that is required to perform a specific RCU operation in a response file. For example, you can provide your database connection details, a list of components to be added or dropped, and the schema prefix to RCU via a response file. A response file can be used to automate a RCU session.

When you run RCU using a response file, RCU reads the information provided in the response file to complete the RCU operation.

For more information, see the following topics:

3.4.1 Understanding Response Files

A response file is a properties file in which all RCU command-line parameters can be provided as input to RCU to perform a RCU operation.

Rather than directly entering the RCU Command Line Parameters on the command line, you can provide values for these parameters to RCU via a text file. This file can be generated from the RCU graphical interface (using the values you provide in the RCU screens) or from the command line. After you create the response file, the parameters can be modified in a text editor or be used exactly as-is to perform a RCU operation at a later time.

If you choose to run RCU from the command line with a response file, the values you specify in the response file are the values for the RCU parameters that you would normally provide on the command line during a typical silent RCU session. If you choose to run the RCU graphical interface with a response file, the values you specify in the response file are used to pre-populate the fields on certain screens.

3.4.2 Creating a RCU Response File from the Graphical Interface

The Save Response File option on the Summary (for Create Operation) or the Summary (for Drop Operation) screen saves the information you provide in the RCU screens to a response file.

After you click the Save Response File option, you will be prompted to specify a location for where you want to create this file. By default, RCU saves the response file in the $HOME/.rcu directory.

Because the response file needs to contain password information, RCU provides the Save Passwords in Wallet option to securely store and encrypt any passwords you provide on the RCU screens in a wallet. You can use the wallet later in silent situations to provide the necessary passwords to RCU so that you do not have to directly enter your passwords on the command line. When you run RCU from the command line, the wallet location can be provided to RCU on the command line or using a response file. If a wallet directory is not provided to RCU, you will be prompted for the required passwords.

3.4.3 Creating a RCU Response File from the Command Line

This topic shows the full syntax for the RCU command line interface to generate a RCU response file.

rcu -silent -generateResponseFile
  [-responseFileDir absolute_path_of_response_file_directory]
  [-schemaPrefix schema_prefix]  
  [-componentList list_of_component_IDs]
  [-createWallet]
  [-useSamePasswordForAllSchemaUsers [true|false]]
  [-selectDependentsForComponents [true|false]]
  [-dbUser database_username]

If the —createWallet parameter is provided, then values for —dbUser and —schemaPrefix are required. Otherwise, the —dbUser and —schemaPrefix parameters are optional. RCU uses the prefixed schema name and the database user name as the key/alias to store schema passwords and the database user password in the wallet, respectively.

If you provide —createWallet and —useSamePasswordForAllSchemaUsers true on the command line, then all schema passwords will be set to the same value in wallet.

If the —createWallet parameter is provided, RCU will prompt you to enter a value for each password that will be stored in the wallet.

Below is a sample command to generate a RCU response file on a UNIX operating system:

./rcu -silent -generateResponseFile -componentList OPSS,IAU -schemaPrefix DEV -createWallet 
-responseFileDir /home/exampleuser/rcu -useSamePasswordForAllSchemaUsers true 
-selectDependentsForComponents true -dbUser sys

In this example, a response file and wallet are created in the /home/exampleuser/rcu directory, and the information provided on the command line (such as the list of components) is added to the response file.

3.4.4 Performing RCU Operations Using a Response File

This topic shows the full syntax for the RCU command line interface to perform a RCU operation using a response file. You use a response file to provide input to RCU to automate a RCU operation from the command line or from the graphical interface.

If you choose to run the graphical interface with a response file, RCU will pre-populate certain RCU screens (such as the Database Connection Details screen) based on the input values you provide in the response file. If you choose to run RCU from the command line, you can use a response file to provide values for all valid RCU parameters rather than directly entering these parameters on the command line.

The full syntax for the RCU command line interface to perform a RCU operation with a response file is shown below:

rcu [-silent|-interactive] -responseFile absolute_path_of_response_file

Below is a sample command to automate a silent RCU session using a response file on a UNIX operating system:

./rcu -silent -responseFile /home/exampleuser/rcu/rcuResponseFile.properties

Note:

If you provide a value for a parameter on the command line and in the response file, RCU will use the value provided on the command line.
Before running RCU, ensure that you have provided the required information in the response file. If some of the mandatory properties in the response file are missing values when you run RCU, RCU will notify you and exit.
For connecting to certain databases (for example, SQL Server), the dbRole parameter is not normally required when you run RCU. However, when a RCU response file is generated, the dbRole parameter is marked as required in the response file by default. As a result, if you are using a response file, the dbRole field must not be left blank even if the database role is not required to connect to a database like SQL Server.

3.5 Creating a Repository from the Command Line

This topic shows the full syntax for the RCU command line interface to create a repository.

rcu [-silent | -interactive] -createRepository
        [-compInfoXMLLocation ComponentInfo.xml_file_location]
        [-storageXMLLocation Storage.xml_file_location]
        [-databaseType [ORACLE|EBR]]
         -connectString database_connect_string
        [-edition edition_name]
         -dbUser database_username
        [-dbRole database_user_role]
        [-unicodeSupport [Yes|No]]
         [-skipCleanupOnFailure [true|false]]
         [-useSamePasswordForAllSchemaUsers [true|false]]
         [-selectDependentsForComponents [true|false]]
        [-honorOMF [true|false]]
        [-encryptTablespace [true|false]]
         [-variables variablename=value]
         [-schemaPrefix schema_prefix]
         -component component_ID
         [-tablespace component_tablespace_name]
         [-tempTablespace component_temp_tablespace_name]
        [-walletDir absolute_path_of_wallet_directory]

In order to work properly, make sure that the parameters are specified in the same order that they are listed. For example, do not specify the -compInfoXMLLocation parameter after the -component parameter.

When specifying the -component, you must use the correct component IDs, which are listed in Understanding Repository Creation Utility Schemas, IDs, and Tablespaces.

Before you create any schemas, you must be aware of and specify all dependencies for the component you are loading. For example, the SOAINFRA schema depends on the MDS and ORASDPM schemas; if you try to load the SOAINFRA schema without specifying both the MDS and ORASDPM schemas, or if the MDS and ORASDPM schemas do not already exist in the database, RCU will stop before any loading takes place.

Below is a sample command to create the OPSS schema on a UNIX operating system:

./rcu -silent -createRepository -databaseType ORACLE -connectString examplehost.exampledomain.com:1521:exampleSID -dbUser sys 
-dbRole sysdba -schemaPrefix TEST -component OPSS -component MDS

3.6 Generating a System Load Script From the Command Line

This topic shows the full syntax for the RCU command line interface to generate a system load script.

rcu [-silent | -interactive] -generateScript
         [-compInfoXMLLocation ComponentInfo.xml_file_location]
         [-storageXMLLocation Storage.xml_file_location]
         [-databaseType [ORACLE|EBR]]
         -connectString database_connect_string
         [-edition edition_name]
         -dbUser database_username
        [-dbRole database_user_role]
        [-skipCleanupOnFailure [Yes|No]]
        [-scriptLocation script_location]
         [-selectDependentsForComponents [true|false]]
         [-honorOMF [true|false]]
        [-encryptTablespace [true|false]]
         [-variables variablename=value]
         [-schemaPrefix schema_prefix]
         -component component_ID
         [-tablespace component_tablespace_name]
         [-tempTablespace component_temp_tablespace_name]
         [-walletDir absolute_path_of_wallet_directory]

When specifying the -component, you must use the correct component IDs, which are listed in Understanding Repository Creation Utility Schemas, IDs, and Tablespaces.

Before you create a script, you must be aware of and specify all component dependencies. For example, the SOAINFRA schema depends on the MDS and ORASDPM schemas; if you specify the SOAINFRA schema without specifying both the MDS and ORASDPM schemas, or if the MDS and ORASDPM schemas do not already exist in the database, RCU will stop before competing the operation.

Below is a sample command to create a system load script on a UNIX operating system:

./rcu -silent -generateScript -databaseType ORACLE -connectString examplehost.exampledomain.com:1521:exampleSID -dbUser sys 
-dbRole sysdba -scriptLocation /tmp/RCUdate_timestamp_random_number/logs/ -schemaPrefix TEST 
-component OPSS -component MDS

3.7 Loading Data Into the Repository From the Command Line

This topic shows the full syntax for the RCU command line interface to load data into a repository.

rcu [-silent | -interactive] -dataLoad
         [-compInfoXMLLocation ComponentInfo.xml_file_location]
         [-storageXMLLocation Storage.xml_file_location]
         [-databaseType [ORACLE|EBR]]
         -connectString database_connect_string
         [-edition edition_name]
          -dbUser database_username
         [-dbRole database_user_role]
         [-skipCleanupOnFailure [Yes|No]]
         [-useSamePasswordForAllSchemaUsers [true|false]]
         [-selectDependentsForComponents [true|false]]
         [-variables variablename=value]
        [-schemaPrefix schema_prefix]
         -component component_ID
         [-walletDir absolute_path_of_wallet_directory]

Below is a sample command to perform a data load on a UNIX operating system:

./rcu -silent -dataLoad -databaseType ORACLE -connectString examplehost.exampledomain.com:1521:exampleSID -dbUser sys -dbRole 
sysdba -schemaPrefix TEST -component OPSS -component MDS

3.8 Dropping a Repository from the Command Line

This topic shows the full syntax for the RCU command line interface to drop a repository.

rcu [-silent | -interactive] -dropRepository
         [-compInfoXMLLocation ComponentInfo.xml_file_location]
         [-storageXMLLocation Storage.xml_file_location]
         [-databaseType [ORACLE|EBR]]
         -connectString database_connect_string
         [-edition edition_name]
          -dbUser database_username
         [-dbRole database_user_role]
         [-unicodeSupport [Yes|No]]
         [-selectDependentsForComponents [true|false]]
         [-skipTablespaceDrop [Yes|No]]
         [-variables variablename=value]
        [-schemaPrefix schema prefix]
         -component component_ID
         [-walletDir absolute_path_of_wallet_directory]

You must also be aware of schema dependencies when dropping schemas (see Understanding Repository Creation Utility Schemas, IDs, and Tablespaces). For example, several schemas require the MDS schema to be present; if you choose to drop the MDS schema, then all the schemas that require the MDS schema will stop working.

Below is a sample command to drop the OPSS schema on a UNIX operating system:

./rcu -silent -dropRepository -databaseType ORACLE -connectString examplehost.exampledomain.com:1521:exampleSID -dbUser sys -dbRole 
sysdba -schemaPrefix TEST -component OPSS

3.9 Generating a List of Components in an Oracle Home from the Command Line

This topic shows the full syntax for the RCU command line interface to generate a list of valid components that are available in a given Oracle home.

rcu -silent -listComponents

This command displays the name, component ID, and the supported database types for each component that is available in the Oracle home in which RCU was started.

The Component ID and database type are the values you must specify with the -component and —databaseType parameters, respectively, when you run RCU from the command line.

3.10 RCU Environment Variables

Table 3-4 shows the variables picked up by RCU from the environment. If the environment variable is not set, then RCU uses the default value.

Table 3-4 RCU Environment Variables

Variable	Default	Description
`RCU_LOG_LOCATION`	`/tmp` (UNIX operating systems) `C:\Users\user_name\AppData\Local\Temp` (Windows operating systems)	Location of the RCU log file.
`RCU_TIMESTAMP_LOG_DIR`	`true`	Determines whether or not a directory with the format `logdir.yyyy-dd_hh-mm` is created for the RCU log file. Set this variable to `true` or `false`.
`RCU_LOG_NAME`	`rcu.log`	Name of the RCU log file.
`RCU_LOG_LEVEL`	`ERROR`	Determines the RCU log level. Set this variable to one of `SEVERE`, `ERROR`, `NOTIFICATION`, or `TRACE`.
`RCU_JAVA_OPTIONS`	N/A	Set this variable to any Java Virtual Machine (JVM) argument. For example: setenv RCU_JAVA_OPTIONS -Djava.io.tmpdir=/scratch/mytmpDir