link rel="Stylesheet" href="../../dcommon/css/doccd.css" title="Default" type="text/css" />
10g Release 1 ( 10.1) Part Number B10739-01 |
| ||||||
|
View PDF |
This chapter describes various aspects of managing partitioned tables and indexes, and contains the following topics:
Modern enterprises fre quently run mission-critical databases containing upwards of several hundred gigabytes and, in many cases, several terabytes of data. These enterprises are challenged by the support and maintenance requirements of very large databases (VLDB), and must devise methods to meet those challenges.
One way to meet VLDB demands is to create and use partitioned tables and indexes. Partitioned tables allow your data to be broken down into smaller, more manageable pieces called partitions, or even subpartitions. Indexes can be partitioned in similar fashion. Each partiti on is stored in its own segment and can be managed individually. It can function independently of the other partitions, thus providin g a structure that can be better tuned for availability and performance.
If you are using parallel execution, partitions provi de another means of parallelization. Operations on partitioned tables and indexes are performed in parallel by assigning different pa rallel execution servers to different partitions of the table or index.
Partitions and subpartitions of a table or index all s
hare the same logical attributes. For example, all partitions (or subpartitions) in a table share the same column and constraint defi
nitions, and all partitions (or subpartitions) of an index share the same index options. They can, however, have different physical a
ttributes (such as TABLESPACE).
Although you are not required to keep each table or index partition (or subpartit ion) in a separate tablespace, it is to your advantage to do so. Storing partitions in separate tablespaces enables you to:
Reduce the possibility of data corruption in multiple partitions
Back up and recover each partition independently
Control the mapping of partitions to disk drives (important for balancing I/O load)
Improve manageability, availability, and performance
Partitioning is transpar ent to existing applications and standard DML statements run against partitioned tables. However, an application can be programmed to take advantage of partitioning by using partition-extended table or index names in DML.
You can use SQL*Loader and the import and export utilities to load or unload data stored in partitioned tables. These utilities are all partition and subpartition aware.< /p>
|
See Also:
|
There are several partitionin g methods offered by Oracle Database:
Range partitioning
Hash partitioning< /p>
List partitioning
Composite range-hash partitioning
Composite range-list partitioning
Indexes, as well as tables, can be partitioned. A global index can be partitioned by the range or hash method, and it can be de fined on any type of partitioned, or nonpartitioned, table. It can require more maintenance than a local index.
A local index< a id="sthref2216" name="sthref2216"> is constructed so that it reflects the structure of the underlying table. It is equipartitioned with the underlying table, meaning that it is partitioned on the same columns as the und erlying table, creates the same number of partitions or subpartitions, and gives them the same partition bounds as corresponding part itions of the underlying table. For local indexes, index partitioning is maintained automatically when partitions are affected by mai ntenance activity. This ensures that the index remains equipartitioned with the underlying table.
The following sections can h elp you decide on a partitioning method appropriate for your needs:
Use range partitioning to map rows to partitions based on r anges of column values. This type of partitioning is useful when dealing with data that has logical ranges into which it can be distr ibuted; for example, months of the year. Performance is best when the data evenly distributes across the range. If partitioning by ra nge causes partitions to vary dramatically in size because of unequal distribution, you may want to consider one of the other methods of partitioning.
When creating range partitions, you must specify:
Partitioning method: range
Partitioning column(s)
Partition descriptions identifying partition bounds
The example below creates a table of four partitions, one for each quarter of sales. The columns sale_year, sale_month, and sale_day are the partitioning columns, while their values constitute th
e partitioning key of a specific row. The VALUES LESS THAN clause determines the partition boun
d: rows with partitioning key values that compare less than the ordered list of values specified by the clause are stored in
the partition. Each partition is given a name (sales_q1, sales_q2, ...), and each partition is contained i
n a separate tablespace (tsa, tsb, ...).
CREATE TABLE sales
( invoice_no
NUMBER,
sale_year INT NOT NULL,
sale_month INT NOT NULL,
sale_day INT NOT NULL )
PARTITION BY RANGE (sale_yea
r, sale_month, sale_day)
( PARTITION sales_q1 VALUES LESS THAN (1999, 04, 01)
TABLESPACE tsa,
PARTITION sales_q2 V
ALUES LESS THAN (1999, 07, 01)
TABLESPACE tsb,
PARTITION sales_q3 VALUES LESS THAN (1999, 10, 01)
TABLESPACE
tsc,
PARTITION sales_q4 VALUES LESS THAN (2000, 01, 01)
TABLESPACE tsd );
A row with sale_year=1999
, sale_month=8, and sale_day=1 has a partitioning key of (1999, 8, 1) and would be stor
ed in partition sales_q3.
Use hash partitioning if your data does not easily lend itself to range partitioning, but you would like to partition for perf ormance and manageability reasons. Hash partitioning provides a method of evenly distributing data across a specified number of parti tions. Rows are mapped into partitions based on a hash value of the partitioning key. Creating and using hash partitions gives you a highly tunable method of data placement, because you can influence availability and performance by spreading these evenly sized parti tions across I/O devices (striping).
To create hash partitions you specify the following:
Partiti oning method: hash
Partitioning column(s)
Number of partitions or individua l partition descriptions
The following example creates a hash-partitioned table. The partitioning column is id
, four partitions are created and assigned system generated names, and they are placed in four named tablespaces (gear1<
/code>, gear2, ...).
CREATE TABLE scubagear
(id NUMBER,
name VARCHAR2 (60))
PARTITION BY HASH (id)
PARTITIONS 4
STORE IN (gear1, gear2, gear3, gear4);
Use list partitioning when you require explicit control over how rows map to partitions. You can specify a list of discrete value s for the partitioning column in the description for each partition. This is different from range partitioning, where a range of valu es is associated with a partition, and from hash partitioning, where the user has no control of the row to partition mapping.
The list partitioning method is specifically designed for modeling data distributions that follow discrete values. This cannot be eas ily done by range or hash partitioning because:
Range partitioning assumes a natural range of values for the partitioning column. It is not possible to group together out-of-range values partitions.
Hash part itioning allows no control over the distribution of data because the data is distributed over the various partitions using the system hash function. Again, this makes it impossible to logically group together discrete values for the partitioning columns into partiti ons.
Further, list partitioning allows unordered and unrelated sets of data to be grouped and organized together ver y naturally.
Unlike the range and hash partitioning methods, multicolumn partitioning is not supported for list partitioning. If a table is partitioned by list, the partitioning key can consist only of a single column of the table. Otherwise all columns that can be partitioned by the range or hash methods can be partitioned by the list partitioning method.
When creating list partiti ons, you must specify:
Partitioning method: list
Partitioning column
Partition descriptions, each specifying a list of literal values (a value list), which are th e discrete values of the partitioning column that qualify a row to be included in the partition
The following exampl
e creates a list-partitioned table. It creates table q1_sales_by_region which is partitioned by regions consisting of gr
oups of states.
CREATE TABLE q1_sales_by_region
(deptno number,
deptname varchar2(20),
quarterly_sales number(10, 2),
state varchar2(2))
PARTITION BY LIST (state)
(PARTITION q1_northwest VALUES ('OR'
, 'WA'),
PARTITION q1_southwest VALUES ('AZ', 'UT', 'NM'),
PARTITION q1_northeast VALUES ('NY', 'VM', 'NJ'),
PA
RTITION q1_southeast VALUES ('FL', 'GA'),
PARTITION q1_northcentral VALUES ('SD', 'WI'),
PARTITION q1_southcentral VALU
ES ('OK', 'TX'));
A row is mapped to a partition by checking whether the value of the partitioning column for a row match es a value in the value list that describes the partition.
For example, some sample rows are inserted as follows:
(10, 'accounting', 100, 'WA') maps to partition q1_northwest
(20, 'R&D
', 150, 'OR') maps to partition q1_northwest
(30, 'sales', 100, 'FL') maps to partition
(40, 'HR', 10, 'TX') maps to partition q1_southwest
(50, 'systems engineering', 10, 'CA') does not map to any partition in the table and raises an error
Un
like range partitioning, with list partitioning, there is no apparent sense of order between partitions. You can also specify a
Range-hash partitioning partitions data using the range method, and within each partition, subpartitions it using the hash method. T hese composite partitions are ideal for both historical data and striping, and provide improved manageability of range partitioning a nd data placement, as well as the parallelism advantages of hash partitioning.
When creating range-hash partitions, you specif y the following:
Partitioning method: range
Partitioning column(s)
Partition descriptions identifying partition bounds
Subpartitioning method: hash
Subpartitioning column(s)
Number of subpartitions for each partition or descr iptions of subpartitions
The following statement creates a range-hash partitioned table. In this example, three rang
e partitions are created, each containing eight subpartitions. Because the subpartitions are not named, system generated names are as
signed, but the STORE IN clause distributes them across the 4 specified tablespaces (ts1, ...,ts4).
CREATE TABLE scubagear (equipno NUMBER, equipname VARCHAR(32), price NUMBER)
PARTITION BY RANGE
(equipno) SUBPARTITION BY HASH(equipname)
SUBPARTITIONS 8 STORE IN (ts1, ts2, ts3, ts4)
(PARTITION p1 VALUES LESS THAN (10
00),
PARTITION p2 VALUES LESS THAN (2000),
PARTITION p3 VALUES LESS THAN (MAXVALUE));
The partitions of a r ange-hash partitioned table are logical structures only, as their data is stored in the segments of their subpartitions. As with part itions, these subpartitions share the same logical attributes. Unlike range partitions in a range-partitioned table, the subpartition s cannot have different physical attributes from the owning partition, although they are not required to reside in the same tablespac e.
Like the compos ite range-hash partitioning method, the composite range-list partitioning method provides for partitioning based on a two level hiera rchy. The first level of partitioning is based on a range of values, as for range partitioning; the second level is based on discrete values, as for list partitioning. This form of composite partitioning is well suited for historical data, but lets you further group the rows of data based on unordered or unrelated column values.
When creating range-list partitions, you specify the followin g:
Partitioning method: range
Partitioning column(s)
Partition descriptions identifying partition bounds
Subpartitioning method: list
Subpartitioning column
Subpartition descriptions, each specifying a list of literal values (a value list), which are the discrete values of the subpartitioning column that qualify a row to be included in the subpartition
The following example illustrates how range-list partitioning might be used. The example tracks sales data of products by quarters and within each quarter, groups it by specified states.
CREATE TABLE quart
erly_regional_sales
(deptno number, item_no varchar2(20),
txn_date date, txn_amount number, state varchar2(2))
TABLESP
ACE ts4
PARTITION BY RANGE (txn_date)
SUBPARTITION BY LIST (state)
(PARTITION q1_1999 VALUES LESS THAN (TO_DATE('1-APR-19
99','DD-MON-YYYY'))
(SUBPARTITION q1_1999_northwest VALUES ('OR', 'WA'),
SUBPARTITION q1_1999_southwest VALUES ('A
Z', 'UT', 'NM'),
SUBPARTITION q1_1999_northeast VALUES ('NY', 'VM', 'NJ'),
SUBPARTITION q1_1999_southeast VALUES
('FL', 'GA'),
SUBPARTITION q1_1999_northcentral VALUES ('SD', 'WI'),
SUBPARTITION q1_1999_southcentral VALUES ('O
K', 'TX')
),
PARTITION q2_1999 VALUES LESS THAN ( TO_DATE('1-JUL-1999','DD-MON-YYYY'))
(SUBPARTITION q2_1999
_northwest VALUES ('OR', 'WA'),
SUBPARTITION q2_1999_southwest VALUES ('AZ', 'UT', 'NM'),
SUBPARTITION q2_1999_no
rtheast VALUES ('NY', 'VM', 'NJ'),
SUBPARTITION q2_1999_southeast VALUES ('FL', 'GA'),
SUBPARTITION q2_1999_north
central VALUES ('SD', 'WI'),
SUBPARTITION q2_1999_southcentral VALUES ('OK', 'TX')
),
PARTITION q3_1999 VAL
UES LESS THAN (TO_DATE('1-OCT-1999','DD-MON-YYYY'))
(SUBPARTITION q3_1999_northwest VALUES ('OR', 'WA'),
SUBPARTIT
ION q3_1999_southwest VALUES ('AZ', 'UT', 'NM'),
SUBPARTITION q3_1999_northeast VALUES ('NY', 'VM', 'NJ'),
SUBPAR
TITION q3_1999_southeast VALUES ('FL', 'GA'),
SUBPARTITION q3_1999_northcentral VALUES ('SD', 'WI'),
SUBPARTITION
q3_1999_southcentral VALUES ('OK', 'TX')
),
PARTITION q4_1999 VALUES LESS THAN ( TO_DATE('1-JAN-2000','DD-MON-YYYY')
)
(SUBPARTITION q4_1999_northwest VALUES ('OR', 'WA'),
SUBPARTITION q4_1999_southwest VALUES ('AZ', 'UT', 'NM'),
SUBPARTITION q4_1999_northeast VALUES ('NY', 'VM', 'NJ'),
SUBPARTITION q4_1999_southeast VALUES ('FL', 'GA'),
SUBPARTITION q4_1999_northcentral VALUES ('SD', 'WI'),
SUBPARTITION q4_1999_southcentral VALUES ('OK', 'TX')
)
);
A row is mapped to a partition by checking whether the value of the partitioning column for a row falls within a specific partition range. The row is then mapped to a subpartition within that partition by identifying the subpartition whose des criptor value list contains a value matching the subpartition column value.
For example, some sample rows are inserted as foll ows:
(10, 4532130, '23-Jan-1999', 8934.10, 'WA') maps to subpartition q1_1999_northwest
(20, 5671621, '15-May-1999', 49021.21, 'OR') maps to subpartition q2_1999_northwest
(30, 9977612, ,'07-Sep-1999', 30987.90, 'FL') maps to subpartition q3_1999_southeast
(40, 9977612, '29-Nov-1999', 67891.45, 'TX') maps to subpartition q4_1999_southcentral
(40, 4532130, '5-Jan-2000', 897231.55, 'TX') does not map to any partition in the table and raises an error
(50, 5671621, '17-Dec-1999', 76123.35, 'CA') does not map to any subpartition in the table and raises an error
The partitions of a range-list partitioned table are logical structures only, as their data is stored in the segments of thei r subpartitions. The list subpartitions have the same characteristics as list partitions. You can specify a default subpartition, just as you s pecify a default partition for list partitioning.
Creating a partitioned table or index i s very similar to creating a nonpartitioned table or index (as described in Chapter 14, " Managing Tabl es"), but you include a partitioning clause. The partitioning clause, and subclauses, that you include depend upon the type of pa rtitioning you want to achieve.
You can partition both regular (heap organized) tables and index-organized tables, except for those cont
aining LONG or LONG RAW columns. You can create nonpartitioned global indexes, range or hash-partitioned gl
obal indexes, and local indexes on partitioned tables.
When you create (or alter) a partitioned table, a row movement clause,
either ENABLE ROW MOVEMENT or DISABLE ROW
MOVEMENT can be specified. This clause either enables or disables the migration of a row to a new partition if its key is upda
ted. The default is DISABLE ROW MOVEMENT.
The following sections present details and examples of creating partiti ons for the various types of partitioned tables and indexes:
Using Subpartition Templates to Describe Composite Par titioned Tables
Partitionin g Restrictions for Multiple Block Sizes
|
See Also:
|
The PARTITION BY RANGE clause of the CREATE TABLE statement specifies that the table or index is to be range-partitioned. The PARTITION clauses identify the individual partition ranges, and optional subclaus
es of a PARTITION clause can specify physical and other attributes specific to a partition segment. If not overridden at
the partition level, partitions inherit the attributes of their underlying table.
In th
is example, more complexity is added to the example presented earlier for a range-partitioned table. Storage parameters and a L
OGGING attribute are specified at the table level. These replace the corresponding defaults inherited from the tablespace leve
l for the table itself, and are inherited by the range partitions. However, since there was little business in the first quarter, the
storage attributes for partition sales_q1 are made smaller. The ENABLE ROW MOVEMENT clause is specified to allow the migration of a row to a new partition if an update to a key value is made that wo
uld place the row in a different partition.
CREATE TABLE sales
( invoice_no NUMBER,
sale_y
ear INT NOT NULL,
sale_month INT NOT NULL,
sale_day INT NOT NULL )
STORAGE (INITIAL 100K NEXT 50K) LOGGING
PA
RTITION BY RANGE ( sale_year, sale_month, sale_day)
( PARTITION sales_q1 VALUES LESS THAN ( 1999, 04, 01 )
TABLESPACE ts
a STORAGE (INITIAL 20K, NEXT 10K),
PARTITION sales_q2 VALUES LESS THAN ( 1999, 07, 01 )
TABLESPACE tsb,
PARTITI
ON sales_q3 VALUES LESS THAN ( 1999, 10, 01 )
TABLESPACE tsc,
PARTITION sales q4 VALUES LESS THAN ( 2000, 01, 01 )
TABLESPACE tsd)
ENABLE ROW MOVEMENT;
The
rules for creating range-partitioned global indexes are similar to those for creating range-partitioned tables. The following is an example of creating a range-partitioned global inde
x on sales_month for the table created in the preceding example. Each index par
tition is named but is stored in the default tablespace for the index.
CREATE INDEX month_ix ON sales(s
ales_month)
GLOBAL PARTITION BY RANGE(sales_month)
(PARTITION pm1_ix VALUES LESS THAN (2)
PARTITION pm2_ix VALUES LES
S THAN (3)
PARTITION pm3_ix VALUES LESS THAN (4)
PARTITION pm4_ix VALUES LESS THAN (5)
PARTITION pm5_ix VALUES L
ESS THAN (6)
PARTITION pm6_ix VALUES LESS THAN (7)
PARTITION pm7_ix VALUES LESS THAN (8)
PARTITION pm8_ix VALUES
LESS THAN (9)
PARTITION pm9_ix VALUES LESS THAN (10)
PARTITION pm10_ix VALUES LESS THAN (11)
PARTITION pm11_ix
VALUES LESS THAN (12)
PARTITION pm12_ix VALUES LESS THAN (MAXVALUE));
|
Note: If your enterprise has or will have databases using different character sets, use caution when partitioning on character columns, because the sort sequence of characters is not identical in all character sets. For more information, see Oracle Database Globalization Su pport Guide. |
The PARTITION BY HA
SH clause of the CREATE TABLE statement identifies that the table is to be hash-partitioned. The PARTITIONS clause can then be used to specify the number of partitions to create, and optionall
y, the tablespaces to store them in. Alternatively, you can use PARTITION claus
es to name the individual partitions and their tablespaces.
The only attribute you can specify for hash partitions is TA
BLESPACE. All of the hash partitions of a table must share the same segment attributes (except TABLESPACE), which
are inherited from the table level.
The following examples illustrate two methods of cre
ating a hash-partitioned table named dept. In the first example the number of partitions is specified, but system genera
ted names are assigned to them and they are stored in the default tablespace of the table.
CREATE TABLE
dept (deptno NUMBER, deptname VARCHAR(32))
PARTITION BY HASH(deptno) PARTITIONS 16;
In this second example, names o f individual partitions, and tablespaces in which they are to reside, are specified. The initial extent size for each hash partition (segment) is also explicitly stated at the table level, and all partitions inherit this attribute.
CREA
TE TABLE dept (deptno NUMBER, deptname VARCHAR(32))
STORAGE (INITIAL 10K)
PARTITION BY HASH(deptno)
(PARTITION p1 TA
BLESPACE ts1, PARTITION p2 TABLESPACE ts2,
PARTITION p3 TABLESPACE ts1, PARTITION p4 TABLESPACE ts3);
If you crea
te a local index for this table, the database constructs the index so that it is equipartitioned with the underlying table. The datab
ase also ensures that the index is maintained automatically when maintenance operations are performed on the underlying table. The fo
llowing is an example of creating a local index on the table dept:
CREATE INDEX loc_dept_ix ON dept(deptno) LOCAL;
You can optionally name the hash partitions and tablesp aces into which the local index partitions are to be stored, but if you do not do so, the database uses the name of the corresponding base partition as the index partition name, and stores the index partition in the same tablespace as the table partition.
Hash partitioned global
indexes can improve the performance of indexes where a small number of leaf blocks in the index have high contention in multiuser OLT
P environments. Queries involving the equality and IN predicates on the index partitioning key can efficiently use hash-
partitioned global indexes.
The syntax for creating a hash partitioned global index is similar to that used for a hash partiti oned table. For example, the following statement creates a hash-partitioned global index:
CREATE INDEX
hgidx ON tab (c1,c2,c3) GLOBAL
PARTITION BY HASH (c1,c2)
(PARTITION p1 TABLESPACE tbs_1,
PARTITION p2 TABLESPACE tb
s_2,
PARTITION p3 TABLESPACE tbs_3,
PARTITION p4 TABLESPACE tbs_4);
The semantics for creating list partitions are very similar to those for creating range pa
rtitions. However, to create list partitions, you specify a PARTITION BY LIST c
lause in the CREATE TABLE statement, and the PARTITION clauses spe
cify lists of literal values, which are the discrete values of the partitioning columns that qualify rows to be included in the parti
tion. For list partitioning, the partitioning key can only be a single column name from the table.
Available only with list pa
rtitioning, you can use the keyword DEFAULT
code> to describe the value list for a partition. This identifies a partition that will accommodate rows that do not map into any of
the other partitions.
As for range partitions, optional subclauses of a PARTITION clause can specify physical and
other attributes specific to a partition segment. If not overridden at the partition level, partitions inherit the attributes of the
ir parent table.
The following example creates table sales_by_region and partitions it using the list method. The
first two PARTITION clauses specify physical attributes, which override the table-level defaults. The remaining P
ARTITION clauses do not specify attributes and those partitions inherit their physical attributes from table-level defaults. A
default partition is specified.
CREATE TABLE sales_by_region (item# INTEGER, qty INTEGER,
store_name VARCHAR(30), state_code VARCHAR(2),
sale_date DATE)
STORAGE(INITIAL 10K NEXT 20K) TABLESPACE tbs5
PARTITION BY LIST (state_code)
(
PARTITION region_east
VALUES ('MA','NY','CT','NH','ME','MD','VA','PA','NJ')
STORAGE (INITIAL 20K NEXT 40K PCTINCREASE 50)
TABLESPACE tbs8,
PARTITION region_west
VALUES ('CA','AZ','NM
','OR','WA','UT','NV','CO')
PCTFREE 25 NOLOGGING,
PARTITION region_south
VALUES ('TX','KY','TN','LA','MS','AR','
AL','GA'),
PARTITION region_central
VALUES ('OH','ND','SD','MO','IL','MI','IA'),
PARTITION region_null
VAL
UES (NULL),
PARTITION region_unknown
VALUES (DEFAULT)
);
To create a range-hash partit
ioned table, you start by using the PARTITION BY RANGE clause of a CREATE
TABLE statement. Next, you specify a SUBPARTITION BY HASH clause that f
ollows similar syntax and rules as the PARTITION BY HASH clause. The individual PARTITION and SUBPARTITION or SUBPARTITIONS clauses, and optionally a SUBPARTITION TEMPLATE clause, follow.
Attributes speci
fied for a range partition apply to all subpartitions of that partition. You can specify different attributes for each range partitio
n, and you can specify a STORE IN clause at the partition level if the list of
tablespaces across which the subpartitions of that partition should be spread is different from those of other partitions. All of thi
s is illustrated in the following example.
CREATE TABLE emp (deptno NUMBER, empname VARCHAR(32), grade
NUMBER)
PARTITION BY RANGE(deptno) SUBPARTITION BY HASH(empname)
SUBPARTITIONS 8 STORE IN (ts1, ts3, ts5, ts7)
(P
ARTITION p1 VALUES LESS THAN (1000) PCTFREE 40,
PARTITION p2 VALUES LESS THAN (2000)
STORE IN (ts2, ts4, ts6, ts8),
PARTITION p3 VALUES LESS THAN (MAXVALUE)
(SUBPARTITION p3_s1 TABLESPACE ts4,
SUBPARTITION p3_s2 TABLESPACE ts5));
pre>
To learn how using a subpartition template can simplify the specification of a composite partitioned table, see "Using Subpartition Templates to Describe Composite Partitioned Tables".
The following statement is an example of
creating a local index on the emp table where the index segments are spread acr
oss tablespaces ts7, ts8, and ts9.
CREATE INDEX emp_ix ON emp(de
ptno)
LOCAL STORE IN (ts7, ts8, ts9);
This local index is equipartitioned with the base table as follows:
It consists of as many partitions as the base table.
Each index partition consists of as many subpartitions as the corresponding base table partition.
Index entries for rows in a given subp artition of the base table are stored in the corresponding subpartition of the index.
The concept
of range-list partitioning is similar to that of the other composite partitioning method, range-hash, but this time you specify that
the subpartitions are to be list rather than hash. Specifically, after the CREATE TABLE ... PARTITION BY RANGE clause, you include a SUBPARTITION BY LIST clau
se that follows similar syntax and rules as the PARTITION BY LIST clause. The individual PARTITION and SUBPARTITION clauses, and optionally a
The range partitions of the composite partitioned table are described as for n
oncomposite range partitioned tables. This allows that optional subclauses of a PARTITION clause can specify physical an
d other attributes, including tablespace, specific to a partition segment. If not overridden at the partition level, partitions inher
it the attributes of their underlying table.
The list subpartition descriptions, in the SUBPARTITION clauses, are
described as for noncomposite list partitions, except the only physical attribute that can be specified is a tablespace (optional).
Subpartitions inherit all other physical attributes from the partition description.
The following example of creates a table t hat specifies a tablespace at the partition and subpartition levels. The number of subpartitions within each partition varies, and de fault subpartitions are specified.
CREATE TABLE sample_regional_sales
(deptno number, item_no var
char2(20),
txn_date date, txn_amount number, state varchar2(2))
PARTITION BY RANGE (txn_date)
SUBPARTITION BY LIST (stat
e)
(PARTITION q1_1999 VALUES LESS THAN (TO_DATE('1-APR-1999','DD-MON-YYYY'))
TABLESPACE tbs_1
(SUBPARTITION
q1_1999_northwest VALUES ('OR', 'WA'),
SUBPARTITION q1_1999_southwest VALUES ('AZ', 'UT', 'NM'),
SUBPARTITION q1_
1999_northeast VALUES ('NY', 'VM', 'NJ'),
SUBPARTITION q1_1999_southeast VALUES ('FL', 'GA'),
SUBPARTITION q1_oth
ers VALUES (DEFAULT) TABLESPACE tbs_4
),
PARTITION q2_1999 VALUES LESS THAN ( TO_DATE('1-JUL-1999','DD-MON-YYYY'))
TABLESPACE tbs_2
(SUBPARTITION q2_1999_northwest VALUES ('OR', 'WA'),
SUBPARTITION q2_1999_southwest VALUE
S ('AZ', 'UT', 'NM'),
SUBPARTITION q2_1999_northeast VALUES ('NY', 'VM', 'NJ'),
SUBPARTITION q2_1999_southeast VA
LUES ('FL', 'GA'),
SUBPARTITION q2_1999_northcentral VALUES ('SD', 'WI'),
SUBPARTITION q2_1999_southcentral VALUE
S ('OK', 'TX')
),
PARTITION q3_1999 VALUES LESS THAN (TO_DATE('1-OCT-1999','DD-MON-YYYY'))
TABLESPACE tbs_3
(SUBPARTITION q3_1999_northwest VALUES ('OR', 'WA'),
SUBPARTITION q3_1999_southwest VALUES ('AZ', 'UT', 'NM'),
SUBPARTITION q3_others VALUES (DEFAULT) TABLESPACE tbs_4
),
PARTITION q4_1999 VALUES LESS THAN ( TO_DATE('1-J
AN-2000','DD-MON-YYYY'))
TABLESPACE tbs_4
);
This example results in the following subpartition descripti ons:
All subpartitions inherit their physical attributes, other than tablespace, from tablespace level d efaults. This is because the only physical attribute that has been specified for partitions or subpartitions is tablespace. There are no table level physical attributes specified, thus tablespace level defaults are inherited at all levels.
The first 4 subpartitions of partition q1_1999 are all contained in tbs_1, except for the subpartition <
code>q1_others, which is stored in tbs_4 and contains all rows that do not map to any of the other partitions.
The 6 subpartitions of partition q2_1999 are all stored in tbs_2.
The first 2 subpartitions of partition q3_1999 are all contained in tbs_3, except for the su
bpartition q3_others, which is stored in tbs_4 and contains all rows that do not map to any of the other pa
rtitions.
There is no subpartition description for partition q4_1999. This results in one d
efault subpartition being created and stored in tbs_4. The subpartition name is system generated in the form SYS_S
UBPn.
To learn how using a subpartition template can simplify the specification of a co mposite partitioned table, see "Using Subpartition Templates to Describe Composite Partitioned Tables".
div>You can create subpartitions in a composi te partitioned table using a subpartition template. A subpartition template simplifies the specification of subpartitions by not requ iring that a subpartition descriptor be specified for every partition in the table. Instead, you describe subpartitions only once in a template, then apply that subpartition template to every partition in the table.
The subpartition template is used whenever a subpartition descriptor is not specified for a partition. If a subpartition descriptor is specified, then it is used instead of the subpartition template for that partition. If no subpartition template is specified, and no subpartition descriptor is supplied for a partition, then a single default subpartition is created.
In the case of range-hash partitioned tables, the subpartition template can describe t he subpartitions in detail, or it can specify just the number of hash subpartitions.
The following example creates a range-has h partitioned table using a subpartition template:
CREATE TABLE emp_sub_template (deptno NUMBER, empnam
e VARCHAR(32), grade NUMBER)
PARTITION BY RANGE(deptno) SUBPARTITION BY HASH(empname)
SUBPARTITION TEMPLATE
(SU
BPARTITION a TABLESPACE ts1,
SUBPARTITION b TABLESPACE ts2,
SUBPARTITION c TABLESPACE ts3,
SUBPARTITION
d TABLESPACE ts4
)
(PARTITION p1 VALUES LESS THAN (1000),
PARTITION p2 VALUES LESS THAN (2000),
PARTITION p3
VALUES LESS THAN (MAXVALUE)
);
This example produces the following table description:
Ev ery partition has four subpartitions as described in the subpartition template.
Each subpartition has a tablespace specified. It is required that if a tablespace is specified for one subpartition in a subpartition template, then one must be specified for all.
The names of the subpartitions are generated by concatenating the partition name with the subpartition name in the form:
partition name_subpartition name
The following quer y displays the subpartition names and tablespaces:
SQL> SELECT TABLESPACE_NAME, PARTITION_NAME, SUBP
ARTITION_NAME
2 FROM DBA_TAB_SUBPARTITIONS WHERE TABLE_NAME='EMP_SUB_TEMPLATE'
3 ORDER BY TABLESPACE_NAME;
TABLESPACE_NAME PAR
TITION_NAME SUBPARTITION_NAME
--------------- --------------- ------------------
TS1 P1 P1_A
TS1
P2 P2_A
TS1 P3 P3_A
TS2 P1 P1_B
TS2 P2 P2_B
TS2 P3 P3_B
TS3 P1 P1_C
TS3 P2 P2_C
TS3 P3
P3_C
TS4 P1 P1_D
TS4 P2 P2_D
TS4 P3 P3_D
12 ro
ws selected.
The following example, for a range-list partitioned table, illustrates how using a subpartition tem plate can help you stripe data across tablespaces. In this example a table is created where the table subpartitions are vertically st riped, meaning that subpartition n from every partition is in the same tablespace.
CREATE TABL
E stripe_regional_sales
( deptno number, item_no varchar2(20),
txn_date date, txn_amount number, state varc
har2(2))
PARTITION BY RANGE (txn_date)
SUBPARTITION BY LIST (state)
SUBPARTITION TEMPLATE
(SUBPARTITION northwest VAL
UES ('OR', 'WA') TABLESPACE tbs_1,
SUBPARTITION southwest VALUES ('AZ', 'UT', 'NM') TABLESPACE tbs_2,
SUBPARTITION nort
heast VALUES ('NY', 'VM', 'NJ') TABLESPACE tbs_3,
SUBPARTITION southeast VALUES ('FL', 'GA') TABLESPACE tbs_4,
SUBPARTI
TION midwest VALUES ('SD', 'WI') TABLESPACE tbs_5,
SUBPARTITION south VALUES ('AL', 'AK') TABLESPACE tbs_6,
SUBPARTITIO
N others VALUES (DEFAULT ) TABLESPACE tbs_7
)
(PARTITION q1_1999 VALUES LESS THAN ( TO_DATE('01-APR-1999','DD-MON-YYYY')),
PARTITION q2_1999 VALUES LESS THAN ( TO_DATE('01-JUL-1999','DD-MON-YYYY')),
PARTITION q3_1999 VALUES LESS THAN ( TO_DATE('01-OCT-
1999','DD-MON-YYYY')),
PARTITION q4_1999 VALUES LESS THAN ( TO_DATE('1-JAN-2000','DD-MON-YYYY'))
);
If you specified
the tablespaces at the partition level (for example, tbs_1 for partition q1_1999, tbs_2 for p
artition q1_1999, tbs_3 for partition q3_1999, and tbs_4 for partition q4_1
999) and not in the subpartition template, then the table would be horizontally striped. All subpartitions would be in the tab
lespace of the owning partition.
For range- and hash-partitioned tables, you can specify up
to 16 partitioning key columns. Multicolumn partitioning should be used when the partitioning key is composed of several columns and
subsequent columns define a higher granularity than the preceding ones. The most common scenario is a decomposed DATE o
r TIMESTAMP key, consisting of separated columns, for year, month, and day.
In evaluating multicolumn partitionin g keys, the database uses the second value only if the first value cannot uniquely identify a single target partition, and uses the t hird value only if the first and second do not determine the correct partition, and so forth. A value cannot determine the correct pa rtition only when a partition bound exactly matches that value and the same bound is defined for the next partition. The nth column will therefore be investigated only when all previous (n-1) values of the multicolumn key exactly match the (n-1) bounds of a partition. A second column, for example, will be evaluated only if the first column exactly matches the partition boundary value. If all column values exactly match all of the bound values for a partition, the database will determine that the row does not fit in this partition and will consider the next partition for a match.
In the case of nondeterministic boundary definitions (success ive partitions with identical values for at least one column), the partition boundary value becomes an inclusive value, representing a "less than or equal to" boundary. This is in contrast to deterministic boundaries, where the values are always regarded as "less th an" boundaries.
The following example illustrates the column evaluation for a multicolumn range-partitioned table, storing the
actual DATE information in three separate columns: year, month, and date. The pa
rtitioning granularity is a calendar quarter. The partitioned table being evaluated is created as follows:
CREATE TABLE sales_demo ( year NUMBER, month NUMBER, day NUMBER, amount_sold NUMBER) P ARTITION BY RANGE (year,month) (PARTITION before2001 VALUES LESS THAN (2001,1), PARTITION q1_2001 VALUES LESS THAN (2001,4), PARTITION q2_2001 VALUES LESS THAN (2001,7), PARTITION q3_2001 VALUES LESS THAN (2001,10), PARTITION q4_2001 VALUE S LESS THAN (2002,1), PARTITION future VALUES LESS THAN (MAXVALUE,0)); REM 12-DEC-2000 INSERT INTO sales_demo VALUES(2000,12 ,12, 1000); REM 17-MAR-2001 INSERT INTO sales_demo VALUES(2001,3,17, 2000); REM 1-NOV-2001 INSERT INTO sales_demo VALUES(2001,11,1, 5000); REM 1-JAN-2002 INSERT INTO sales_demo VALUES(2002,1,1, 4000);
The year value for 12-DEC-2000 satisfied the first
partition, before2001, so no further evaluation is needed:
SELECT * FROM sales_demo PARTI
TION(before2001);
YEAR MONTH DAY AMOUNT_SOLD
---------- ---------- ---------- -----------
2000 12
12 1000
The information for 17-MAR-2001 is stored in partition q1_2001. The first partitioning
key column, year, does not by itself determine the correct partition, so the second partition key column, month, must be evaluated.
SELECT * FROM sales_demo PARTITION(q1_2001);
YEAR MONTH DAY
AMOUNT_SOLD
---------- ---------- ---------- -----------
2001 3 17 2000
Following the same
determination rule as for the previous record, the second column, month, determines partition q4_2001 as c
orrect partition for 1-NOV-2001:
SELECT * FROM sales_demo PARTITION(q4_2001);
YEAR MONTH
DAY AMOUNT_SOLD
---------- ---------- ---------- -----------
2001 11 1 5000
The partit
ion for 01-JAN-2002 is determined by evaluating only the year column, which indicates the future partition:
SELECT * FROM sales_demo PARTITION(future);
YEAR MONTH DAY AMOUNT_SOLD
---------- -
--------- ---------- -----------
2002 1 1 4000
If the database encounters MAXVALUE
code> in one of the partition key columns, all other values of subsequent columns become irrelevant. That is, a definition of partiti
on future in the preceding example, having a bound of (MAXVALUE,0) is equivalent to a bound of (MAXVA
LUE,100) or a bound of (MAXVALUE,MAXVALUE).
The following example illustrates the use of a mu
lticolumn partitioned approach for table supplier_parts, storing the information about which suppliers deliver which par
ts. To distribute the data in equal-sized partitions, it is not sufficient to partition the table based on the supplier_id, because some suppliers might provide hundreds of thousands of parts, while others provide only a few specialty parts. Instead, yo
u partition the table on (supplier_id, partnum) to manually enforce equal-sized partitions.
CREATE TABLE supplier_parts ( supplier_id NUMBER, partnum NUMBER, price NUMBER) PAR TITION BY RANGE (supplier_id, partnum) (PARTITION p1 VALUES LESS THAN (10,100), PARTITION p2 VALUES LESS THAN (10,200), PART ITION p3 VALUES LESS THAN (MAXVALUE,MAXVALUE));
The following three records are inserted into the table:
INSERT INTO supplier_parts VALUES (5,5, 1000); INSERT INTO supplier_parts VALUES (5,150, 1000); INSERT INTO supplier_pa rts VALUES (10,100, 1000);
The first two records are inserted into partition p1, uniquely identified by p2; it matches all range boundary values of p
artition p1 exactly and the database therefore considers the following partition for a match. The value of partnum
satisfies the criteria < 200, so it is inserted into partition p2.
SELECT * FRO
M supplier_parts PARTITION (p1);
SUPPLIER_ID PARTNUM PRICE
----------- ---------- ----------
5 5 10
00
5 150 1000
SELECT * FROM supplier_parts PARTITION (p2);
SUPPLIER_ID PARTNUM PRICE
----------- ---
------- ----------
10 100 1000
Every row with supplier_id < 10 will be stored in pa
rtition p1, regardless of the partnum value. The column partnum will be evaluated only if p1, p2, or even into <
code>p3 when partnum >=200. To achieve equal-sized partitions for ranges of supplier_parts, you c
ould choose a composite range-hash partitioned table, range partitioned by supplier_id, hash subpartitioned by par
tnum.
Defining the partition boundaries for multicolumn partitioned tables must obey some rules. For example, consider
a table that is range partitioned on three columns a, b, and c. The individual partitions have
range values represented as follows:
P0(a0, b0, c0) P1(a1, b1, c1) P2(a2, b2, c2) … Pn(an, bn, cn)
The range values you provide for each partition must follow these rules:
a0
must be less than or equal to a1, and a1 must be less than or equal to a2, and so on.
If a0=a1, then b0 must be less than or equal to b1. If a1, then b0 and b1 can have any values. If b0=b1, t
hen c0 must be less than or equal to c1. If b0<b1, then c0 and
If a1=a2, then b1 m
ust be less than or equal to b2. If a1<a2, then b1 and b2 can hav
e any values. If b1=b2, then c1 must be less than or equal to c2. If b1<b2, then c0 and c1 can have any values, and so on.
For heap-organized partitioned ta bles, you can compress some or all partitions using table compression. The compression attribute can be declared for a tablespace, a table, or a partition of a table. Whenever the compress attribute is not specified, it is inherited like any other storage attribute.
The following example creates a list-partitioned table with one compressed partition costs_old. The compression
attribute for the table and all other partitions is inherited from the tablespace level.
CREATE TABLE c
osts_demo (
prod_id NUMBER(6), time_id DATE,
unit_cost NUMBER(10,2), unit_price NUMBER(10,2))
PARTITION BY RANGE
(time_id)
(PARTITION costs_old
VALUES LESS THAN (TO_DATE('01-JAN-2003', 'DD-MON-YYYY')) COMPRESS,
PARTITION costs_q1_
2003
VALUES LESS THAN (TO_DATE('01-APR-2003', 'DD-MON-YYYY')),
PARTITION costs_q2_2003
VALUES LESS THAN (TO_DATE('
01-JUN-2003', 'DD-MON-YYYY')),
PARTITION costs_recent VALUES LESS THAN (MAXVALUE));
You can compress some or all partitions of a B-tr ee index using key compression. Key compression is applicable only to B-tree indexes. Bitmap indexes are stored in a compressed manne r by default. Index using key compression eliminates repeated occurrences of key column prefix values, thus saving space and I/O.
The following example crates a local partitioned index with all partitions except the most recent one compressed:
CREATE INDEX i_cost1 ON costs_demo (prod_id) COMPRESS LOCAL
(PARTITION costs_old, PARTITION costs_q1_2003,
PAR
TITION costs_q2_2003, PARTITION costs_recent NOCOMPRESS);
You cannot specify COMPRESS (or NOCOMPRESS
code>) explicitly for an index subpartition. All index subpartitions of a given partition inherit the key compression setting from th
e parent partition.
To modify the key compression attribute for all subpartitions of a given partition, you must first issue a
n ALTER INDEX ... MODIFY PARTITION statement and then rebuild all subpartitions. The MODIFY PARTITION claus
e will mark all index subpartitions as UNUSABLE.
For index-organized tables, you can use the range, list, or hash partitioning method. The semantics for creating partitioned index-or ganized tables is similar to that for regular tables with these differences:
When you create the table y
ou specify the ORGANIZATION INDEX clause, and INCLUDING and OVERFLOW clauses as necessary.
The PARTITION or PARTITIONS clauses can have OVERFLOW subclauses tha
t allow you to specify attributes of the overflow segments at the partition level.
Specifying an OVERFLOW clause results in the overflow data segments themselves being equipartitioned with the primary key index segments. Thus, for parti
tioned index-organized tables with overflow, each partition has an index segment and an overflow data segment.
For index-organ ized tables, the set of partitioning columns must be a subset of the primary key columns. Since rows of an index-organized table are stored in the primary key index for the table, the partitioning criterion has an effect on the availability. By choosing the partitio n key to be a subset of the primary key, an insert operation only needs to verify uniqueness of the primary key in a single partition , thereby maintaining partition independence.
Support for secondary indexes on index-organized tables is similar to the suppor t for regular tables. Because of the logical nature of the secondary indexes, global indexes on index-organized tables remain usable for certain operations where they would be marked UNUSABLE for regular tables.
|
See Also:
|
You can partition index-organized tables, and their secondary indexes, by the range method. In the following example, a range-partit
ioned index-organized table sales is created. The INCLUDING clause specifies all columns after week_n
o are stored in an overflow segment. There is one overflow segment for each partition, all stored in the same tablespace (OVERFLOW TABLESPACE could be specified at the individual partition level, in which
case some or all of the overflow segments could have separate TABLESPACE attributes.
CREAT
E TABLE sales(acct_no NUMBER(5),
acct_name CHAR(30),
amount_of_sale NUMBER(6),
week_no INTEGER,
sale_details VARCHAR2(1000),
PRIMARY KEY (acct_no, acct_name, week_no))
ORGANIZATION INDEX
INCLUDING week_no
OVERFLOW TABLESPACE overflow_here
PARTITION BY RANGE (week_no)
(PARTITION VALUES LESS THAN (5)
TABLESPACE ts1,
PARTITION VALUES LESS THAN (9)
TABLESPACE ts2 OVERFLOW TABLESPACE overflow_ts2,
...
PARTITION VALUES LESS THAN (MAXVALUE)
TABLESPACE ts13);
Another o
ption for partitioning index-organized tables is to use the list method. In the following example the index-organized table, sales
, is partitioned by the list method. This example uses the example tablespace, which is part of the sample schemas in yo
ur seed database. Normally you would specify different tablespace storage for different partitions.
CRE
ATE TABLE sales(acct_no NUMBER(5),
acct_name CHAR(30),
amount_of_sale NUMBER(6),
week_no INTEGER,
sale_details VARCHAR2(1000),
PRIMARY KEY (acct_no, acct_name, week_no))
ORGANIZATION INDEX
INCLUDING week_no
OVERFLOW TABLESPACE example
PARTITION BY LIST (week_no)
(PARTITION VALUES (1, 2, 3, 4)
TABLESPACE example,
PARTITION VALUES (5, 6, 7, 8)
TABLESPACE example OVERFLOW TABLESPACE example,
PARTITION VALUES (DEFAULT)
TABLESPACE example
);
The other option for partitioning index-organize
d tables is to use the hash method. In the following example the index-organized table, sales, is partitioned by the has
h method.
CREATE TABLE sales(acct_no NUMBER(5),
acct_name CHAR(30),
amount_of_sale NUMBER(6),
week_no INTEGER,
sale_details VARCHAR2(1000),
PRIM
ARY KEY (acct_no, acct_name, week_no))
ORGANIZATION INDEX
INCLUDING week_no
OVERFLOW
PARTITION BY
HASH (week_no)
PARTITIONS 16
STORE IN (ts1, ts2, ts3, ts4)
OVERFLOW STORE IN (ts3, ts6, ts9);
|
Note: A well-designed hash function is intended to distribute rows in a well-balanced fashion among the partitions. Therefore, updating the primary key co lumn(s) of a row is very likely to move that row to a different partition. Oracle recommends that you explicitly specify theRO
W MOVEMENT ENABLE clause when creating a hash-partitioned index-organized table with a changeable partitioning key. The defaul
t is that ROW MOVEMENT ENABLE is disabled. |
Use caution when creating partitioned objects in a database with tablespaces of multiple block size. The storage of partitioned objects in such tablespaces is subject to some restrictions. Specifically, all partitions of the following entities must reside in tablespaces of the same block size:
Conventional tables
Indexes< /p>
Primary key index segments of index-organized tables
Overflow segments of i ndex-organized tables
LOB columns stored out of line
Therefore:
For each conventional table, all partitions of that table must be stored in tablespaces with the same block size.< /p>
For each index-organized table, all primary key index partitions must reside in tablespaces of the same block size, and all overflow partitions of that table must reside in tablespaces of the same block size. However, index partitions an d overflow partitions can reside in tablespaces of different block size.
For each index (global or local ), each partition of that index must reside in tablespaces of the same block size. However, partitions of different indexes defined o n the same object can reside in tablespaces of different block sizes.
For each LOB column,
each partition of that column must be stored in tablespaces of equal block sizes. However, different LOB columns can be
stored in tablespaces of different block sizes.
When you create or alter a partitioned table or index, all tablespac es you explicitly specify for the partitions and subpartitions of each entity must be of the same block size. If you do not explicitly specify tablespace storage for an entity, the tablespaces the database uses by default must be of the same block size. Therefore you must be aware of the default tablespaces at each level of the partitioned object.
This section describes how to perfo rm partition and subpartition maintenance operations for both tables and indexes.
Table 16-1 lists mai
ntenance operations that can be performed on table partitions (or subpartitions) and, for ea
ch type of partitioning, lists the specific clause of the ALTER TABLE statement that is used to perform that maintenance operation.
Table 16-1 ALTER TABLE Maintenance Operations for Table Partitions
| Maintenance Operation | Range | Hash | List | Composite: Range/Hash | Composite: Range/List |
|---|---|---|---|---|---|
| Adding Partitions |
ADD PARTITION |
ADD PARTITION<
/td>
| ADD PARTITION |
ADD
PARTITION
|
ADD
PARTITION
|
| Coalescing Partitions |
n/a | COALESCE PARTITION |
n /a | MODIFY PARTITION ... COALESCE SUBPARTITION |
n/a |
| Dropping Partitions |
DROP PARTITION |
n/a | DROP PARTITION |
DROP PARTITION |
DROP PARTITION
|
| Exchanging Partitions |
EXCHANGE PARTITION |
EXCHANGE PARTITION |
EXCHANGE PARTITI
ON |
EXCHANGE PARTITION
| EXCHANGE PARTITION
|
| Merging Partitions |
MERGE PARTITIONS |
n/a | MERGE PARTITIONS |
MERGE PAR
TITIONS |
MERGE PARTITIONS
|
| Modifying Default Attri butes | MODIFY DEFAULT ATTRIBUTES |
MODIFY DEFAULT ATTRIBUTES |
MODIFY DEFAULT ATTRIBUTES |
MODIFY DEFAULT ATTRIBUTES
|
MODIFY DEFAULT ATTRIBUTES
|
| Modifying Real Attributes of Partitions |
MODIFY PARTITION
code> |
MODIFY PARTITION |
< code>MODIFY PARTITION | MODIFY PARTITION
|
MODIFY PARTITION
|
| Modifying List Partitio
ns: Adding Values |
n/a | n/a td> | MODIFY PARTITION...ADD VALUES |
n/a | MODIFY SUBPARTITION ... ADD VALUES |
| Modifying List Partitions: Dropping Values |
n/a | n/a | MODIFY PARTITION...DROP VALUES |
n/a | MODIFY SUBPARTITION ... DROP VALUES |
| Modifying a Subpartition Template |
n/a | n/a | n/a< /td> | SET SUBPARTITION TEMPLATE |
SET SUBPARTITION TEMPLATE |
|
Moving Partitions |
MOVE PARTITION |
MOVE PARTITION |
MOVE PART
ITION |
MOVE SUBPARTITION |
MOVE SUBPARTITION |
| Renaming Partitions |
RENAME PARTITION |
RENAME
PARTITION |
RENAME PARTITION
|
RENAME PARTITION
| |
| Splitting Partitions < /td> | SPLIT PARTITION |
n/a | SPLIT PARTITION |
SP
LIT PARTITION |
SPLIT PARTITION
|
| Truncating Partit
ions |
TRUNCATE PARTITION |
TRUNCATE PARTITION |
TRUNCATE PARTITION |
TRUNCATE PARTITION
|
TRUNCATE PARTITION
|
These actions are independent of whether any partitions contain data and of the operation that introduces the compressed partition. This does not apply to partitioned tables with B-tree indexes or to partitioned index-organized tables. For more information, see the Oracle Data Warehousing Guide. | ||||
| Mainten ance Operation | Type of Index | Type of Index Partitioning | ||
|---|---|---|---|---|
| Range | Hash a nd List | Composite | ||
| Adding Index Partitions |
Global | - |
ADD PARTITION (hash only) |
- |
| Local | n/a | n/a | n/a | |
| Dropping Index Partitions |
Global | DROP PARTITION |
- | - |
| Local | n/a | n/a | n/a | |
| Modifying
Default Attributes of Index Partitions |
Global | MODIFY DEFAULT ATTRIBUTES |
-< /td> | - |
| Local | MODIFY DEFAULT ATTRIBUTES
|
MODIFY DEFAULT ATTRIBUTES |
MODIFY DEFAULT ATTRIBUTES
| |
| Modifying Real Attributes of Index Partitions |
Global | MODIFY PARTITION |
- | - |
| Local | MODIFY PARTITION |
MODIFY PARTITION |
MODIFY PARTITION
| |
| Rebuilding Index Partitions
|
Global | REBUILD PARTITION |
- | - |
| Local | REBUILD PARTITION |
REBUILD PARTITION |
REBUILD
SUBPARTITION | |
|
Renaming Index Partitions |
Global | RENAME PARTITION |
-< /td> | - |
| Local | RENAME PARTITION |
RENAME PARTITION |
RENAME PARTITION
| |
| Splitting Index Partitions
|
Global | SPLIT PARTITION |
- | - |
| Local | n/a | n/ a | n/a | |
|
Note: The followin g sections discuss maintenance operations on partitioned tables. Where the usability of indexes or index partitions affected by the m aintenance operation is discussed, consider the following:
|
Before discussing the individual maintenance operations for partitioned tables and indexes, it is important to discuss the
effects of the UPDATE INDEXES clause that can be specified in the ALTER TABLE sta
tement.
By default, many table maintenance operations on partitioned tables invalidate (mark UNUSABLE) the corres
ponding indexes or index partitions. You must then rebuild the entire index or, in the case of a global index, each of its partitions
. The database lets you override this default behavior if you specify UPDATE INDEXES in your ALTER TABLE statement for the maintenance operation. Specifying this clause tells the database to update the index at the time it e
xecutes the maintenance operation DDL statement. This provides the following benefits:
The index is upda ted in conjunction with the base table operation. You are not required to later and independently rebuild the index.
The index is more highly available, because it does not get marked UNUSABLE. The index remains available ev
en while the partition DDL is executing and it can be used to access unaffected partitions in the table.
You need not look up the names of all invalid indexes to rebuild them.
Optional clauses for local indexes let you s pecify physical and storage characteristics for updated local indexes and their partitions.
You can spec
ify physical attributes, tablespace storage, and logging for each partition of each local index. Alternatively, you can specify only
the PARTITION keyword and let the database update the as follows
For operations on a sing
le table partition (such as MOVE PARTITION and SPLIT PARTITION), the correspondin
g index partition inherits the attributes of the affected index partition. The database does not generate names for new index partiti
ons, so any new index partitions resulting from this operation inherit their names from the corresponding new table partition.
For MERGE PARTITION operations, the resulting local index partition inherits its n
ame from the resulting table partition and inherits its attributes from the local index.
For a composite-partitioned index, you can specify tablespace storage for each subpartition.
The following operations support the UP
DATE INDEXES clause:
ADD PARTITION | SUBPARTITION
COALESCE PARTITION | SUBPARTITION
DROP PARTITION | SUBPARTITION
EXCHANGE PART
ITION | SUBPARTITION
MERGE PARTITION | SUBPARTITION<
/code>
MOVE PARTITION | SUBPARTITION
SPLIT PARTITION | SUBPARTITION
TRUNCATE PARTI
TION | SUBPARTITION
The SKIP_UNUSABLE_INDEXES, which in earlier releases was a session par
ameter, is now an initialization parameter with a default value of TRUE. This setting disables error reporting of indexe
s and index partitions marked UNUSABLE. If you do not want the database to choose an alternative execution plan to avoid
the unusable elements, you should set this parameter to FALSE.
The following performance implications are worth not
ing when you specify UPDATE INDEXES:
The partition DDL statement takes longer
to execute, because indexes that were previously marked UNUSABLE are updated. However, you must compare this increase wi
th the time it takes to execute DDL without updating indexes, and then rebuild all indexes. A rule of thumb is that it is faster to u
pdate indexes if the size of the partition is less that 5% of the size of the table.
The DROP, TRUNCATE, and EXCHANGE operations are no longer fast operations. Again, you must compare the time it ta
kes to do the DDL and then rebuild all indexes.
When you update a table with a global index:
The index is updated in place. The updates to the index are logged, and redo and undo records are generated. In c
ontrast, if you rebuild an entire global index, you can do so in NOLOGGING mode.
Rebuildi ng the entire index manually creates a more efficient index, because it is more compact with space better utilized.
This section describes how to add new partitions to a partitioned table and explains why partitions cannot be specifically add ed to most partitioned indexes.
Use
the ALTER TABLE ... ADD PARTITION statem
ent to add a new partition to the "high" end (the point after the last existing partition). To add a partition at the beginning or in
the middle of a table, use the SPLIT PARTITION clause.
For
example, consider the table, sales, which contains data for the current month in addition to the previous 12 months. On
January 1, 1999, you add a partition for January, which is stored in tablespace tsx.
ALTE
R TABLE sales
ADD PARTITION jan96 VALUES LESS THAN ( '01-FEB-1999' )
TABLESPACE tsx;
Local and global indexe s associated with the range-partitioned table remain usable.
When you add a partition to a hash-partitioned table, the database populates the new partition with rows rehashed from an existing partition (selected by the database) as determined by the hash function.
Th
e following statements show two ways of adding a hash partition to table scubagear. Choosing the first statement adds a
new hash partition whose partition name is system generated, and which is placed in the table default tablespace. The second statemen
t also adds a new hash partition, but that partition is explicitly named p_named and is created in tablespace gear
5.
ALTER TABLE scubagear ADD PARTITION;
ALTER TABLE scubagear
ADD PARTITION p_named TABLE
SPACE gear5;
Indexes may be marked UNUSABLE as explained in the fol
lowing table:
| Table Typ e | Index Behavio r |
|---|---|
| Regular (Heap) | Unless you specify UPDATE INDEXES as part of the <
code>ALTER TABLE statement:
|
| Index-organized |
|
The following sta
tement illustrates adding a new partition to a list-partitioned table. In this example physical attributes and NOLOGGING
are specified for the partition being added.
ALTER TABLE q1_sales_by_region
ADD PARTITION q1_nonma
inland VALUES ('HI', 'PR')
STORAGE (INITIAL 20K NEXT 20K) TABLESPACE tbs_3
NOLOGGING;
Any value in the set of literal values that describe the partition being added must not exist in any of the other partitions of the table.
You cannot add a partition to a list-partitioned table that has a default partition, but you can split the default partition. By doing so, you effectively create a new partition defined by the values that you specify, and a second partition that remains the default partition.
Local and global indexes associated with the list-partitioned table remain usable.
Partitions can be added at both the range partition level and the hash sub partition level.
Adding a new range partition to a range-has
h partitioned table is as described previously in "Adding a Partition to a Range-Partitioned Table". However,
you can specify a SUBPARTITIONS clause that lets you add a specified number of
subpartitions, or a SUBPARTITION clause for naming specific subpartitions. If
no SUBPARTITIONS or SUBPARTITION clause is specified, the partition inherits table level defaults for subpa
rtitions.
This example adds a range partition q1_2000 to table sales, which will be populated with d
ata for the first quarter of the year 2000. There are eight subpartitions stored in tablespace tbs5. The subpartitions c
annot be set explicitly to use table compression. Subpartitions inherit the compression attribute from the partition level and are st
ored in a compressed form in this example:
ALTER TABLE sales ADD PARTITION q1_2000
VALUES LESS TH
AN (2000, 04, 01) COMPRESS
SUBPARTITIONS 8 STORE IN tbs5;
You use the MODIF
Y PARTITION ... ADD SUBPARTITION clause of the
ALTER TABLE statement to add a hash subpartition to a range-hash partitioned table. The newly added subpar
tition is populated with rows rehashed from other subpartitions of the same partition as determined by the hash function.
In t
he following example, a new hash subpartition us_loc5, stored in tablespace us1, is added to range partitio
n locations_us in table diving.
ALTER TABLE diving MODIFY PARTITION locations
_us
ADD SUBPARTITION us_locs5 TABLESPACE us1;
Index subpartitions corresponding to the added and rehashed subpartit
ions must be rebuilt unless you specify UPDATE INDEXES.
Partitions can be added at both the range partition level and t he list subpartition level.
Adding a new range partition to a range-li
st partitioned table is as described previously in "Adding a Partition to a Range-Partitioned Table". However
, you can specify SUBPARTITION clauses for naming and providing value lists for
the subpartitions. If no SUBPARTITION clauses are specified, then the partition inherits the subpartition template. If
there is no subpartition template, then a single default subpartition is created.
This following statement statements adds a n
ew partition to the quarterly_regional_sales table that is partitioned by the range-list method. Some new physical attri
butes are specified for this new partition while table-level defaults are inherited for those that are not specified.
ALTER TABLE quarterly_regional_sales
ADD PARTITION q1_2000 VALUES LESS THAN (TO_DATE('1-APR-2000','DD-MON-YYYY'))
STORAGE (INITIAL 20K NEXT 20K) TABLESPACE ts3 NOLOGGING
(
SUBPARTITION q1_2000_northwest VALUES ('OR', 'WA')
,
SUBPARTITION q1_2000_southwest VALUES ('AZ', 'UT', 'NM'),
SUBPARTITION q1_2000_northeast VALUES ('NY', 'VM', 'N
J'),
SUBPARTITION q1_2000_southeast VALUES ('FL', 'GA'),
SUBPARTITION q1_2000_northcentral VALUES ('SD', 'WI'),
SUBPARTITION q1_2000_southcentral VALUES ('OK', 'TX')
);
You use the MODIFY PARTITION ... ADD SUBPARTITION clause of the ALTER TA
BLE statement to add a list subpartition to a range-list partitioned table.
The following statement adds a new subparti
tion to the existing set of subpartitions in range-list partitioned table quarterly_regional_sales. The new subpartition
is created in tablespace ts2.
ALTER TABLE quarterly_regional_sales
MODIFY PARTITION q1
_1999
ADD SUBPARTITION q1_1999_south
VALUES ('AR','MS','AL') tablespace ts2;
You cannot explicitly add a partition to a local index. Instead, a new partition is added to a local index only when you add a pa
rtition to the underlying table. Specifically, when there is a local index defined on a table and you issue the ALTER ADD PA
RTITION operation is complete.
You can effectively specify a new tablespace for an index partition in an ADD PARTITION operation by first modifying the default attributes for the index. For example, assume that a local index,
q1_sales_by_region_locix, was created for list partitioned table q1_sales_by_region. If before adding the n
ew partition q1_nonmainland, as shown in "Adding a Partition to a List-Partitioned Table", you h
ad issued the following statement, then the corresponding index partition would be created in tablespace tbs_4.
ALTER INDEX q1_sales_by_region_locix MODIFY DEFAULT ATTRIBUTES TABLESPACE tbs_4;
Otherwise, it w
ould be necessary for you to use the following statement to move the index partition to tbs_4 after adding it:
ALTER INDEX q1_sales_by_region_locix REBUILD PARTITION q1_nonmainland TABLESPACE tbs_4;
You can
add a partition to a hash-partitioned global index using the ADD PARTITION syntax of ALTER hgidx shown in "Creating a Hash-Partitioned Global Index":
ALTER INDEX hgidx ADD PARTITION p5; < /pre>You cannot add a partition to a range-partitioned global index, because the highest partition always has a partition bound of
MAXVALUE. If you want to add a new highest partition, use theALTERINDEX...SPLIT code>PARTITIONstatement.
Coalescing partitions is a way of reducing the number o f partitions in a hash-partitioned table or index, or the number of subpartitions in a range-hash partitioned table. When a hash part ition is coalesced, its contents are redistributed into one or more remaining partitions determined by the hash function. The specifi c partition that is coalesced is selected by the database, and is dropped after its contents have been redistributed.
Index pa
rtitions may be marked UNUSABLE as explained in the following table:
| Table Type | Index Behavior |
|---|---|
| Regular (Heap) | Unless you specify UPDATE INDEXES as part of the ALTER |
| In dex-organized |
|
The ALTER T
ABLE ... COALESCE PARTITION statement is used to coalesce a
partition in a hash-partitioned table. The following statement reduces by one the number of partitions in a table by coalescing a pa
rtition.
ALTER TABLE ouu1
COALESCE PARTITION;
The following statement distributes the contents of a subpartition of partition MODIFY PARTITION ... ADD SUBPARTITION clause
discussed in "Adding a Subpartition to a Range-Hash Partitioned Table".
ALTER
TABLE diving MODIFY PARTITION us_locations
COALESCE SUBPARTITION;
You can instruct the database to reduce by one the number of index partitions in a hash-partitioned global in
dex using the COALESCE PARTITION clause of ALTER INDEX. The database selects the
partition to coalesce based on the requirements of the hash partition. The following statement reduces by one the number of partition
s in the hgidx index, created in "Creating a Hash-Partitioned Global Index":
ALTER INDEX hgidx COALESCE PARTITION;
You can drop partitions from range, list, or composite range-list partitioned tables. For hash-partitioned tables, or hash subpartitions of range-hash partitioned tables, you mu st perform a coalesce operation instead.
Use one of the following statements to drop a table par tition or subpartition:
ALTER TABLE ... <
/a>DROP PARTITION to drop a table partition
ALTER TABLE ... DROP SUBPARTITION to drop a subpartition of a range-list partitioned table
If you
want to preserve the data in the partition, use the MERGE PARTITION statement instead of the DROP PARTITION statement.
If local indexes are defined for the table, this statement also drops the matching parti
tion or subpartitions from the local index. All global indexes, or all partitions of partitioned global indexes, are marked UNUSABLE unless either of the following are true:
You speci
fy UPDATE INDEXES (cannot be specified for index-organized tables)
The partiti on being dropped or its subpartitions are empty
|
|
|
Note: You cannot drop the highest partit ion in a global index. |
You can convert a partition (or subpartition) into a nonpartitioned table, and a nonpartitioned table into a partition (or subpartition) of a partitioned table by exchanging their data segments. You can also convert a hash-partitioned table into a partition of a range- hash partitioned table, or convert the partition of the range-hash partitioned table into a hash-partitioned table. Similarly, you ca n convert a list-partitioned table into a partition of a range-list partitioned table, or convert the partition of the range-list par titioned table into a list-partitioned table
Exchanging table partitions is most useful when you have an application using non partitioned tables that you want to convert to partitions of a partitioned table. For example, in data warehousing environments excha nging partitions facilitates high-speed data loading of new, incremental data into an already existing partitioned table. Generically , OLTP as well as data warehousing environments benefit from exchanging old data partitions out of a partitioned table. The data is p urged from the partitioned table without actually being deleted and can be archived separately afterwards.
When you exchange p
artitions, logging attributes are preserved. You can optionally specify if local indexes are also to be exchanged (INCLUDING INDEXES clause), and if rows are to be validated for proper mapping (WITH VALIDATION clau
se).
|
Note: When you speci fyWITHOUT VALIDATION for the exchange partition operation, this is normally a fast operation because it in
volves only data dictionary updates. However, if the table or partitioned table involved in the exchange operation has a primary key
or unique constraint enabled, then the exchange operation will be performed as if WITH VALIDATION were spec
ified in order to maintain the integrity of the constraints.
To avoid the overhead of this validation activity, issue the followi ng statement for each constraint before doing the exchange partition operation: ALTER TABLE table_n
ame
DISABLE CONSTRAINT constraint_name KEEP INDEX
Then, enable the constraints after the exchange. |
Unless you specify UPDATE INDEXES (this cannot be specified for index-organized tables), the database marks UNUSABL
E the global indexes, or all global index partitions, on the table whose partition is being exchanged. Global indexes, or glob
al index partitions, on the table being exchanged remain invalidated.
See Also:
"Using Transportable Tablespaces: Sce narios" for information about transportable tablespaces
To exchange a partition of a range, hash, or list-partitioned tab
le with a nonpartitioned table, or the reverse, use the ALTER TABLE ... EXCHANGE PARTITION statement. An example of converting a partition into a nonpartitioned table follow
s. In this example, table stocks can be range, hash, or list partitioned.
ALTER TABLE stoc
ks
EXCHANGE PARTITION p3 WITH TABLE stock_table_3;
In this example, you are exchanging a whole hash-partitioned tabl e, with all of its partitions, with the range partition of a range-hash partitioned table and all of its hash subpartitions. This is illustrated in the following example.
First, create a hash-partitioned table:
CREATE TABLE t1 (i
NUMBER, j NUMBER)
PARTITION BY HASH(i)
(PARTITION p1, PARTITION p2);
Populate the table, then create a range -hash partitioned table as shown:
CREATE TABLE t2 (i NUMBER, j NUMBER)
PARTITION BY RANGE(j)
SUBPARTITION BY HASH(i)
(PARTITION p1 VALUES LESS THAN (10)
SUBPARTITION t2_pls1
SUBPARTITION t2_pls2
,
PARTITION p2 VALUES LESS THAN (20)
SUBPARTITION t2_p2s1
SUBPARTITION t2_p2s2));
It is
important that the partitioning key in table t1 is the same as the subpartitioning key in table t2.
To migrate the data in t1 to t2, and validate the rows, use the following statement:
ALTER TABLE t2 EXCHANGE PARTITION p1 WITH TABLE t1
WITH VALIDATION;
Us
e the ALTER TABLE ... EXCHANGE PARTITION
statement to convert a hash subpartition of a range-hash partitioned table into a nonpartitioned table, or the reverse. The followin
g example converts the subpartition q3_1999_s1 of table sales into the nonpartitioned table q3_1999
code>. Local index partitions are exchanged with corresponding indexes on q3_1999.
ALTER T
ABLE sales EXCHANGE SUBPARTITION q3_1999_s1
WITH TABLE q3_1999 INCLUDING INDEXES;
The semantics of the ALTER TABLE ... EXCHANGE PARTITION statement are the same as described previously in "Exchanging a Hash-Partitioned Table with a Range-Hash Partition". In the example shown there, the syntax of the <
code>CREATE TABLE statements would only need to be modified to create a list-partitioned table and a range-list partitioned ta
ble, respectively. The actions involved remain the same.
The semantics of the ALTER TABLE ... EXCHANGE SUBPARTITION are the same as described previously in "Exchanging a Subpartition of a Range-Hash Partitioned Table".
Use the ALTER
code> TABLE ... MERGE PARTITION statement to merge th
e contents of two partitions into one partition. The two original partitions are dropped, as are any corresponding local indexes.
You cannot use this statement for a hash-partitioned table or for hash subpartitions of a range-hash partitioned table.
If
the involved partitions or subpartitions contain data, indexes may be marked UNUSABLE
as explained in the following table:
| Table Type | Index Behavior |
|---|---|
| Regular (Heap) | U
nless you specify UPDATE INDEXES as part of the ALTER TABLE statement:
|
| Index-organized |
|
You are allowed to me rge the contents of two adjacent range partitions into one partition. Nonadjacent range partitions cannot be merged. The resulting pa rtition inherits the higher upper bound of the two merged partitions.
One reason for merging range partitions is to keep histo rical data online in larger partitions. For example, you can have daily partitions, with the oldest partition rolled up into weekly p artitions, which can then be rolled up into monthly partitions, and so on.
The following scripts create an example of merging range partitions.
First, create a partitioned table and create local indexes.
-- Create a Table
with four partitions each on its own tablespace
-- Partitioned by range on the data column.
--
CREATE TABLE four_seasons
(
o
ne DATE,
two VARCHAR2(60),
three NUMBER
)
PARTITION BY RANGE ( one )
(
PARTITION quarter_one
VALUES LESS THAN (
TO_DATE('01-apr-1998','dd-mon-yyyy'))
TABLESPACE quarter_one,
PARTITION quarter_two
VALUES LESS THAN ( TO_DATE('01-jul-1998',
'dd-mon-yyyy'))
TABLESPACE quarter_two,
PARTITION quarter_three
VALUES LESS THAN ( TO_DATE('01-oct-1998','dd-mon-yyyy'))
TAB
LESPACE quarter_three,
PARTITION quarter_four
VALUES LESS THAN ( TO_DATE('01-jan-1999','dd-mon-yyyy'))
TABLESPACE quarter_four
);
--
-- Create local PREFIXED index on Four_Seasons
-- Prefixed because the leftmost columns of the index match the
-- Partition ke
y
--
CREATE INDEX i_four_seasons_l ON four_seasons ( one,two )
LOCAL (
PARTITION i_quarter_one TABLESPACE i_quarter_one,
PARTITION
i_quarter_two TABLESPACE i_quarter_two,
PARTITION i_quarter_three TABLESPACE i_quarter_three,
PARTITION i_quarter_four TABLESPACE i_
quarter_four
);
Next, merge partitions.
-- -- Merge the first two partitions -- ALTER TABL E four_seasons MERGE PARTITIONS quarter_one, quarter_two INTO PARTITION quarter_two UPDATE INDEXES;
If you omit the INDEXES clause from the preceding statement, then you must rebuild the local index for the affected part
ition.
-- Rebuild index for quarter_two, which has been marked unusable -- because it has not had all of the data from Q1 added to it. -- Rebuilding the index will correct this. -- ALTER TABLE four_seasons MODIFY PARTITION quarter_two REBUILD UNUSABLE LOCAL INDEXES;
When you merge list partitions, t he partitions being merged can be any two partitions. They do not need to be adjacent, as for range partitions, since list partitioni ng does not assume any order for partitions. The resulting partition consists of all of the data from the original two partitions. If you merge a default list partition with any other partition, the resulting partition will be the default partition.
The state
ment below merges two partitions of a table partitioned using the list method into a partition that inherits all of its attributes fr
om the table-level default attributes, except for PCTFREE and MAXEXTENTS, which are specified in the statem
ent.
ALTER TABLE q1_sales_by_region
MERGE PARTITIONS q1_northcentral, q1_southcentral
INTO PART
ITION q1_central
PCTFREE 50 STORAGE(MAXEXTENTS 20);
The value lists for the two original partitions were specified as:
PARTITION q1_northcentral VALUES ('SD','WI')
PARTITION q1_southcentral VALUES ('OK','TX')
The resulting sales_west partition value list comprises the set that represents the union of these two partition val
ue lists, or specifically:
('SD','WI','OK','TX')
When you merge range-hash partitions, the subpartitions are rehashed into the number of subpartitions specified by
SUBPARTITIONS n or the SUBPARTITION clause. If neither is included, table-level defa
ults are used.
Note that the inheritance of properties is different when a range-hash partition is split (discussed in "Splitting a Range-Hash Partition"), as opposed to when two range-hash partitions are merged. When a partition is sp lit, the new partitions can inherit properties from the original partition since there is only one parent. However, when partitions a re merged, properties must be inherited from table level defaults because there are two parents and the new partition cannot inherit from either at the expense of the other.
The following example merges two range-hash partitions:
ALTER TABLE all_seasons MERGE PARTITIONS quarter_1, quarter_2 INTO PARTITION quarter_2 SUBPARTITIONS 8;
Partitions can be merged at the range partition level and subpartitions c an be merged at the list subpartition level.
Merging range partitions in a range-list partitioned table is as described previously in "Merging Range Partitions". However, when you merge two range-list partitions, the resulting new partition inherits the subpartition descriptions from the subpartition template, if one exists. If no subpartition template exists, then a single default subpartition is created for the new partition.
This f
ollowing statement merges two partitions in the range-list partitioned stripe_regional_sales table. A subpartition templ
ate exists for the table.
ALTER TABLE stripe_regional_sales
MERGE PARTITIONS q1_1999, q2_1999 INTO P
ARTITION q1_q2_1999
PCTFREE 50 STORAGE(MAXEXTENTS 20);
Some new physical attributes are specified for this new part
ition while table-level defaults are inherited for those that are not specified. The new resulting partition q1_q2_1999
inherits the high-value bound of the partition q2_1999 and the subpartition value-list descriptions from the subpartitio
n template description of the table.
The data in the resulting partitions consists of data from both the partitions. However, there may be cases where the database returns an error. This can occur because data may map out of the new partition when both of the following conditions exist:
Some literal values of the merged subpartitions were not included in the su bpartition template
The subpartition template does not contain a default partition definition.
This error condition can be eliminated by always specifying a default partition in the default subpartition template.
You can merge the contents of any two arbitra ry list subpartitions belonging to the same range partition. The resulting subpartition value-list descriptor includes all o f the literal values in the value lists for the partitions being merged.
The following statement merges two subpartitions of a
table partitioned using range-list method into a new subpartition located in tablespace ts4:
ALTER TABLE quarterly_regional_sales
MERGE SUBPARTITIONS q1_1999_northwest, q1_1999_southwest
INTO SUBPARTITION q1_1999_
west
TABLESPACE ts4;
The value lists for the original two partitions were:
Subparti
tion q1_1999_northwest was described as ('WA','OR')
Subpartition q1_1999
_southwest was described as ('AZ','NM','UT')
The resulting subpartition value list comprises the set that represents the union of these two subpartition value lists:
Subpartition q1_1999_west has a value list described as ('WA','OR','AZ','NM','UT')
The tablespace in which the resulting sub partition is located and the subpartition attributes are determined by the partition-level default attributes, except for those speci fied explicitly. If any of the existing subpartition names are being reused, then the new subpartition inherits the subpartition attr ibutes of the subpartition whose name is being reused.
You can modify the default attributes of a table, or for a partition of a composite partitioned table. When you modify default attribute s, the new attributes affect only future partitions, or subpartitions, that are created. The default values can still be specifically overridden when creating a new partition or subpartition.
You modify the default a
ttributes that will be inherited for range, list, or hash partitions using the MODIFY DEFAULT ATTRIBUTES clause of ALTER TABLE
. The following example changes the default value of PCTFREE in table emp for any new partitions tha
t are created.
ALTER TABLE emp
MODIFY DEFAULT ATTRIBUTES PCTFREE 25;
For hash-partiti
oned tables, only the TABLESPACE attribute can be modified.
To modify the default attributes inherited when creating subpartitions, use the ALTER TABLE
... MODIFY DEFAULT ATTRIBUTES FOR PARTITION. The following statement modifies the TABLESPACE in wh
ich future subpartitions of partition p1 in range-hash partitioned table emp will reside.
ALTER TABLE emp
MODIFY DEFAULT ATTRIBUTES FOR PARTITION p1 TABLESPACE ts1;
Since all subpartitions of a
range-hash partitioned table must share the same attributes, except TABLESPACE, it is the only attribute that can be ch
anged.
In similar fashion to table partitions, you can alter the default attributes that will be i
nherited by partitions of a range-partitioned global index, or local index partitions of partitioned tables. For this you use the INDEX ... MODIFY DEFAULT ATTRIBUTES statement. Use the ALTE
R INDEX ... MODIFY
DEFAULT ATTRIBUTES FOR PARTITION statement if you are altering default attribute
s to be inherited by subpartitions of a composite partitioned table.
It is po ssible to modify attributes of an existing partition of a table or index.
You cannot change the TABLESPACE attrib
ute. Use ALTER TABLESPACE ... MOVE PARTITION/SUBPARTITION to move a partition or subpartition to a new tablespace.
Use the ALTER TABLE ... MODIFY PARTITION statement to modify existing attributes of a range partition or list p
artition. You can modify segment attributes (except TABLESPACE), or you can allocate and deallocate extents, mark local
index partitions UNUSABLE, or rebuild local indexes that have been marked UNUSABLE.
If this is a range partition of a range-hash partitioned table, note the following:
If you allocate or deallocate an extent, this action is performed for every subpartition of the specified partition.
Likewise, changing any other attributes results in corresponding changes to those attributes of all the subpartitio
ns for that partition. The partition level default attributes are changed as well. To avoid changing attributes of existing subpartit
ions, use the FOR PARTITION clause of the MODIFY DEFAULT ATTRIBUTES statement.
The following are some examples of modifying the real attributes of a partition.
This example modifies the MAXEXTENTS storage attribute
for the range partition sales_q1 of table sales:
ALTER TABLE sales MODIFY PAR
TITION sales_Q1
STORAGE (MAXEXTENTS 10);
All of the local index subpartitions of partition ts1 in rang
e-hash partitioned table scubagear are marked UNUSABLE in the following example
:
ALTER TABLE scubagear MPDIFY PARTITION ts1 UNUSABLE LOCAL INDEXES;
With the MODIF
Y SUBPARTITION clause of ALTER TABLE you can perform the same actions as listed previou
sly for partitions, but at the specific composite partitioned table subpartition level. For example:
AL
TER TABLE emp MODIFY SUBPARTITION p3_s1
REBUILD UNUSABLE LOCAL INDEXES;
The MODIFY PARTITION clause of ALTER INDEX lets you modify the real attributes of an index partition
or its subpartitions. The rules are very similar to those for table partitions, but unlike the MODIFY PARTITION clause for ALTER INDEX, there is no subclause to rebuild an unusable index partition, but there is a s
ubclause to coalesce an index partition or its subpartitions. In this context, coalesce means to merge index blocks where possible to
free them for reuse.
You can also allocate or deallocate storage for a subpartition of a local index, or mark it UNUSAB
LE, using the MODIFY PARTITION clause.
You cannot add values to a default list partition.
This oper
ation is essentially the same as described for "Modifying List Partitions: Adding Values", however, you use a
MODIFY SUBPARTITION clause instead of the MODIFY PARTITION clause. For example,
to extend the range of literal values in the value list for subpartition q1_1999_southeast use the following statement:<
/p>
ALTER TABLE quarterly_regional_sales
MODIFY SUBPARTITION q1_1999_southeast
ADD VALUES ('KS');
Literal values being added must not have been included in any other subpartition value list within the owning partition. However, they can be duplicates of literal values in the subpartition value lists of other partitions within the table.
List partitioning allows you the option of dro pping literal values from the defining value list.
Use the MODIFY
PARTITION ... DROP VALUES clause of the ALTER TABLE statement to remove li
teral values from the value list of an existing partition. The statement is always executed with validation, meaning that it checks t
o see if any rows exist in the partition that correspond to the set of values being dropped. If any such rows are found then the data
base returns an error message and the operation fails. When necessary, use a DELETE statement to delete corresponding ro
ws from the table before attempting to drop values.
|
< strong>Note: You cannot drop all literal values from the value list describing the partition. You must use the |
The partition value list for any corresponding local index partition reflects the new value list, and any global index, or global or local index partitions, remain usable.
The statement below drops a set of state codes ('OK' and 'KS') from an existing partition value list.
ALTER TABLE sales_by_region
MODIFY PARTITION region_sou
th
DROP VALUES ('OK', 'KS');
|
Note:< /strong> The database executes a query to check for the existence of rows in the partition that correspond to the literal values being dropped. Therefore, it is advisable to create a local prefixed index on the table. This speeds up the execution of the q uery and the overall operation. |
You cannot drop values fr om a default list partition.
This operation is essent
ially the same as described for "Modifying List Partitions: Dropping Values", however, you use a MODIFY
SUBPARTITION clause instead of the MODIFY PARTITION clause. For example, to remove a s
et of literal values in the value list for subpartition q1_1999_southeast use the following statement:
ALTER TABLE quarterly_regional_sales
MODIFY SUBPARTITION q1_1999_southeast
DROP VALUES ('KS');
You can modify a subpartition template of a composite
partitioned table by replacing it with a new subpartition template. Any subsequent operations that use the subpartition template (suc
h as ADD PARTITION or MERGE PARTITIONS) will now use the new subpartition templat
e. Existing subpartitions remain unchanged.
Use the ALTER TABLE ... SET SUBPARTIT
ION TEMPLATE statement to specify a new subpartition template. For example:
ALTER T
ABLE emp_sub_template
SET SUBPARTITION TEMPLATE
(SUBPARTITION e, TABLESPACE ts1,
SUBPARTITION f, TABLESPACE ts2
,
SUBPARTITION g, TABLESPACE ts3,
SUBPARTITION h, TABLESPACE ts4
);
You can drop a subpartit ion template by specifying an empty list:
ALTER TABLE emp_sub_template SET SUBPARTITION TEMPLATE ( ) ;
Use the MOVE PARTITION clause of the ALTER
TABLE statement to:
Re-cluster data and reduce fragmentation
M ove a partition to another tablespace
Modify create-time attributes
Store t he data in compressed format using table compression
Typically, you can change the physical storage attributes of a
partition in a single step using an ALTER TABLE/INDEX ... MODIFY PARTITION<
/code> statement. However, there are some physical attributes, such as TABLESPACE, that you cannot modify using MODIFY PARTITION. In these cases, use the MOVE PARTITIO
N clause. Modifying some other attributes, such as table compression, affects only future storage, but not existing data.
If the partition being moved contains any data, indexes may be marked UNUSABLE according to the following table:
| Table Type | Index Behavior |
|---|---|
| Regular (Heap) | Unless you
specify UPDATE INDEXES as part of the ALTER TABLE statement:
|
| Index-organized | Any local or global indexes defined for the partit ion being moved remain usable because they are primary-key based logical rowids. However, the guess information for these rowids beco mes incorrect. |
Use the
MOVE PARTITION clause to move a partition. For example, to move the most active partition to a tablespace that re
sides on its own disk (in order to balance I/O), not log the action, and compress the data, issue the following statement:
ALTER TABLE parts MOVE PARTITION depot2
TABLESPACE ts094 NOLOGGING COMPRESS;
This statement alwa ys drops the old partition segment and creates a new segment, even if you do not specify a new tablespace.
If you are moving a
partition of a partitioned index-organized table, you can specify the MAPPING TABLE clause as part of the
MOVE PARTITION clause, and the mapping table partition will be moved to the new location along with the tab
le partition.
The following statement shows how to move data in a subpartition of a t
able. In this example, a PARALLEL clause has also been specified.
ALTER TABLE scuba_gear M
OVE SUBPARTITION bcd_types
TABLESPACE tbs23 PARALLEL (DEGREE 2);
The ALTER TABLE ... MOVE PARTITION
statement for regular tables, marks all partitions of a global index UNUSABLE. You can rebuild the entire index by rebui
lding each partition individually using the ALTER INDEX ...
REBUILD PARTITION statement. You can perform these rebuilds concurrently.
You can also simply drop the ind ex and re-create it.
Some reasons for rebuilding index partitions include:
To recover space and improve performance
To repa ir a damaged index partition caused by media failure
To rebuild a local index partition after loading th e underlying table partition with SQL*Loader or an import utility
To rebuild index partitions that have
been marked UNUSABLE
To enable key compression for B-tree indexes
The foll owing sections discuss your options for rebuilding index partitions and subpartitions.
Y ou can rebuild global index partitions in two ways:
Rebuild each partition by issuing the ALTER INDEX ... REBUILD PARTITION statement (you can run the rebuilds concurrently).
Drop the entire global index and re-create it. This method is more efficient because the table is scanned only onc e.
For most maintenance operations on partitioned tables with indexes, you can optionally avoid the need to rebuild
the index by specifying UPDATE INDEXES on your DDL statement.
Rebuild local indexes using either ALTER INDEX or ALTER TABL
E as follows:
ALTER INDEX ... REBUILD PARTITION/SUBPARTITION
This statement rebuilds an index partition or subpartition unconditionally.
ALTER TABLE ... MODIFY PARTITION/SUBPARTITION ... REBU
ILD UNUSABLE LOCAL INDEXES
This statement finds all of the unusable indexes for
the given table partition or subpartition and rebuilds them. It only rebuilds an index partition if it has been marked UNUSABLE
.
The ALTER INDEX ... REBUILD PARTITION statement rebuilds one partition of an index. It cannot be used f
or composite-partitioned tables. Only real physical segments can be rebuilt with this command. When you re-create the index, you can
also choose to move the partition to a new tablespace or change attributes.
For composite-partitioned tables, use ALTER<
/code> INDEX ... REBUILD SUBPARTITION to rebuild a su
bpartition of an index. You can move the subpartition to another tablespace or specify a parallel clause. The following statement reb
uilds a subpartition of a local index on a table and moves the index subpartition is another tablespace.
ALTER INDEX scuba REBUILD SUBPARTITION bcd_types TABLESPACE tbs23 PARALLEL (DEGREE 2);
The REBUILD UNUSABLE
LOCAL INDEXES clause of ALTER TABLE ... MODIFY PARTITION does not allow you to specify any new attributes for the rebuilt index partition.
The following example finds and rebuilds any unusable local index partitions for table scubagear, partition p1.
ALTER TABLE scubagear MODIFY PARTITION p1 REBUILD UNUSABLE LOCAL INDEXES;
There is
a corresponding ALTER TABLE ... MODIFY SUBPARTITION clause for rebuilding unusabl
e local index subpartitions.
It is possible to rename partitions an d subpartitions of both tables and indexes. One reason for renaming a partition might be to assign a meaningful name, as opposed to a default system name that was assigned to the partition in another maintenance operation.
Rename
a range, hash, or list partition, using the ALTER TABLE ... RENAME PARTITION statement. For example:
ALTER TABLE scubagear RENAME PARTITION sy s_p636 TO tanks;
Likewise, you can assign new names to subpartitions of a table. In this case you would use the <
code>ALTER TABLE ... RENAME PARTITION syntax.<
/p>
The SPLI
T PARTITION clause of the ALTER TABLE or ALTER INDEX statemen
t is used to redistribute the contents of a partition into two new partitions. Consider doing this when a partition becomes too large
and causes backup, recovery, or maintenance operations to take a long time to complete. You can also use the SPLIT
This clause cannot be used for hash partitions or subpartitions.
< p>If the partition you are splitting contains any data, indexes may be markedUNUSABLE
as explained in the following table:
| Table Type | Index Behavior |
|---|---|
| Regular (Heap) | U
nless you specify UPDATE INDEXES as part of the ALTER TABLE statement:
|
| Index-organized |
|
You split a list partition using the ALTER TABLE ... SPLIT PARTITION statement. The SPLIT PARTITION clause lets you specify a value list of literal val
ues that define a partition into which rows with corresponding partitioning key values are inserted. The remaining rows of the origin
al partition are inserted into a second partition whole value list is the remaining values from the original partition.
You ca n optionally specify new attributes for the two partitions resulting from the split.
The following statement splits the partit
ion region_east into two partitions:
ALTER TABLE sales_by_region
SPLIT PARTITION regio
n_east VALUES ('CT', 'VA', 'MD')
INTO
( PARTITION region_east_1
PCTFREE 25 TABLESPACE tbs2,
PARTITION region
_east_2
STORAGE (NEXT 2M PCTINCREASE 25))
PARALLEL 5;
The literal-value list for the original region_ea
st partition was specified as:
PARTITION region_east VALUES ('MA','NY','CT','NH','ME','MD','VA',
'PA','NJ')
The two new partitions are:
region_east_1 with a literal-value list
of ('CT','VA','MD')
region_east_2 inheriting the remaining literal-value list
of ('NY','NH','ME','VA','PA','NJ')
The individual partitions have new physical attributes specified at the partition level. The operation is executed with parallelism of degree 5.
You can split a default list partition just like you split any other list partition. This is also the only means of adding a partition to list-partitioned table that contains a defau lt partition. When you split the default partition, you create a new partition defined by the values that you specify, and a second p artition that remains the default partition.
The following example splits the default partition of sales_by_region, thereby creating a new partition.
ALTER TABLE sales_by_region
SPLIT PARTITION region_unknown VAL
UES ('MT', 'WY', 'ID')
INTO
( PARTITION region_wildwest,
PARTITION region_unknown);
Partitions can be split at both the range partition level and at the list subpartition level.
Splitting a range partition of a range-list partitioned table is similar to what is described in "Splitting a Partition of a Range-Partitioned Ta ble". No subpartition literal value list can be specified for either of the new partitions. The new partitions inherit the subpar tition descriptions from the original partition being split.
The following example splits the q1_1999 partition o
f the quarterly_regional_sales table:
ALTER TABLE quarterly_regional_sales SPLIT PARTITION
q1_1999
AT (to_date('15-Feb-1999','dd-mon-yyyy'))
INTO ( PARTITION q1_1999_jan_feb
PCTFREE 25 TABLESPACE ts1,
PARTITION q1_1999_feb_mar
STORAGE (NEXT 2M PCTINCREASE 25) TABLESPACE ts2)
PARALLEL 5;
This opera
tion splits the partition q1_1999 into two resulting partitions: q1_1999_jan_feb and q1_1999_feb_mar<
/code>. Both partitions inherit their subpartition descriptions from the original partition. The individual partitions have new physi
cal attributes, including tablespaces, specified at the partition level. These new attributes become the default attributes of the ne
w partitions. This operation is run with parallelism of degree 5.
The ALTER TABLE ... SPLIT PARTITION statement provides no means of specifically naming subpartitions resulting from the split of a partition
in a composite partitioned table. However, for those subpartitions in the parent partition with names of the form partition
name_subpartition name, the database generates corresponding names in the newly created subpartitions using the new part
ition names. All other subpartitions are assigned system generated names of the form SYS_SUBPn. Sy
stem generated names are also assigned for the subpartitions of any partition resulting from the split for which a name is not specif
ied. Unnamed partitions are assigned a system generated partition name of the form SYS_Pn.
The following query displays the subpartition names resulting from the previous split partition operation on table quarterly_re
gional_sales. It also reflects the results of other operations performed on this table in preceding sections of this chapter s
ince its creation in "When to Use Composite Range-List Partitioning ".
SELECT P
ARTITION_NAME, SUBPARTITION_NAME, TABLESPACE_NAME
FROM DBA_TAB_SUBPARTITIONS
WHERE TABLE_NAME='QUARTERLY_REGIONAL_SALES'
ORDER
BY PARTITION_NAME;
PARTITION_NAME SUBPARTITION_NAME TABLESPACE_NAME
-------------------- ------------------------
------ ---------------
Q1_1999_FEB_MAR Q1_1999_FEB_MAR_WEST TS2
Q1_1999_FEB_MAR Q1_1999_FEB_MAR_NORTHEAST TS
2
Q1_1999_FEB_MAR Q1_1999_FEB_MAR_SOUTHEAST TS2
Q1_1999_FEB_MAR Q1_1999_FEB_MAR_NORTHCENTRAL TS2
Q1_1999_FEB_MAR
Q1_1999_FEB_MAR_SOUTHCENTRAL TS2
Q1_1999_FEB_MAR Q1_1999_FEB_MAR_SOUTH TS2
Q1_1999_JAN_FEB Q1_1999_JAN_FEB_WES
T TS1
Q1_1999_JAN_FEB Q1_1999_JAN_FEB_NORTHEAST TS1
Q1_1999_JAN_FEB Q1_1999_JAN_FEB_SOUTHEAST TS1
Q1_19
99_JAN_FEB Q1_1999_JAN_FEB_NORTHCENTRAL TS1
Q1_1999_JAN_FEB Q1_1999_JAN_FEB_SOUTHCENTRAL TS1
Q1_1999_JAN_FEB Q1_19
99_JAN_FEB_SOUTH TS1
Q1_2000 Q1_2000_NORTHWEST TS3
Q1_2000 Q1_2000_SOUTHWEST
TS3
Q1_2000 Q1_2000_NORTHEAST TS3
Q1_2000 Q1_2000_SOUTHEAST TS3
Q1_2000
Q1_2000_NORTHCENTRAL TS3
Q1_2000 Q1_2000_SOUTHCENTRAL TS3
Q2_1999 Q2_1999_NORT
HWEST TS4
Q2_1999 Q2_1999_SOUTHWEST TS4
Q2_1999 Q2_1999_NORTHEAST TS
4
Q2_1999 Q2_1999_SOUTHEAST TS4
Q2_1999 Q2_1999_NORTHCENTRAL TS4
Q2_1999
Q2_1999_SOUTHCENTRAL TS4
Q3_1999 Q3_1999_NORTHWEST TS4
Q3_1999 Q3_1999_SOUTHWEST
TS4
Q3_1999 Q3_1999_NORTHEAST TS4
Q3_1999 Q3_1999_SOUTHEAST TS4
Q3_19
99 Q3_1999_NORTHCENTRAL TS4
Q3_1999 Q3_1999_SOUTHCENTRAL TS4
Q4_1999 Q4_19
99_NORTHWEST TS4
Q4_1999 Q4_1999_SOUTHWEST TS4
Q4_1999 Q4_1999_NORTHEAST
TS4
Q4_1999 Q4_1999_SOUTHEAST TS4
Q4_1999 Q4_1999_NORTHCENTRAL TS4
Q4_1999
Q4_1999_SOUTHCENTRAL TS4
36 rows selected.
Splitting a list subpartition of a range-list partitioned table is similar to what is described in "Spli
tting a Partition of a List-Partitioned Table", but the syntax is that of SUBPARTITION rather than PARTITION
code>. For example, the following statement splits a subpartition of the quarterly_regional_sales table:
ALTER TABLE quarterly_regional_sales SPLIT SUBPARTITION q2_1999_southwest
VALUES ('UT') INTO
( SUBPARTITION q
2_1999_utah
TABLESPACE ts2,
SUBPARTITION q2_1999_southwest
TABLESPACE ts3
)
PARALLEL;
This operation splits the subpartition q2_1999_southwest into two subpartitions:
q2_1999_utah with literal-value list of ('UT')
q2_1999_southwest which
inherits the remaining literal-value list of ('AZ','NM')
The individual subpartitions have new physica l attributes that are inherited from the subpartition being split.
You cannot explicitly s plit a partition in a local index. A local index partition is split only when you split a partition in the underlying table. However, you can split a global index partition as is done in the following example:
ALTER INDEX quon1 SPLIT
PARTITION canada AT ( 100 ) INTO
PARTITION canada1 ..., PARTITION canada2 ...);
ALTER INDEX quon1 REBUILD PARTITION canada1;
ALTER INDEX quon1 REBUILD PARTITION canada2;
The index being split can contain index data, and the resulting partitions d
o not require rebuilding, unless the original partition was previously marked UNUSABLE.
Oracle Database implements a SPLIT PARTITION operation by creating two new partitions and re
distributing the rows from the partition being split into the two new partitions. This is an expensive operation because it is necess
ary to scan all the rows of the partition being split and then insert them one-by-one into the new partitions. Further if you do not
use the UPDATE INDEXES clause, both local and global indexes also require rebuilding.
Sometimes afte r a split operation, one of the new partitions contains all of the rows from the partition being split, while the other partition con tains no rows. This is often the case when splitting the first partition of a table. The database can detect such situations in heap- organized partitioned tables and can optimize the split operation. This optimization results in a fast split operation that behaves l ike an add partition operation. The fast split optimization does not apply to partitioned index-organized tables.
Specifically
, the database can optimize and speed up SPLIT PARTITION operations if two conditions are met:
One of the two resulting partitions must be empty.
The nonempty resulting partition mus t have storage characteristics identical to those of the partition being split. Specifically:
If the p artition being split is composite, then the storage characteristics of each subpartition in the new nonempty resulting partition must be identical to those of the subpartitions of the partition being split.
If the partition being split
contains a LOB column, then the storage characteristics of each LOB (sub)partition in the new nonempty res
ulting partition must be identical to those of the LOB (sub)partitions of the partition being split.
If both of these conditions are met after the split, then all global indexes remain usable, even if you did not specify the <
code>UPDATE INDEXES clause. Local index (sub)partitions associated with both resulting partitions remain usable i
f they were usable before the split. Local index (sub)partition(s) corresponding to the nonempty resulting partition will be identica
l to the local index (sub)partition(s) of the partition that was split.
The same optimization holds for SPLIT
Use the ALTER TABLE ... TRUNCATE PARTITION statement to remove all rows from a table partition. Trun
cating a partition is similar to dropping a partition, except that the partition is emptied of its data, but not physically dropped.<
/p>
You cannot truncate an index partition. However, if local indexes are defined for the table, the ALTER TABL
E ... TRUNCATE PARTITION statement truncates the matching p
artition in each local index. Unless you specify UPDATE INDEXES (cannot be specified for index-organized ta
bles), any global indexes are marked UNUSABLE and must be rebuilt.
Use the ALTER TABLE ... TRUNCATE<
/code> PARTITION statement to remove all rows from a table partition, with or without reclaiming space.
If the partition contains data and global indexes, use one of the following methods to truncate the table partition.
Leave the global indexes in place during the ALTER TABLE ... PARTITION statement. In this example, table sales has a global index sales_area_i
x, which is rebuilt.
ALTER TABLE sales TRUNCATE PARTITION dec98; ALTER INDEX sales_area_ix REBUI LD;
This method is most appropriate for large tables where the partition being truncated contains a significant percentag e of the total data in the table.
Issu
e the DELETE statement to delete all rows from the partition before you issue the ALTER TABLE
... TRUNCATE PARTITION statement. The DELETE statemen
t updates the global indexes, and also fires triggers and generates redo and undo logs.
For example, to truncate the first par tition, which has a partition bound of 10000, issue the following statements:
DELETE FROM sales WHERE T RANSID < 10000; ALTER TABLE sales TRUNCATE PARTITION dec98;
This method is most appropriate for small tables, or for l arge tables when the partition being truncated contains a small percentage of the total data in the table.
Specify UPDATE INDEXES in the AL
TER TABLE statement. This causes the global index to be truncated at the time the partition is truncated.
ALTER TABLE sales TRUNCATE PARTITION dec98
UPDATE INDEXES;
If a partition contains data and has referential integrity constraints, choose either of the following methods to truncate the table partition.
Disable the integrity constraints, issue the ALTER TABLE ... TRUNCA
TE PARTITION statement, then reenable the integrity constraints:
ALTER TABLE sales
DISABLE CONSTRAINT dname_sales1;
ALTER TABLE sales TRUNCATE PARTITTION dec94;
ALTER TABLE sales
ENABLE CONSTRAINT dname_sales
1;
This method is most appropriate for large tables where the partition being truncated contains a significant percentage of the total data in the table.
Issue
the DELETE statement to delete all rows from the partition before you issue the ALTER TABLE .
.. TRUNCATE PARTITION statement. The DELETE statement enforces referential integrity constrain
ts, and also fires triggers and generates redo and undo log.
|
Note: You can substantially reduce the amount of logging by setting theNOLOGGING at
tribute (using ALTER TABLE ... TRUNCATE PARTITION ... NOLOGGING) for
the partition before deleting all of its rows. |
DELETE FROM sales WHERE TRANSID < 10000; ALTER TABLE sales TRUNCATE PARTITION dec94;
This method is most appropriate for small tables, or for large tables when the partition being truncated contains a small percentage of the total data i n the table.
You use the ALTER TABLE ... TRUNCATE SUBPARTITION statement to remove all rows from a subpartition of a composite part
itioned table. Corresponding local index subpartitions are also truncated.
The following statement shows how to truncate data in a subpartition of a table. In this example, the space occupied by the deleted rows is made available for use by other schema objec ts in the tablespace.
ALTER TABLE diving
TRUNCATE SUBPARTITION us_locations
DROP STORAGE;
This section presents an example of moving the time window in a historical table.
A hi
storical table describes the business transactions of an enterprise over intervals of time. Historical tables can be base tables, which contain base information; for example, sales, checks, and orders. Historical tables can also be
rollup tables, which contain summary information derived from the base information using operations such as GROUP BY
code>, AVERAGE, or COUNT.
The time interval in a historical table is often a rolling window. DBAs pe riodically delete sets of rows that describe the oldest transactions, and in turn allocate space for sets of rows that describe the m ost recent transactions. For example, at the close of business on April 30, 1995, the DBA deletes the rows (and supporting index entr ies) that describe transactions from April 1994, and allocates space for the April 1995 transactions.
Now consider a specific
example. You have a table, order, which contains 13 months of transactions: a year of historical data in addition to ord
ers for the current month. There is one partition for each month. These monthly partitions are named order_yym
m, as are the tablespaces in which they reside.
The order table contains two local indexes, ord
er_ix_onum, which is a local, prefixed, unique index on the order number, and order_ix_supp, which is a local, no
nprefixed index on the supplier number. The local index partitions are named with suffixes that match the underlying table. There is
also a global unique index, order_ix_cust, for the customer name. order_ix_cust contains three partitions,
one for each third of the alphabet. So on October 31, 1994, change the time window on order as follows:
Back up the data for the oldest time interval.
ALTER TABLESPACE order_9310 BEGIN BA CKUP; ... ALTER TABLESPACE order_9310 END BACKUP;
Drop the partition for t he oldest time interval.
ALTER TABLE order DROP PARTITION order_9310;
Add the par tition to the most recent time interval.
ALTER TABLE order ADD PARTITION order_9411;
Re-create the global index partitions.
ALTER INDEX order_ix_cust REBUILD PARTITION order_ix_cust_AH ; ALTER INDEX order_ix_cust REBUILD PARTITION order_ix_cust_IP; ALTER INDEX order_ix_cust REBUILD PARTITION order_ix_cust_QZ;
Ordinarily, the database acquires sufficient locks to ensure that no operation (DML, DDL, or utility) interferes with
an individual DDL statement, such as ALTER TABLE ... DROP PARTITION. However, if
the partition maintenance operation requires several steps, it is the database administrator's responsibility to ensure that applicat
ions (or other maintenance operations) do not interfere with the multistep operation in progress. Some methods for doing this are:
Bring down all user-level applications during a well-defined batch window.
En
sure that no one is able to access table order by revoking access privileges from a role that is used in all application
s.
The following views display information specific to partitioned tables and indexes:
| View | Description |
|---|---|
DBA_PART_TA
BLES
|
DBA view displays partitioning information for all partitioned tables in the database. ALL view displays
partitioning information for all partitioned tables accessible to the user. USER view is restricted to partitioning inf
ormation for partitioned tables owned by the user. |
DBA_TAB_PARTITIONS
|
Display partition-level partitioning information, partition storage parameters, and partition s
tatistics generated by the DBMS_STATS package or the ANALYZE statement. |
DBA_TAB_SUBPARTITIONS
|
Display subpartition-level partitioning
information, subpartition storage parameters, and subpartition statistics generated by the DBMS_STATS package or the |
DBA_PA
RT_KEY_COLUMNS
|
Display the partitioning key columns for partitioned tables. |
DBA_SUBPART_KEY_COLUMNS
|
Display the subpartitioning key columns for com posite-partitioned tables (and local indexes on composite-partitioned tables). |
DBA_PART_COL_STATISTICS
|
Display column statistics and histogram information for the partitions of tables. |
DBA_SU
BPART_COL_STATISTICS
|
Display column statistics and histogram information for subpartitions of tables. | DBA_PART_HISTOGRAMS
|
Display the histogram data (end-points for each histogram) for histograms on table partitions. |
DBA_SUBPART_HISTOGRAMS
|
Display the histogram data (end-points for each histogram) for histograms on table subpartitions. |
| <
code>DBA_PART_INDEXES
|
Display partitioning information for partitioned indexes. |
DBA_IND_PARTITIONS
|
Display the following for index partitions: partition-level par
titioning information, storage parameters for the partition, statistics collected by the DBMS_STATS package or the ANALYZE statement. |
DBA_IND_
SUBPARTITIONS
|
Display the following information for index subpartitions: partition-level partitioning information, storage
parameters for the partition, statistics collected by the DBMS_STATS package or the ANALYZE statement. |
DBA_SUBPARTITION_TEMPLATES
|
Display information about existing subpartition templates. |
|
See Also:
|