CHAPTER 7 Tables and Constraints

Logical Progression of Steps in Creating a Database Environment 1. Install Oracle database binaries (Chapter 1) 2. Create database (Chapter 2) 3. Establish a way to manage your environment (Chapter 3) 4. Create and manage tablespaces and datafiles (Chapter 4) 5. Understand and manage control files and online redo logs (Chapter 5) 6. Create users and establish basic security (Chapter 6) 7. Create database objects (Chapter 7, 8, 9)

Tables and Constraints A table is the basic storage container for data in a database. You create and modify the table structure via Data Definition Language (DDL) statements such as CREATE TABLE and ALTER TABLE You access and manipulate table data via Data Manipulation Language (DML) statements (INSERT, UPDATE, DELETE, MERGE, and SELECT) A constraint is a mechanism for enforcing that data adheres to business rules Examples of constraints: Primary key uniqueness, not null values, relationships between data in tables (foreign keys)

Understanding Table Types Heap-organized Temporary Index-organized (IOT) Partitioned Materialized view (MV) Clustered External Nested Object

Choosing Table Features If a column always contains numeric data, make it a number data type. If you have a business rule that defines the length and precision of a number field, then enforce it; for example, NUMBER(7,2). If you don’t have a business rule, make it NUMBER(38). For character data that is of variable length, use VARCHAR2 (and not VARCHAR). Use DATE and TIMESTAMP data types appropriately. Consider setting the physical attribute PCTFREE to a value higher than the default of 10% if the table initially has rows inserted with null values that are later updated with large values. Index-organized (IOT)

Choosing Table Features (continued) Most tables should be created with a primary key. Create a numeric surrogate key to be the primary key for each table. Populate the surrogate key from a sequence. Create a unique key for the logical business key; a recognizable combination of columns that makes a row unique. Define foreign keys where appropriate. Consider special features such as virtual columns, read- only, parallel, compression, no logging, and so on. Index-organized (IOT)

Choosing Table Features (continued) Use standards when naming tables, columns, constraints, triggers, indexes, and so on. If you have a business rule that specifies the maximum length of a column, then use that length, as opposed to making all columns VARCHAR2(4000). Specify a separate tablespace for the table and indexes. Let tables and indexes inherit storage attributes from the tablespaces. Create primary-key constraints out of line. Create comments for the tables and columns. If a column should always have a value, then enforce it with a NOT NULL constraint. Create audit-type columns, such as CREATE_DTT and UPDATE_DTT, that are automatically populated with default values and/or triggers. Index-organized (IOT)

Creating a Heap-organized Table Use the CREATE TABLE statement to create tables create table d_sources( d_source_id number not null, source_type varchar2(32), create_dtt date default sysdate not null, update_dtt timestamp(5) );

More Complex Create Table Statement create table operating_systems( operating_system_id number(19, 0) not null, version varchar2(50), os_name varchar2(256), release varchar2(50), vendor varchar2(50), create_dtt date default sysdate not null, update_dtt date, constraint operating_systems_pk primary key (operating_system_id) using index tablespace inv_mgmt_index ) tablespace inv_mgmt_data ;

Implementing Virtual Columns A virtual column is based on one or more existing columns from the same table and/or a combination of constants, SQL functions, and user-defined PL/SQL functions Virtual columns aren’t stored on disk Evaluated at runtime when the SQL query executes Virtual columns can be indexed and can have stored statistics Tip: Consider using an indexed virtual column instead of using a function based index

Advantages of Virtual Columns You can create an index on a virtual column. Internally, Oracle creates a function-based index. You can store statistics in a virtual column that can be used by the cost-based optimizer (CBO). Virtual columns can be referenced in WHERE clauses. Virtual columns are permanently defined in the database. There is one central definition of such a column

Virtual Column Example create table inv( inv_id number,inv_count number,inv_status generated always as ( case when inv_count <= 100 then 'GETTING LOW' when inv_count > 100 then 'OKAY' end) );

Virtual Column Considerations You can only define a virtual column on a regular heap- organized table. You can’t define a virtual column on an index-organized table, an external table, a temporary table, object tables, or cluster tables. Virtual columns can’t reference other virtual columns. Virtual columns can only reference columns from the table in which the virtual column is defined. The output of a virtual column must be a scalar value (a single value, not a set of values).

Reasons for Read-Only Tables The data in the table is historical and should never be updated in normal circumstances. You’re performing some maintenance on the table and want to ensure that it doesn’t change while it’s being updated. You want to drop the table, but before you do, you want to place it in read-only mode to better determine if any users are attempting to update the table. SQL> alter table inv read only; SQL> alter table inv read write;

Avoiding Extent Allocation Delays When Creating Tables Starting with Oracle Database 11g R2, with non-partitioned heap-organized tables created in locally managed tablespaces, the initial segment creation is deferred. Allows for a faster installation of applications that have a large number of tables and indexes; this improves installation speed, especially when you have thousands of objects. As a DBA, your space usage reports may initially confuse you when you notice that there is no space allocated for objects. The creation of the first row will take a slightly longer time than in previous versions (because now Oracle allocates the first extent based on the creation of the first row). For most applications, this performance degradation is not noticeable.

Avoiding Extent Allocation Delays When Creating Tables (continued) SQL> create table f_regs(reg_id number, reg_name varchar2(200)); SQL> select count(*) from user_segments where segment_name='F_REGS'; COUNT(*) SQL> insert into f_regs values(1,'BRDSTN'); 1 row created. SQL> select count(*) from user_segments where segment_name='F_REGS'; COUNT(*) You can disable the deferred segment creation feature by setting the database initialization parameter DEFERRED_SEGMENT_CREATION to FALSE Deferred segment generation also applies to partitioned tables and indexes. An extent will not be allocated until the initial record is inserted into a given extent.

Parallel SQL Execution For large table operations, consider using PARALLEL create table inv_apr_10 parallel 2 as select * from inv where create_dtt >= '01-apr-10' and create_dtt < '01-may- 10';

Compressing Data for Direct Path Loading Use the COMPRESS clause to enable compression either when creating, altering, or moving an existing table. Load data via a direct path mechanism such as CREATE TABLE…AS SELECT or INSERT /*+ APPEND */. Prior to Oracle Database 11g R2, basic compression was referred to as DSS compression and enabled via the COMPRESS FOR DIRECT_LOAD OPERATION clause. This syntax is deprecated in Oracle Database 11g R2 and higher.

Compressing Data for Direct Path Loading (continued) create table regs_dss compress as select reg_id, reg_name from regs; The prior statement creates a table with compressed data in it. Any subsequent direct path–load operations will also load the data in a compressed format. You can use either the COMPRESS clause or the COMPRESS BASIC clause to enable the basic table compression feature. The COMPRESS clause and COMPRESS BASIC clause are synonymous.

Compressing Data for All DML Use the COMPRESS FOR OLTP clause when creating a table to enable data compression when using regular DML statements to manipulate data Prior to Oracle Database 11g R2, OLTP table compression was enabled using the COMPRESS FOR ALL OPERATIONS clause. This syntax is deprecated in Oracle Database 11g R2 and higher. create table regs (reg_id number,reg_name varchar2(2000) ) compress for oltp;

Compressing Data at the Column Level The Oracle Exadata product allows for column level compression (hybrid columnar compression) To enable hybrid columnar compression, when creating a table, use either the COMPRESS FOR QUERY or the COMPRESS FOR ARCHIVE clause create table f_regs( reg_id number,reg_desc varchar2(4000)) compress for query;

Compressing Data at the Column Level (continued) These levels are listed here from the lowest level of column level compression to the highest level: COMPRESS FOR QUERY LOW COMPRESS FOR QUERY HIGH COMPRESS FOR ARCHIVE LOW COMPRESS FOR ARCHIVE HIGH COMPRESS FOR QUERY is appropriate for bulk load operations on heap-organized tables that are infrequently updated COMPRESS FOR ARCHIVE maximizes the degree of compression and is more appropriate for data that is stored for long periods of time and will not be updated

Maximizing Data Loading Speeds Set the table’s logging attribute to NOLOGGING;, this minimizes the generation redo for direct path operations (this feature has no effect on regular DML operations). Use a direct path loading feature, such as the following: INSERT /*+ APPEND */ on queries that use a subquery for determining which records are inserted. INSERT /*+ APPEND_VALUES */ on queries that use a VALUES clause. CREATE TABLE…AS SELECT

Creating a Table from a Query Create table as select (CTAS) create table cwp_user_profile_ as select * from cwp_user_profile; create table cwp_user_profile_ nologging tablespace staging_data parallel 2 as select * from cwp_user_profile_tab;

Modifying a Table Renaming the table Adding a column Altering a column Renaming a column Dropping a column

Obtaining the Needed Lock In Oracle Database 11g and higher, set the DDL_LOCK_TIMEOUT parameter. Avoids the ORA-00054: resource busy and acquire with NOWAIT specified or timeout expired SQL> alter session set ddl_lock_timeout=100;

Reasons for Renaming a Table To make the table conform to standards To better determine whether the table is being used before you drop it SQL> rename inv_mgmt to inv_mgmt_old;

Adding a Column Requirements often change after initially creating the table SQL> alter table inv add(inv_count number);

Altering a Column Requirements often change after the column definitions are defined and implemented SQL> alter table inv modify inv_desc varchar2(256);

Renaming a Column Sometimes requirements change, and you want to modify the column name to better reflect what the column is used for. If you’re planning to drop a column, it doesn’t hurt to rename the column first to better determine whether any users or applications are accessing the column. SQL> alter table inv rename column inv_count to inv_amt;

Dropping a Column Sometimes column are initially created and never used, or requirements change after the table was created SQL> alter table inv drop (inv_name);

Displaying Table DDL Query the data dictionary Use the exp and imp utilities Use Data Pump Use the DBMS_METADATA package Example using DBMS_METADATA: SQL> set long SQL> select dbms_metadata.get_ddl('TABLE','INV') from dual;

Dropping a Table Consider renaming the table before dropping it SQL> drop table emp; Use PURGE to drop table permanently (remove it from the recyclebin): SQL> drop table emp purge;

Undropping a Table When you drop a table (without PURGE clause), the table is renamed, this is known as placing it in the recyclebin View recylebin: SQL> show recyclebin To undrop a table: SQL> flashback table purchases to before drop;

Removing Data from a Table Using Delete SQL> delete from inv; SQL> commit;

Removing Data from a Table Using Truncate TRUNCATE is a DDL statement Oracle automatically commits the statement SQL> truncate table computer_systems;

Detecting Table with Significant Free Space Below High Water Mark Using Autotrace 1. SQL> set autotrace trace statistics 2. Run the query that performs the full-table scan. 3. Compare the number of rows processed to the number of logical I/Os (memory and disk accesses).

Detecting Table with Significant Free Space Below High Water Mark Using DBMS_SPACE dbms_space.space_usage( segment_owner => user, segment_name => 'INV', segment_type => 'TABLE',

Removing Free Space Below High Water Mark Use a TRUNCATE statement (removes all data from the table) Use ALTER TABLE... SHRINK SPACE Use ALTER TABLE... MOVE SQL> alter table inv enable row movement; SQL> alter table inv shrink space; SQL> alter table parties move tablespace mts;

Creating a Temporary Table Sometimes applications need a temporary table for the duration of the session Used to hold data temporarily by the application during the session ON COMMIT PRESERVE ROWS ON COMMIT DELETE ROWS create global temporary table today_regs on commit preserve rows as select * from f_registrations where create_dtt > sysdate - 1;

Creating an Index-Organized Table IOTs are efficient when most of the columns in the table are part of the primary key IOTs uses a b-tree index structure create table prod_sku (prod_sku_id number, sku varchar2(256), create_dtt timestamp(5), constraint prod_sku_pk primary key(prod_sku_id) ) organization index including sku pctthreshold 30 tablespace inv_mgmt_data overflow tablespace mts;

Managing Constraints Primary key Unique key Foreign key Check Not null

Creating Primary-Key Constraints Guarantees uniqueness for primary key columns Most tables should always include a primary key Example: create table dept( dept_id number, dept_desc varchar2(30), constraint dept_pk primary key (dept_id) using index tablespace prod_index);

Enforcing Unique Key Values Use unique keys to enforce uniqueness on columns that aren’t part of the primary key Example: create table dept( dept_id number,dept_desc varchar2(30) constraint dept_desc_uk1 unique using index tablespace prod_index);

Creating Foreign-key Constraints Foreign-key constraints are used to ensure that a column value (or multiple columns) is contained within a defined list of values in a column or columns in another table Used to enforce that a child record has a corresponding record in a parent table Parent table must contain a PK or UK constraint on parent table columns referenced in the child table foreign key columns Example: create table emp( emp_id number, name varchar2(30), dept_id constraint emp_dept_fk references dept(dept_id));

Checking for Specific Data Conditions Check constraints work well for enforcing a column value is of a specific value Works well for static, fairly small list of know values, for example Y or N, 0 or 1, and so on Example: CREATE table emp( emp_id number, emp_name varchar2(30), st_flg number(1) constraint "st_flg must be 0 or 1" check (st_flg in (0,1)) );

Enforcing Not Null Conditions Business requirements may dictate that a column always contain a value Example: create table emp( emp_id number, emp_name varchar2(30) constraint emp_name_nn not null);

Disabling Constraints Sometimes you will need to disable constraints on a table Easier than dropping and re-creating Prior to truncating a table that has a primary key referenced by a foreign key; in this scenario, first disable the constraints and then truncate, then re-enable constraints Example: SQL> alter table f_sales disable constraint f_sales_fk1;

Summary DBAs must know how to create and maintain tables and constraints Several new 11g features related to tables were introduced in this chapter Tables are the basic object used to store data Constraints enforce business rules related to data integrity