Skip to main content
Oracle Help Center

Sign Out

Sign In

  • Table of Contents
  • Search
  • Print
  • Download
  1. Database
  2. Oracle
  3. Oracle Database
  4. Release 19

Database SecureFiles and Large Objects Developer's Guide

  • Table of Contents
  • Search
  • Print
  • Download

Table of Contents

Expand AllCollapse All
  • Title and Copyright Information
  • Preface
    • Audience
    • Documentation Accessibility
    • Related Documents
    • Conventions
  • Changes in Oracle Database
    • New Features
    • Deprecated Features
    • Desupported Features
  • Part I Getting Started
    • 1 Introduction to Large Objects and SecureFiles
      • What Are Large Objects?
      • Why Use Large Objects?
        • Data Types that Use Large Objects
        • LOBs Used for Semistructured Data
        • LOBs Used for Unstructured Data
      • Why Not Use LONGs?
      • Different Kinds of LOBs
        • Internal LOBs
        • External LOBs and the BFILE Data Type
      • LOB Locators
      • Database Semantics for Internal and External LOBs
      • Large Object Data Types
      • About Object Data Types and LOBs
      • Storage and Creation of Other Data Types with LOBs
        • VARRAYs Stored as LOBs
      • BasicFiles and SecureFiles LOBs
      • Database File System (DBFS)
    • 2 Working with LOBs
      • LOB Column States
      • Locking a Row Containing a LOB
      • LOB Open and Close Operations
      • LOB Locator and LOB Value
        • Using the Data Interface for LOBs
        • Use the LOB Locator to Access and Modify LOB Values
      • LOB Locators and BFILE Locators
        • Table for LOB Examples: The PM Schema print_media Table
        • LOB Column Initialization
          • Initializing a Persistent LOB Column
          • Initializing BFILEs
      • LOB Access
        • Accessing a LOB Using SQL
        • Accessing a LOB Using the Data Interface
        • Accessing a LOB Using the Locator Interface
      • LOB Rules and Restrictions
        • Rules for LOB Columns
        • Restrictions for LOB Operations
    • 3 Using Oracle LOB Storage
      • LOB Storage
        • BasicFiles LOB Storage
        • SecureFiles LOB Storage
          • About Advanced LOB Compression
          • About Advanced LOB Deduplication
          • About SecureFiles Encryption
      • CREATE TABLE with LOB Storage
        • CREATE TABLE LOB Storage Parameters
        • CREATE TABLE and SecureFiles LOB Features
          • CREATE TABLE with Advanced LOB Compression
            • Usage Notes for Advanced LOB Compression
            • Examples of CREATE TABLE and Advanced LOB Compression
          • CREATE TABLE with Advanced LOB Deduplication
            • Usage Notes for Advanced LOB Deduplication
            • Examples of CREATE TABLE and Advanced LOB Deduplication
          • CREATE TABLE with SecureFiles Encryption
            • Usage Notes for SecureFiles Encryption
            • Examples of CREATE TABLE and SecureFiles Encryption
      • ALTER TABLE with LOB Storage
        • About ALTER TABLE and LOB Storage
        • BNF for the ALTER TABLE Statement
        • ALTER TABLE LOB Storage Parameters
        • ALTER TABLE SecureFiles LOB Features
          • ALTER TABLE with Advanced LOB Compression
            • Usage Notes for Advanced LOB Compression
            • Examples of ALTER TABLE and Advanced LOB Compression
          • ALTER TABLE with Advanced LOB Deduplication
            • Usage Notes for Advanced LOB Deduplication
            • Examples of ALTER TABLE and Advanced LOB Deduplication
          • ALTER TABLE with SecureFiles Encryption
            • Usage Notes for SecureFiles Encryption
            • Examples of ALTER TABLE and SecureFiles Encryption
      • Initialization, Compatibility, and Upgrading
        • Compatibility and Upgrading
        • Initialization Parameter for SecureFiles LOBs
      • Migrating Columns from BasicFiles LOBs to SecureFiles LOBs
        • Preventing Generation of REDO Data When Migrating to SecureFiles LOBs
        • Online Redefinition for BasicFiles LOBs
        • Online Redefinition Example for Migrating Tables with BasicFiles LOBs
        • Redefining a SecureFiles LOB in Parallel
      • PL/SQL Packages for LOBs and DBFS
        • The DBMS_LOB Package Used with SecureFiles LOBs and DBFS
        • DBMS_LOB Constants Used with SecureFiles LOBs and DBFS
        • DBMS_LOB Subprograms Used with SecureFiles LOBs and DBFS
        • DBMS_SPACE Package
          • DBMS_SPACE.SPACE_USAGE()
    • 4 Operations Specific to Persistent and Temporary LOBs
      • Persistent LOB Operations
        • Inserting a LOB into a Table
        • Selecting a LOB from a Table
      • Temporary LOB Operations
        • Creating and Freeing a Temporary LOB
      • Creating Persistent and Temporary LOBs in PL/SQL
      • Freeing Temporary LOBs in OCI
    • 5 Distributed LOBs
      • Working with Remote LOBs
        • Working with Remote LOB Columns
          • Create table as select or insert as select
          • Functions on remote LOBs returning scalars
          • Data Interface for remote LOBs
        • Working with Remote Locator
          • Using Local and Remote locators as bind with queries and DML on remote tables
          • Restrictions when using remote LOB locators
      • SQL Semantics with LOBs in Remote Tables
        • Built-in Functions for Remote LOBs and BFILEs
        • Passing Remote Locator to Built in SQL Functions
      • Working with Remote LOBs in PL/SQL
        • PL/SQL Functions for Remote LOBs and BFILEs
          • Restrictions on Remote User-Defined Functions
          • Remote Functions in PL/SQL, OCI, and JDBC
        • Using Remote Locator in PL/SQL
        • Using Remote Locators with DBMS_LOB
          • Restrictions on Using Remote Locators with DBMS_LOB
      • Using Remote Locators with OCILOB API
    • 6 DDL and DML Statements with LOBs
      • Creating a Table Containing One or More LOB Columns
      • Creating a Nested Table Containing a LOB
      • Inserting a Row by Selecting a LOB From Another Table
      • Inserting a LOB Value Into a Table
      • Inserting a Row by Initializing a LOB Locator Bind Variable
        • About Inserting Rows with LOB Locator Bind Variables
        • PL/SQL: Inserting a Row by Initializing a LOB Locator Bind Variable
        • C (OCI): Inserting a Row by Initializing a LOB Locator Bind Variable
        • COBOL (Pro*COBOL): Inserting a Row by Initializing a LOB Locator Bind Variable
        • C/C++ (Pro*C/C++): Inserting a Row by Initializing a LOB Locator Bind Variable
        • Java (JDBC): Inserting a Row by Initializing a LOB Locator Bind Variable
      • Updating a LOB with EMPTY_CLOB() or EMPTY_BLOB()
      • Updating a Row by Selecting a LOB From Another Table
  • Part II Value Semantics LOBs
    • 7 SQL Semantics and LOBs
      • About Using LOBs in SQL
      • SQL Functions and Operators Supported for Use with LOBs
        • About SQL Functions and Operators for LOBs
        • Implicit Conversion of CLOB to CHAR Types
        • CLOBs and NCLOBs Do Not Follow Session Collation Settings
        • UNICODE Support
        • Codepoint Semantics
        • Return Values for SQL Semantics on LOBs
        • LENGTH Return Value for LOBs
      • Implicit Conversion of LOB Data Types in SQL
        • Implicit Conversion Between CLOB and NCLOB Data Types in SQL
      • Unsupported Use of LOBs in SQL
      • VARCHAR2 and RAW Semantics for LOBs
        • About VARCHAR2 and RAW Semantics for LOBs
        • LOBs Returned from SQL Functions
        • IS NULL and IS NOT NULL Usage with VARCHAR2s and CLOBs
        • WHERE Clause Usage with LOBs
      • Built-in Functions for Remote LOBs and BFILEs
    • 8 PL/SQL Semantics for LOBs
      • PL/SQL Statements and Variables
      • Implicit Conversions Between CLOB and VARCHAR2
      • Explicit Conversion Functions
        • VARCHAR2 and CLOB in PL/SQL Built-In Functions
      • PL/SQL Functions for Remote LOBs and BFILEs
    • 9 Data Interface for Persistent LOBs
      • Overview of the Data Interface for Persistent LOBs
      • Benefits of Using the Data Interface for Persistent LOBs
      • Using the Data Interface for Persistent LOBs in PL/SQL
        • About Using the Data Interface for Persistent LOBs in PL/SQL
        • Guidelines for Accessing LOB Columns Using the Data Interface in SQL and PL/SQL
        • Implicit Assignment and Parameter Passing
        • Passing CLOBs to SQL and PL/SQL Built-In Functions
        • Explicit Conversion Functions
        • Calling PL/SQL and C Procedures from SQL
        • Calling PL/SQL and C Procedures from PL/SQL
        • Binds of All Sizes in INSERT and UPDATE Operations
        • 4000 Byte Limit on Results of a SQL Operator
        • Example of 4000 Byte Result Limit of a SQL Operator
        • Restrictions on Binds of More Than 4000 Bytes
        • Parallel DML (PDML) Support for LOBs
        • Example: PL/SQL - Using Binds of More Than 4000 Bytes in INSERT and UPDATE
        • Using the Data Interface for LOBs with INSERT, UPDATE, and SELECT Operations
        • Using the Data Interface for LOBs in Assignments and Parameter Passing
        • Using the Data Interface for LOBs with PL/SQL Built-In Functions
      • The Data Interface Used for Persistent LOBs in OCI
        • LOB Data Types Bound in OCI
        • LOB Data Types Defined in OCI
        • Multibyte Character Sets Used in OCI with the Data Interface for LOBs
        • OCI Functions Used to Perform INSERT or UPDATE on LOB Columns
          • Performing Simple INSERTs or UPDATEs in One Piece
          • Using Piecewise INSERTs and UPDATEs with Polling
          • Performing Piecewise INSERTs and UPDATEs with Callback
          • Array INSERT and UPDATE Operations
        • The Data Interface Used to Fetch LOB Data in OCI
          • Simple Fetch in One Piece
          • Performing a Piecewise Fetch with Polling
          • Performing a Piecewise with Callback
          • Array Fetch
        • PL/SQL and C Binds from OCI
        • Example: C (OCI) - Binds of More than 4000 Bytes for INSERT and UPDATE
        • Using the Data Interface for LOBs in PL/SQL Binds from OCI on LOBs
        • Binding LONG Data for LOB Columns in Binds Greater Than 4000 Bytes
        • Binding LONG Data to LOB Columns Using Piecewise INSERT with Polling
        • Binding LONG Data to LOB Columns Using Piecewise INSERT with Callback
        • Binding LONG Data to LOB Columns Using an Array INSERT
        • Selecting a LOB Column into a LONG Buffer Using a Simple Fetch
        • Selecting a LOB Column into a LONG Buffer Using Piecewise Fetch with Polling
        • Selecting a LOB Column into a LONG Buffer Using Piecewise Fetch with Callback
        • Selecting a LOB Column into a LONG Buffer Using an Array Fetch
      • The Data Interface Used with Persistent LOBs in Java
      • The Data Interface Used with Remote LOBs
        • About the Data Interface with Remote LOBs
        • Non-Supported Syntax
        • Remote Data Interface Example in PL/SQL
        • Remote Data Interface Example in OCI
        • Remote Data Interface Examples in JDBC
  • Part III Reference Semantics LOBs
    • 10 Overview of Supplied LOB APIs
      • Programmatic Environments That Support LOBs
      • Comparing the LOB Interfaces
      • Using PL/SQL (DBMS_LOB Package) to Work With LOBs
        • Provide a LOB Locator Before Running the DBMS_LOB Routine
        • Guidelines for Offset and Amount Parameters in DBMS_LOB Operations
        • Determining Character Set ID
        • PL/SQL Functions and Procedures for LOBs
        • PL/SQL Functions and Procedures to Modify LOB Values
        • PL/SQL Functions and Procedures for Introspection of LOBs
        • PL/SQL Operations on Temporary LOBs
        • PL/SQL Read-Only Functions and Procedures for BFILEs
        • PL/SQL Functions and Procedures to Open and Close Internal and External LOBs
      • Using OCI to Work With LOBs
        • Prefetching of LOB Data, Length, and Chunk Size
        • Setting the CSID Parameter for OCI LOB APIs
        • Fixed-Width and Varying-Width Character Set Rules for OCI
          • Other Operations
          • NCLOBs in OCI
        • OCILobLoadFromFile2() Amount Parameter
        • OCILobRead2() Amount Parameter
        • OCILobLocator Pointer Assignment
        • LOB Locators in Defines and Out-Bind Variables in OCI
        • OCI Functions That Operate on BLOBs, CLOBs, NCLOBs, and BFILEs
        • OCI Functions to Modify Persistent LOB (BLOB, CLOB, and NCLOB) Values
        • OCI Functions to Read or Examine Persistent LOB and External LOB (BFILE) Values
        • OCI Functions for Temporary LOBs
        • OCI Read-Only Functions for BFILEs
        • OCI LOB Locator Functions
        • OCI Functions to Open and Close Internal and External LOBs
        • OCI LOB Examples
        • Further Information About OCI
      • Using C++ (OCCI) to Work With LOBs
        • OCCI Classes for LOBs
          • Clob Class
          • Blob Class
          • Bfile Class
        • Fixed-Width Character Set Rules
        • Varying-Width Character Set Rules
        • Offset and Amount Parameters for Other OCCI Operations
          • NCLOBs in OCCI
        • Amount Parameter for OCCI LOB copy() Methods
        • Amount Parameter for OCCI read() Operations
        • Further Information About OCCI
        • OCCI Methods That Operate on BLOBs, BLOBs, NCLOBs, and BFILEs
        • OCCI Methods to Modify Persistent LOB (BLOB, CLOB, and NCLOB) Values
        • OCCI Methods to Read or Examine Persistent LOB and BFILE Values
        • OCCI Read-Only Methods for BFILEs
        • Other OCCI LOB Methods
        • OCCI Methods to Open and Close Internal and External LOBs
      • Using C/C++ (Pro*C) to Work With LOBs
        • Providing an Allocated Input Locator Pointer That Represents LOB
        • Pro*C/C++ Statements That Operate on BLOBs, CLOBs, NCLOBs, and BFILEs
        • Pro*C/C++ Embedded SQL Statements to Modify Persistent LOB Values
        • Pro*C/C++ Embedded SQL Statements for Introspection of LOBs
        • Pro*C/C++ Embedded SQL Statements for Temporary LOBs
        • Pro*C/C++ Embedded SQL Statements for BFILEs
        • Pro*C/C++ Embedded SQL Statements for LOB Locators
        • Pro*C/C++ Embedded SQL Statements to Open and Close LOBs
      • Using COBOL (Pro*COBOL) to Work With LOBs
        • Providing an Allocated Input Locator Pointer That Represents LOB
        • Pro*COBOL Statements That Operate on BLOBs, CLOBs, NCLOBs, and BFILEs
        • Pro*COBOL Embedded SQL Statements to Modify Persistent LOB Values
        • Pro*COBOL Embedded SQL Statements for Introspection of LOBs
        • Pro*COBOL Embedded SQL Statements for Temporary LOBs
        • Pro*COBOL Embedded SQL Statements for BFILEs
        • Pro*COBOL Embedded SQL Statements for LOB Locators
        • Pro*COBOL Embedded SQL Statements for Opening and Closing LOBs and BFILEs
      • Using Java (JDBC) to Work With LOBs
        • Modifying Internal Persistent LOBs Using Java
        • Reading Internal Persistent LOBs and External LOBs (BFILEs) With Java
          • BLOB, CLOB, and BFILE Classes
        • Calling DBMS_LOB Package from Java (JDBC)
        • Prefetching LOBs to Improve Performance
        • Zero-Copy Input/Output for SecureFiles to Improve Performance
          • Zero-Copy Input/Output on the Server
          • Zero-Copy Input/Output in the JDBC Thin Driver
          • JDBC-OCI Driver Considerations
        • Referencing LOBs Using Java (JDBC)
          • Using OracleResultSet: BLOB and CLOB Objects Retrieved
        • JDBC Syntax References and Further Information
        • JDBC Methods for Operating on LOBs
        • JDBC oracle.sql.BLOB Methods to Modify BLOB Values
        • JDBC oracle.sql.BLOB Methods to Read or Examine BLOB Values
        • JDBC oracle.sql.BLOB Methods and Properties for Streaming BLOB Data
        • JDBC oracle.sql.CLOB Methods to Modify CLOB Values
        • JDBC oracle.sql.CLOB Methods to Read or Examine CLOB Value
        • JDBC oracle.sql.CLOB Methods and Properties for Streaming CLOB Data
        • JDBC oracle.sql.BFILE Methods to Read or Examine External LOB (BFILE) Values
        • JDBC oracle.sql.BFILE Methods and Properties for Streaming BFILE Data
        • JDBC Temporary LOB APIs
        • JDBC: Opening and Closing LOBs
        • JDBC: Opening and Closing BLOBs
          • Opening the BLOB Using JDBC
          • Checking If the BLOB Is Open Using JDBC
          • Closing the BLOB Using JDBC
        • JDBC: Opening and Closing CLOBs
          • Opening the CLOB Using JDBC
          • Checking If the CLOB Is Open Using JDBC
          • Closing the CLOB Using JDBC
        • JDBC: Opening and Closing BFILEs
          • Opening BFILEs
          • Checking If the BFILE Is Open
          • Closing the BFILE
          • Usage Example (OpenCloseLob.java)
        • Truncating LOBs Using JDBC
          • JDBC: Truncating BLOBs
          • JDBC: Truncating CLOBs
        • JDBC BLOB Streaming APIs
        • JDBC CLOB Streaming APIs
        • BFILE Streaming APIs
          • JDBC BFILE Streaming Example (NewStreamLob.java)
        • JDBC and Empty LOBs
      • Oracle Provider for OLE DB (OraOLEDB)
      • Overview of Oracle Data Provider for .NET (ODP.NET)
    • 11 LOB APIs for BFILE Operations
      • Supported Environments for BFILE APIs
      • About Accessing BFILEs
      • Directory Objects
        • Initializing a BFILE Locator
        • How to Associate Operating System Files with a BFILE
      • BFILENAME and Initialization
      • Characteristics of the BFILE Data Type
        • DIRECTORY Name Specification
          • On Windows Platforms
      • BFILE Security
        • Ownership and Privileges
        • Read Permission on a DIRECTORY Object
        • SQL DDL for BFILE Security
        • SQL DML for BFILE Security
        • Catalog Views on Directories
        • Guidelines for DIRECTORY Usage
        • BFILEs in Shared Server (Multithreaded Server) Mode
        • External LOB (BFILE) Locators
          • When Two Rows in a BFILE Table Refer to the Same File
          • BFILE Locator Variable
          • Guidelines for BFILEs
      • About Loading a LOB with BFILE Data
      • About Opening a BFILE with OPEN
      • About Opening a BFILE with FILEOPEN
      • About Determining Whether a BFILE Is Open Using ISOPEN
      • About Determining Whether a BFILE Is Open with FILEISOPEN
      • About Displaying BFILE Data
      • About Reading Data from a BFILE
      • About Reading a Portion of BFILE Data Using SUBSTR
      • Comparing All or Parts of Two BFILES
      • Checking If a Pattern Exists in a BFILE Using INSTR
      • Determining Whether a BFILE Exists
      • Getting the Length of a BFILE
      • About Assigning a BFILE Locator
      • Getting Directory Object Name and File Name of a BFILE
      • About Updating a BFILE by Initializing a BFILE Locator
      • Closing a BFILE with FILECLOSE
      • Closing a BFILE with CLOSE
      • Closing All Open BFILEs with FILECLOSEALL
      • About Inserting a Row Containing a BFILE
    • 12 Using LOB APIs
      • Supported Environments
      • About Appending One LOB to Another
      • About Determining Character Set Form
      • About Determining Character Set ID
      • Loading a LOB with Data from a BFILE
      • About Loading a BLOB with Data from a BFILE
      • Loading a CLOB or NCLOB with Data from a BFILE
        • About PL/SQL: Loading Character Data from a BFILE into a LOB
        • About PL/SQL: Loading Segments of Character Data into Different LOBs
      • Determining Whether a LOB is Open
        • Java (JDBC): Checking If a LOB Is Open
          • Checking If a CLOB Is Open
          • Checking If a BLOB Is Open
      • About Displaying LOB Data
      • About Reading Data from a LOB
      • About LOB Array Read
      • Reading a Portion of a LOB (SUBSTR)
      • Comparing All or Part of Two LOBs
      • Patterns: Checking for Patterns in a LOB Using INSTR
      • Length: Determining the Length of a LOB
      • Copying All or Part of One LOB to Another LOB
      • Copying a LOB Locator
      • Equality: Checking If One LOB Locator Is Equal to Another
      • About Determining Whether LOB Locator Is Initialized
      • About Appending to a LOB
      • About Writing Data to a LOB
      • LOB Array Write
      • About Trimming LOB Data
      • About Erasing Part of a LOB
      • Determining Whether a LOB instance Is Temporary
        • Java (JDBC): Determining Whether a BLOB Is Temporary
      • Converting a BLOB to a CLOB
      • Converting a CLOB to a BLOB
      • Ensuring Read Consistency
  • Part IV Application Design with LOBs
    • 13 LOB Storage with Applications
      • Tables That Contain LOBs
        • Persistent LOBs Initialized to NULL or Empty
          • Setting a Persistent LOB to NULL
          • Setting a Persistent LOB to Empty
        • Initializing LOBs
        • Initializing Persistent LOB Columns and Attributes to a Value
        • Initializing BFILEs to NULL or a File Name
        • Restriction on First Extent of a LOB Segment
      • Data Types for LOB Columns
        • LOBs Compared to LONG and LONG RAW Types
        • Varying-Width Character Data Storage in LOBs
        • Converting Character Sets Implicitly with LOBs
      • LOB Storage Parameters
        • Inline and Out-of-Line LOB Storage
        • Defining Tablespace and Storage Characteristics for Persistent LOBs
          • Assigning a LOB Data Segment Name
        • LOB Storage Characteristics for LOB Column or Attribute
        • TABLESPACE and LOB Index
          • Tablespace for LOB Index in Non-Partitioned Table
        • PCTVERSION
        • RETENTION Parameter for BasicFiles LOBs
        • RETENTION Parameter for SecureFiles LOBs
        • CACHE / NOCACHE / CACHE READS
          • CACHE / NOCACHE / CACHE READS: LOB Values and Buffer Cache
        • LOGGING / NOLOGGING Parameter for BasicFiles LOBs
          • LOBs Always Generate Undo for LOB Index Pages
          • When LOGGING is Set Oracle Generates Full Redo for LOB Data Pages
            • NOLOGGING is Useful for Bulk Loads or Inserts.
        • LOGGING/FILESYSTEM_LIKE_LOGGING for SecureFiles LOBs
          • CACHE Implies LOGGING
          • SecureFiles and an Efficient Method of Generating REDO and UNDO
          • FILESYSTEM_LIKE_LOGGING is Useful for Bulk Loads or Inserts
        • CHUNK
          • The Value of CHUNK
            • Space Considerations
            • Performance Considerations
          • Set INITIAL and NEXT to Larger than CHUNK
        • ENABLE or DISABLE STORAGE IN ROW Clause
        • Guidelines for ENABLE or DISABLE STORAGE IN ROW
      • LOB Columns Indexing
        • Domain Indexing on LOB Columns
        • Text Indexes on LOB Columns
        • Function-Based Indexes on LOBs
        • Extensible Indexing on LOB Columns
          • Extensible Optimizer
        • Oracle Text Indexing Support for XML
      • LOB Manipulation in Partitioned Tables
        • About Manipulating LOBs in Partitioned Tables
        • Partitioning a Table Containing LOB Columns
        • Creating an Index on a Table Containing Partitioned LOB Columns
        • Moving Partitions Containing LOBs
        • Splitting Partitions Containing LOBs
        • Merging Partitions Containing LOBs
      • LOBs in Index Organized Tables
      • Restrictions for LOBs in Partitioned Index-Organized Tables
      • Updating LOBs in Nested Tables
    • 14 Advanced Design Considerations
      • Opening Persistent LOBs with the OPEN and CLOSE Interfaces
        • Index Performance Benefits of Explicitly Opening a LOB
        • Closing Explicitly Open LOB Instances
      • Read-Consistent Locators
        • A Selected Locator Becomes a Read-Consistent Locator
        • Example of Updating LOBs and Read-Consistency
        • Example of Updating LOBs Through Updated Locators
        • Example of Updating a LOB Using SQL DML and DBMS_LOB
        • Example of Using One Locator to Update the Same LOB Value
        • Example of Updating a LOB with a PL/SQL (DBMS_LOB) Bind Variable
      • LOB Locators and Transaction Boundaries
        • About LOB Locators and Transaction Boundaries
        • Read and Write Operations on a LOB Using Locators
        • Selecting the Locator Outside of the Transaction Boundary
        • Selecting the Locator Within a Transaction Boundary
        • LOB Locators Cannot Span Transactions
        • Example of Locator Not Spanning a Transaction
      • LOBs in the Object Cache
      • Terabyte-Size LOB Support
        • About Terabyte-Size LOB Support
        • Maximum Storage Limit for Terabyte-Size LOBs
        • Using Terabyte-Size LOBs with JDBC
        • Using Terabyte-Size LOBs with the DBMS_LOB Package
        • Using Terabyte-Size LOBs with OCI
      • Guidelines for Creating Gigabyte LOBs
        • Creating a Tablespace and Table to Store Gigabyte LOBs
    • 15 Performance Guidelines
      • LOB Performance Guidelines
        • All LOBs
          • Chunk Size
          • LOB Pre-fetching
          • Small LOBs
          • Large LOBs
        • Persistent LOBs
          • Performance Guidelines for Small BasicFiles LOBs
          • General Performance Guidelines for BasicFiles LOBs
        • Temporary LOBs
      • Moving Data to LOBs in a Threaded Environment
      • LOB Access Statistics
        • Example of Retrieving LOB Access Statistics
  • Part V LOB Administration
    • 16 Managing LOBs: Database Administration
      • Database Utilities for Loading Data into LOBs
        • About Using SQL*Loader to Load LOBs
        • About Using SQL*Loader to Populate a BFILE Column
        • About Using Oracle Data Pump to Transfer LOB Data
      • Temporary LOB Management
      • BFILEs Management
        • Rules for Using Directory Objects and BFILEs
        • Setting Maximum Number of Open BFILEs
      • Changing Tablespace Storage for a LOB
      • Managing LOB Signatures
    • 17 Migrating Columns from LONGs to LOBs
      • Benefits of Migrating LONG Columns to LOB Columns
      • Preconditions for Migrating LONG Columns to LOB Columns
        • Dropping a Domain Index on a LONG Column Before Converting to a LOB
        • Preventing Generation of Redo Space on Tables Converted to LOB Data Types
      • Determining how to Optimize the Application Using utldtree.sql
      • Converting Tables from LONG to LOB Data Types
        • Migration Issues
        • Using ALTER TABLE to Convert LONG Columns to LOB Columns
        • Copying a LONG to a LOB Column Using the TO_LOB Operator
        • Online Redefinition of Tables with LONG Columns
        • Using Oracle Data Pump to Migrate a Database
      • Migrating Applications from LONGs to LOBs
        • About Migrating Applications from Longs to LOBs
        • LOB Columns Are Not Allowed in Clustered Tables
        • LOB Columns Are Not Allowed in AFTER UPDATE OF Triggers
        • Rebuilding Indexes on Columns Converted from LONG to LOB Data Types
        • Empty LOBs Compared to NULL and Zero Length LONGs
        • Overloading with Anchored Types
        • Some Implicit Conversions Are Not Supported for LOB Data Types
  • Part VI Oracle File System (OFS) Server
    • 18 Introducing Network File System (NFS)
      • Prerequisites to Access Storage Through NFS Server
      • NFS Security
        • Kerberos
          • Configuring Kerberos Server in Linux
    • 19 Using OFS
      • Limitations of using OFS
      • OFS Configuration Parameters
      • OFS Client Interface
        • DBMS_FS Package
        • Views for OFS
  • Part VII Database File System (DBFS)
    • 20 Introducing the Database File System
      • Why a Database File System?
      • What Is Database File System (DBFS)?
        • About DBFS
        • DBFS Server
        • DBFS Client
      • What Is a Content Store?
    • 21 DBFS SecureFiles Store
      • Setting Up a SecureFiles Store
        • About Managing Permissions
        • Creating or Setting Permissions
        • Creating a SecureFiles File System Store
        • Accessing Tables that Hold SecureFiles System Store Data
        • Initializing SecureFiles Store File Systems
        • Comparison of SecureFiles LOBs to BasicFiles LOBs
      • Using a DBFS SecureFiles Store File System
        • DBFS Content API Working Example
        • Dropping SecureFiles Store File Systems
      • About DBFS SecureFiles Store Package, DBMS_DBFS_SFS
      • Database File System (DBFS)— POSIX File Locking
        • About Advisory Locking
        • About Mandatory Locking
        • File Locking Support
        • Compatibility and Migration Factors of Database Filesystem—File Locking
        • Examples of Database Filesystem—File Locking
        • File Locking Behavior
        • Scheduling File Locks
          • Greedy Scheduling
          • Fair Scheduling
    • 22 DBFS Hierarchical Store
      • About the Hierarchical Store Package, DBMS_DBFS_HS
      • Ways to Use DBFS Hierarchial Store
      • Setting up the Store
        • Managing a HS Store Wallet
        • Creating, Registering, and Mounting the Store
      • Using the Hierarchical Store
        • Using Hierarchical Store as a File System
        • Using Hierarchical Store as an Archive Solution For SecureFiles LOBs
        • Dropping a Hierarchical Store
        • Compression to Use with the Hierarchical Store
        • Program Example Using Tape
        • Program Example Using Amazon S3
      • Database File System Links
        • About Database File System Links
        • Ways to Create Database File System Links
        • Database File System Links Copy
        • Copying a Linked LOB Between Tables
        • Online Redefinition and DBFS Links
        • Transparent Read
      • The DBMS_DBFS_HS Package
        • Constants for DBMS_DBFS_HS Package
        • Methods for DBMS_DBFS_HS Package
      • Views for DBFS Hierarchical Store
        • DBA Views
        • User Views
    • 23 DBFS Content API
      • Overview of DBFS Content API
      • Stores and DBFS Content API
      • Getting Started with DBMS_DBFS_CONTENT Package
        • DBFS Content API Role
        • Path Name Constants and Types
        • Path Properties
        • Content IDs
        • Path Name Types
        • Store Features
        • Lock Types
        • Standard Properties
        • Optional Properties
        • User-Defined Properties
        • Property Access Flags
        • Exceptions
        • Property Bundles
        • Store Descriptors
      • Administrative and Query APIs
        • Registering a Content Store
        • Unregistering a Content Store
        • Mounting a Registered Store
        • Unmounting a Previously Mounted Store
        • Listing all Available Stores and Their Features
        • Listing all Available Mount Points
        • Looking Up Specific Stores and Their Features
      • Querying DBFS Content API Space Usage
      • DBFS Content API Session Defaults
      • DBFS Content API Interface Versioning
      • Notes on DBFS Content API Path Names
      • DBFS Content API Creation Operations
      • DBFS Content API Deletion Operations
      • DBFS Content API Path Get and Put Operations
      • DBFS Content API Rename and Move Operations
      • Directory Listings
      • DBFS Content API Directory Navigation and Search
      • DBFS Content API Locking Operations
      • DBFS Content API Access Checks
      • DBFS Content API Abstract Operations
      • DBFS Content API Path Normalization
      • DBFS Content API Statistics Support
      • DBFS Content API Tracing Support
      • Resource and Property Views
    • 24 Creating Your Own DBFS Store
      • Overview of DBFS Store Creation and Use
      • DBFS Content Store Provider Interface (DBFS Content SPI)
      • Creating a Custom Provider
        • Mechanics
          • Installation and Setup
          • TBFS Use
          • TBFS Internals
        • TBFS.SQL
        • TBL.SQL
        • spec.sql
        • body.sql
        • capi.sql
    • 25 Using DBFS
      • DBFS Installation
      • Creating a DBFS File System
        • Privileges Required to Create a DBFS File System
        • Advantages of Non-Partitioned Versus Partitioned DBFS File Systems
        • Creating a Non-Partitioned File System
        • Creating a Partitioned File System
        • Dropping a File System
      • DBFS File System Access
        • DBFS Client Prerequisites
        • DBFS Client Command-Line Interface Operations
          • About the DBFS Client Command-Line Interface
          • Creating Content Store Paths
          • Creating a Directory
          • Listing a Directory
          • Copying Files and Directories
          • Removing Files and Directories
        • DBFS Mounting Interface (Linux and Solaris Only)
          • Installing FUSE on Solaris 11 SRU7 and Later
          • Mounting the DBFS Store
          • Solaris-Specific Privileges
          • About the Mount Command for Solaris and Linux
          • Mounting a File System with a Wallet
          • Mounting a File System with Password at Command Prompt
          • Mounting a File System with Password Read from a File
          • Unmounting a File System
          • Mounting DBFS Through fstab Utility for Linux
          • Mounting DBFS Through the vfstab Utility for Solaris
          • Restrictions on Mounted File Systems
        • File System Security Model
          • About the File System Security Model
          • Enabling Shared Root Access
          • About DBFS Access Among Multiple Database Users
          • Establishing DBFS Access Sharing Across Multiple Database Users
        • HTTP, WebDAV, and FTP Access to DBFS
          • Internet Access to DBFS Through XDB
          • Web Distributed Authoring and Versioning (WebDAV) Access
          • FTP Access to DBFS
          • HTTP Access to DBFS
      • DBFS Administration
        • Using Oracle Wallet with DBFS Client
        • DBFS Diagnostics
        • Preventing Data Loss During Failover Events
        • Bypassing Client-Side Write Caching
        • Backing up DBFS
          • DBFS Backup at the Database Level
          • DBFS Backup Through a File System Utility
        • Small File Performance of DBFS
        • Enabling Advanced SecureFiles LOB Features for DBFS
      • Shrinking and Reorganizing DBFS Filesystems
        • About Changing DBFS Filesystems
        • Advantages of Online Filesystem Reorganization
        • Determining Availability of Online Filesystem Reorganization
        • Invoking Online Filesystem Reorganization
  • A LOB Demonstration Files
    • PL/SQL LOB Demonstration Files
    • OCI LOB Demonstration Files
    • Java LOB Demonstration Files
  • Glossary
  • Index

Search

Print

Download

PDF for offline and print

  • Previous
  • Next
  1. Database SecureFiles and Large Objects Developer's Guide
  2. Value Semantics LOBs

Part II Value Semantics LOBs

This part describes SQL semantics for LOBs supported in the SQL and PL/SQL environments.

This part contains these chapters:

  • SQL Semantics and LOBs

  • PL/SQL Semantics for LOBs

  • Migrating Columns from LONGs to LOBs

  • Previous
  • Next
Back to main content
  • About Oracle
  • Contact Us
  • Legal Notices
  • Terms of Use
  • Your Privacy Rights
  • Cookie Preferences
Copyright © 1996, 2019, Oracle and/or its affiliates. All rights reserved.
  • Previous
  • Next
Video