This section contains information about:
- The behavior of how Datastream handles data that's being pulled from a source Oracle database
- The versions of Oracle database that Datastream supports
- An overview of how to setup a source Oracle database so that data can be streamed from it to a destination
- Known limitations for using Oracle database as a source
The source Oracle database relies upon its Oracle Logminer feature for exposing changes to the data.
- All schemas or specific schemas from a given database, as well as all tables from the schemas or specific tables, can be selected.
- All historical data is replicated.
- All data manipulation language (DML) changes, such as inserts, updates, and deletes from the specified databases and tables, are replicated.
- Datastream replicates both committed and, in some cases, uncommitted changes into the destination. In case of a rollback, the Datastream output records also include the opposite operation. For example, if there's a rolled-back
INSERToperation, then the output records will also contain a corresponding
DELETEoperation. In this case, the event will appear as a
DELETEevent with only the
Datastream supports the following versions of Oracle database:
- Oracle 11g, Version 126.96.36.199
- Oracle 12c, Version 188.8.131.52
- Oracle 12c, Version 184.108.40.206
- Oracle 18c
- Oracle 19c
- Oracle 21c
Datastream supports the following types of Oracle database:
- Self-hosted on-premises or on any cloud provider
- Amazon RDS for Oracle
- Oracle Cloud
- Oracle Exadata
- Oracle RAC
To set up a source Oracle database so that data from it can be streamed into a destination, you must configure the database to grant access, set up logging, define a retention policy, and so on.
See Configure a source Oracle database to learn how to configure this database so that Datastream can pull data from it into a destination.
Known limitations for using Oracle database as a source include:
- A table that has more than 500 million rows can't be backfilled unless the following conditions are met:
- The table has a unique index.
- This index must also be B-tree, which is a default index. The index can be composite.
- The index can't be reversed.
- The index can't contain a function-based column.
- None of the columns of the index are nullable.
- The index doesn't include a column of type
DATEthat contains negative dates as values.
- All columns of the index are included in the stream.
- Streams are limited to 10,000 tables.
- Datastream supports Oracle multi-tenant architecture (CDB/PDB), however, you can only replicate a single pluggable database in a stream.
- Oracle Autonomous Database isn't supported.
- For tables that don't have a primary key, Datastream uses the row's
ROWIDto perform a merge operation on the consumer side. Note that the
ROWIDmight not be unique. If you delete and reinsert a row with Oracle's Export/Import utility, for example, then the row's
ROWIDmight change. If you delete a row, then Oracle can reassign its
ROWIDto a new row inserted later.
- Index-organized tables (IOTs) aren't supported.
- Temporary tables aren't supported.
- For columns of type
BFILE, only the path to the file is replicated. The contents of the file aren't replicated.
- Columns of data types
XMLTYPEaren't supported, and are replaced with
- To stream columns of large object data types, such as binary large objects (
BLOB), character large objects (
CLOB) and national character large objects (
NCLOB), you need to include the
streamLargeObjectsflag in your stream configuration. If you don't include the flag, Datastream doesn't stream such columns and they're replaced with
NULLvalues in the destination. For more information, see Enable streaming of large objects for Oracle sources.
- For Oracle 11g, tables that have columns of data types
UDTaren't supported, and the entire table won't be replicated.
- Oracle Label Security (OLS) isn't replicated.
- Datastream periodically fetches the latest schema from the source as events are processed. If a schema changes, then some events from the new schema might be read while the old schema is still applied. In this case, Datastream detects the schema change, triggers a schema fetch, and reprocesses the failed events.
- Not all changes to the source schema can be detected automatically, in which case data corruption may occur. The following schema changes may cause data corruption or failure to process the events downstream:
- Dropping columns
- Adding columns to the middle of a table
- Changing the data type of a column
- Reordering columns
- Dropping tables (relevant if the same table is then recreated with new data added)
- Truncating tables
- Datastream doesn't support replicating views.
- Datastream supports materialized views. However, new views created while the stream is running aren't backfilled automatically.
SAVEPOINTstatements aren't supported and can cause data discrepancy in case of a rollback.
- Datastream supports the following character set encodings for Oracle databases:
- Generating very large log files might cause Datastream to time out, which can lead to stream failure. The recommended redo log file size is below 1GB.