PL-SQL Functions Comparison Operators Select Operators Single Row Functions for Numbers, Chars and Dates Conversion Functions Miscellaneous Single Row Functions Aggregate Functions Analytical Functions Object Reference Functions Date Format Models Date Prefixes and Suffixes Number Format Models Comparison Operators Table 1-1. Comparison Operators Operator What it does = true if two expressions are equal != ^= -= <> logically equivalent—true if two expressions are not equal > True if left expression is greater than right expression >= True if left expression is greater than or equal to right expression < True if left expression is less than right expression <= True if left expression is less than or equal to right expression IN Is equal to any member of a set or subquery NOT IN Does NOT equal any member of a set or subquery ANY, SOME True if one or more of the values in the list of expressions or subquery satisfies the condition ALL True if all of the values in the list of expressions or subquery satisfies the condition BETWEEN x AND y True if greater than or equal to x and less than or equal to y (can be reversed in meaning with NOT) 1
Transcript
PL-SQL FunctionsComparison OperatorsSelect OperatorsSingle Row Functions for Numbers, Chars and DatesConversion FunctionsMiscellaneous Single Row FunctionsAggregate FunctionsAnalytical FunctionsObject Reference FunctionsDate Format ModelsDate Prefixes and SuffixesNumber Format Models
Comparison Operators
Table 1-1. Comparison Operators
Operator What it does
= true if two expressions are equal
!= ^= -= <> logically equivalent—true if two expressions are not equal
> True if left expression is greater than right expression
>= True if left expression is greater than or equal to right expression
< True if left expression is less than right expression
<= True if left expression is less than or equal to right expression
IN Is equal to any member of a set or subquery
NOT IN Does NOT equal any member of a set or subquery
ANY, SOME True if one or more of the values in the list of expressions or subquery satisfies the condition
ALL True if all of the values in the list of expressions or subquery satisfies the condition
BETWEEN x AND y
True if greater than or equal to x and less than or equal to y (can be reversed in meaning with NOT)
EXISTS True if the subquery returns at least one row (can be reversed in meaning with NOT)
'True if expression or subquery matches pattern. '%' matches any sequence of characters, '_' matches any single character. If ESCAPE is used, the character 'c' causes the character following to be taken literally (can be reversed in meaning with NOT).
IS NULL TRUE if the value is NULL (can be reversed in meaning with NOT)
Select Operators
Also called SET operators
Table 1-2. Select Operators (Sets)
Operator What it does
UNION This combines the results of two queries and returns the set of distinct rows returned by either query
UNION ALL This combines the results of two queries and returns all rows returned by either query, including duplicates
INTERSECT This combines the results of two queries and returns the set of distinct rows returned by both queries
MINUS This combines the results of two queries and returns the distinct rows that were in the first query, but not in the second
Table 1-3. Other Select Operators
Operator What it does
(+) Denotes that the preceding column is an outer join
* Wildcard operator. Equals all columns in a select statement
PRIOR Denotes a parent-child relationship in a tree-structured query
ALL Include all duplicate rows in a query (the default)
2
Operator What it does
DISTINCT Eliminate duplicates in a result set
Single Row Functions
Number Functions
Table 1-6. Single Row Number Functions
Function What it does
ABS(n) Returns absolute value of n
ACOS(n) Returns arc cosine of n in radians
ASIN(n) Returns arc sine of n in radians
ATAN(n) Returns arc tangent of n, in radians
ATAN2(n,m) Returns the arc tangent of n and m, in radians
BITAND(n,m) Computes the bitwise logical AND of the bits of n and m, where n and m are nonnegative integers. Returns an integer.
CEIL(n) Ceiling function—returns the smallest integer >= n
COS(n) Returns the cosine of n where n is in radians
COSH(n) Returns the hyperbolic cosine of n where n is in radians
EXP(n) Returns en
FLOOR(n) Returns the largest integer <= n
LN(n) Returns the natural log of n
LOG(m,n) Returns the base m log of n
MOD(m,n) Returns the modulus of m, n—the remainder of m divided by n. (Returns m when n=0)
3
Function What it does
POWER(m,n) Returns m raised to the nth power
ROUND (m[,n]) Rounds m to the nearest n places. Where n is omitted, default is zero. n must be an integer
SIGN(n) For n < 0, returns –1, for n > 0, returns 1, for n = 0, returns 0
SIN(n) Returns sine(n) where n is in radians
SINH(n) Returns the hyperbolic sine(n) where n is in radians
SQRT(n) Returns the square root of n
TAN(n) Returns the tangent(n) where n is in radians
TANH(n) Returns the hyperbolic tangent(n) where n is in radians
TRUNC (m[,n]) Truncate. Returns m truncated to n places. Where n is omitted, it returns the integer value of m.
WIDTH_BUCKET (exp,min,max,num)
Returns the “bucket” in which exp belongs, where min is the minimum value, max is the maximum value, and num is the number of divisions (buckets) to use
Character Functions
Table 1-7. Character Single Row Functions
Function What it does
CHR (n) Returns the character whose binary value is n. Accepts USING NCHAR_CS clause
CONCAT (char1,char2) Combines two strings, char1 and char2
INITCAP(char) Returns char with the first character of each word in char capitalized
LOWER(char) Returns char with all characters converted to lowercase
LPAD(char1,n[,char2]) Returns char1 padded on the left to width n
4
Function What it does
with character sequence in char2. Default padding is a single blank (space).
LTRIM(char[,set]) Returns char with initial characters in set removed from the left. Default set is a blank character (space).
NLS_INITCAP(char[,nlsparam]) Returns char with the first character of each word in char capitalized. Accepts an NLS parameter.
NLS_LOWER(char[,nlsparam]) Returns char with all characters converted to lowercase. Accepts an NLS parameter.
NLSSORT(char[,nlsparam]) Returns language specific sort of char. Accepts an NLS parameter.
NLS_UPPER(char[,nlsparam]) Returns char with all characters converted to uppercase. Accepts an NLS parameter.
REPLACE(char[,searchstring[,replacestring]]) Returns char with searchstring replaced by replacestring. Where replacestring is omitted or null, all instances of searchstring are removed. Where searchstring is omitted or null, char is returned.
RPAD(char1,n[,char2]) Returns char1 padded on the right to width n with character sequence in char2. Default padding is a single blank (space).
RTRIM(char[,set]) Returns char with initial characters in set removed from the right. Default set is a blank character (space).
SOUNDEX(char) Returns the phonetic equivalent of char. Allows for searches for words that sound alike but are spelled differently.
SUBSTR(string,n[,m])
also:
SUBSTRB - bytes
SUBSTRC - unicode
SUBSTR2 - UCS2 codepoints
Returns the substring of string, starting at position n, for a length of m (or to the end of string if m is not present)
5
Function What it does
SUBSTR4 - UCS4 codepoints
TRANSLATE(char,from,to) Returns char, with all occurrences of characters in the from string replaced with the corresponding character in the to string. If to is shorter than from, then from characters without a corresponding to character will be removed. Empty to returns NULL, not an empty string.
TREAT(exp AS [[REF] [schema.]] type) Changes the declared type of exp to type
Returns source with leading and/or trailing trimchars removed. Default trimchar is a blank space, default action is to remove both leading and trailing blank spaces.
UPPER (char) Returns char with all characters converted to uppercase
ASCII (char) Returns the number value of the first character of char
INSTR(str,substr[,pos[,occur]])
also:
INSTRB - bytes
INSTRC - unicode
INSTR2 - UCS2 codepoints
INSTR4 - UCS4 codepoints
“In string” function. Returns the position of the occurrence occur of substr in str, starting at pos. Default for pos and occur is 1. If pos is negative, search works backwards from the end of str.
LENGTH (char)
also:
LENGTHB - bytes
LENGTHC - unicode
LENGTH2 - UCS2 codepoints
LENGTH4 - UCS4 codepoints
Returns the length of char
Date Functions
Table 1-8. Date Single Row Functions
6
Function What it does
ADD_MONTHS(d,n) Returns the date d plus n months. If d is the last day of the month, or d+n would be past the end of the month, returns the last day of the month.
CURRENT_DATE Returns the current Gregorian date as datatype DATE, in the session specific time zone
CURRENT_TIMESTAMP [(precision)]
Returns the current date and time as datatype TIMESTAMP WITH TIME ZONE, in the session specific time zone. Precision defaults to 6 places.
DBTIMEZONE Returns the time zone of the database
EXTRACT (datetime FROM expr) datetime can be YEAR, MONTH, DAY, HOUR, MINUTE, SECOND, TIMEZONE_HOUR, TIMEZONE_MINUTE, TIMEZONE_REGION, or TIMEZONE_ABBR, and expr can be either an internal value or datetime value expression
FROM_TZ(timestamp, time_zone) Returns timestamp converted to a TIMESTAMP WITH TIME ZONE value, using time_zone
LAST_DAY(date) Returns the date of the last day of the month containing date
LOCALTIMESTAMP [(precision)] Returns the current date and time of the session in datatype TIMESTAMP of precision
MONTHS_BETWEEN(date1, date2) Returns the number of months between date1 and date2
NEW_TIME(date,zone1,zone2) Returns date converted from time zone zone1 to zone2. NLS_DATE_FORMAT must be set to a 24-hour format.
NEXT_DAY(date,weekday) Returns the next weekday later than date where weekday is the day of the week or its abbreviation
NUMTODSINTERVAL (n, char) Returns n converted to an INTERVAL DAY TO SECOND literal. char can be 'DAY,' 'HOUR,' 'MINUTE,' or 'SECOND,' or an expression that resolves to one of those
NUMTOYMINTERVAL (n, char) Returns n converted to an INTERVAL YEAR TO MONTH literal. char can be 'MONTH' or 'YEAR' or an expression that resolves to one of those
ROUND (date[,fmt]) Returns date rounded to the nearest unit specified by the format model fmt. Defaults to the nearest day.
7
Function What it does
SESSIONTIMEZONE Returns the time zone of the current session, either as a time zone offset or a time zone region name, depending on the format used for the most recent ALTER SESSION statement
SYS_EXTRACT_UTC (datetz) Extracts the UTC value of datetz where datetz is a datetime with time zone displacement
SYSDATE Returns the current date and time
SYSTIMESTAMP Returns the system timestamp in TIMESTAMP WITH TIME ZONE datatype
TO_DSINTERVAL(char [nlsparm]) Converts char to an INTERVAL DAY TO SECOND type
TO_TIMESTAMP (char[,fmt[nlsparm]])
Converts char to datatype of TIMESTAMP. fmt specifies the format of char if other than the default for datatype TIMESTAMP
TO_TIMESTAMP_TZ (char[,fmt[nlsparm]])
Converts char to datatype of TIMESTAMP WITH TIME ZONE. fmt specifies the format of char if other than the default for datatype TIMESTAMP WITH TIME ZONE.
TO_YMINTERVA(char) Converts char to an INTERVAL YEAR TO MONTH type
TRUNC (date[,fmt]) Returns date truncated to the time unit specified by fmt. If fmt is omitted, date is truncated to the nearest day.
ASCIISTR(string) Returns the ASCII string in the database language of string which can be in any character set. Non-ASCII characters are converted to their UTF-16 binary values.
BIN_TO_NUM(expr[,expr…]) Converts the binary bits of expr,expr,… to a number. Example: BIN_TO_NUM(1,1,0,1) returns 13.
8
Function What it does
CAST(expr | [MULTISET] (subquery) AS type)
Converts from one built in datatype or collection type to another
CHARTOROWID(char) Converts char to type ROWID
COMPOSE('string') Converts string to its Unicode string equivalent in the same character set
CONVERT(char, dest_set [,source_set]) Returns char converted from source_set character set to dest_set character set. If source_set is not specified, the database character set is assumed.
DECOMPOSE(string [CANONICAL | COMPATIBILITY])
Returns a unicode string decomposed from its fully normalized form. If CANONICAL(the default) is used, the result can be recomposed with COMPOSE.
HEXTORAW (char) Returns hexadecimal digits of char as RAW
NUMTODSINTERVAL (n, char) Converts number n to an INTERVAL DAY TO SECOND literal. char can be 'DAY,' 'HOUR,' 'MINUTE,' or 'SECOND'
NUMTOYMINTERVAL (n, char) Converts number n to an INTERVAL YEAR TO MONTH literal. char can be 'YEAR or 'MONTH'
RAWTOHEX(raw) Converts raw to its hexadecimal equivalent character value
RAWTONHEX(raw) Converts raw to its hexadecimal equivalent NVARCHAR2 character value
ROWIDTOCHAR(rowid) Converts rowid to a VARCHAR2 18 characters long
ROWIDTONCHAR(rowid) Converts rowid to a NVARCHAR2 18 characters long
TO_CHAR (nchar | clob | nclob) Converts an NCHAR, NVARCHAR2, CLOB or NCLOB value to the underlying database character set
TO_CHAR (date [,fmt[nlsparm]]) Converts date to VARCHAR2, using format fmt and any nlsparm
TO_CHAR (num [,fmt[nlsparm]]) Converts num to VARCHAR2, using format fmt and any nlsparm
TO_CLOB (lob_col|char) Converts lob_col or char to CLOB value
9
Function What it does
TO_DATE char [,fmt[nlsparm]] Converts char to a date, using the format fmt and any nlsparm. If fmt is not specified, then the default date format is used.
TO_DSINTERVAL (char [nlsparm]) Converts char to an INTERVAL DAY TO SECOND literal
TO_LOB(long_col) Converts the LONG or LONG RAW value of long_col to LOB values
TO_MULTI_BYTE(char) Converts single byte char to multibyte characters
TO_NCHAR(char [,fmt[nlsparm]]) Converts a string from the database character set to the national character set
TO_NCHAR (datetime | interval[,fmt[nlsparm]])
Converts a date, time, or interval value from the database character set to the national character set
TO_NCHAR (n [,fmt[nlsparm]]) Converts a number to a string in the NVARCHAR2 character set
TO_NCLOB (lob_column | char) Converts char or lob_column to NCLOB data, using the national character set
TO_NUMBER(char[,fmt[nlsparm]]) Converts char to a number, using fmt as the format specifier
TO_SINGLE_BYTE(char) Returns char with any multibyte characters converted to the corresponding single byte characters
TO_YMINTERVAL(char [nlsparm]) Converts char to an INTERVAL YEAR TO MONTH literal
TRANSLATE (text USING CHAR_CS | NCHAR_CS)
Returns text translated into the database character set (USING CHAR_CS) or the national character set (USING NCHAR_CS)
UNISTR(string) Returns string in Unicode using the database Unicode character set
Miscellaneous Single Row Functions
Table 1-10. Miscellaneous Single Row Functions
10
Function What it does
BFILENAME('dir','fname') Returns a locator for an LOB binary file on the filesystem. dir is the database object that is an alias for the full pathname of the file directory, fname is the actual file name.
11
Function What it does
COALESCE(expr[,expr,...]) Returns the first nonnull expression in a list of expressions
Searches expr for search, returning the specific result for each search. Returns default if search is not found.
DEPTH(correlation_int) Returns the number of levels in the path specified by an UNDER_PATH condition
DUMP(expr[,return_fmt [,start[,length]]])
Returns a VARCHAR2 value with the datatype, length, and internal representation of expr, using the format of return_fmt. Returns entire internal representation unless start and optionally length are specified.
EMPTY_BLOB() Returns a locator for a BLOB, allowing you to initialize the BLOB
EMPTY_CLOB() Returns a locator for a CLOB, allowing you to initialize the CLOB
EXISTSNODE(XML_Instance, path [expr])
Walks the XML tree and returns success if a node is found that matches the specified path
EXTRACT (XML_Instance, path [expr])
Walks the XML tree and, if nodes are found which match the specified path, returns those nodes
EXTRACTVALUE(XML_Instance, path [expr])
Walks the XML tree and, if nodes are found that match the specified path, returns the scalar value of those nodes
GREATEST(expr[,expr,...]) Returns the expression in the list with greatest value. All data types are implicitly converted to the data type of the first expression. Character comparisons use the database character set.
LEAST(expr[,expr,...]) Returns the expression in the list with least value. All data types are implicitly converted to the data type of the first expression. Character comparisons use the database character set.
NLS_CHARSET_DECL_LEN (bytes,set_id)
Returns the declaration width of the NCHAR column of width bytes and a character set ID of set_id
NLS_CHARSET_ID(text) Returns the number of a character set ID with a character set name of text
12
Function What it does
NLS_CHARSET_NAME(num) Returns the character set name of the character set with ID num
NULLIF(expr1,expr2) Returns null if expr1and expr2 are equal, else returns expr1
NVL(expr1,expr2) Returns expr2 if expr1 is NULL, else returns expr1
NVL2(expr1,expr2,expr3) Returns expr2 if expr1 is NOT NULL, else returns expr3
PATH (correlation_int) Returns the relative path to the resource specified in an UNDER_PATH or EQUALS_PATH condition
SYS_CONNECT_BY_PATH (column,char)
Returns the path of a column value from root to node in an hierarchical query. Column values are separated by char.
SYS_CONTEXT('namespace', 'param'[,len])
Returns a VARCHAR2 with the value of param of namespace. Return is 256 bytes unless overridden by len.
Generates a URL that can be used to retrieve an XML document from one or more columns col or attributes attr with or without a rowid
SYS_EXTRACT_UTC(time) Returns the UTC from time where time is a datetime with time zone displacement
SYS_GUID() Generates and then returns a Globally Unique IDentifier (GUID) of 16 RAW bytes
SYS_TYPEID(obj_val) Returns the typeid of an object type operand
SYS_XMLAGG(expr [fmt]) Creates a single well-formed XML document from multiple documents
SYS_XMLGEN(expr [fmt]) Creates a well-formed XML document from a database row/column expression
UID Returns the UID of the current session user
UPDATEXML(XML_instance, path, expr)
Updates an XML document by searching for the node specified in the path, then replaces either the node or the scalar value of the node, depending on argument types
13
Function What it does
USER Returns the username of the current session user
USERENV(param) Returns a variety of information about the current session. While deprecated in favor of SYS_CONTEXT, this is retained for backward compatibility.
VSIZE(expr) Returns the number of bytes used by the value represented by expr
XMLAGG(XML_instance [ORDER BY sortlist])
Returns a well-formed XML document by aggregating a series of XML fragments. The returned document is a simple aggregate and no formatting is supported.
XMLCOLATTVAL Creates an XML fragment for one or more columns of a single row. The format of the fragment is fixed as <column name=”column name”>column value</column>.
XMLCONCAT(XML_instance [, XML_instance,...])
Returns an XML fragment created by concatenating a series of XML fragments or elements
XMLFOREST Creates an XML fragment for one or more columns of a single row. The format of the fragment is fixed as <column name>column value</column name>.
XMLSEQUENCE Used to “unroll” a stored XMLType into multiple rows for further processing as individual elements
XMLTRANSFORM Applies an XSL style sheet to an XML document and returns the resulting new XML document
Aggregate Functions
All of the aggregate functions described below can have an analytical clause appended to them using the OVER (analytical_clause) syntax. For space considerations, we've omitted this from the Function column.
Table 1-11. Aggregate Functions
Function What it does
AVG([DISTINCT|ALL] expr) Computes the average of the rows returned by expr. If the DISTINCT keyword is used, duplicate rows will be excluded from the calculation.
14
Function What it does
CORR( expr1 , expr2 ) Calculates the coefficient of correlation between expr1 and expr2
COUNT(* | [DISTINCT|ALL] expr) Returns the number of [DISTINCT] rows in the expr that are not null, or if * is specified, the total number of rows, including duplicates and nulls
COVAR_POP( expr1, expr2 ) Given a set of pairs, expr1 and expr2, where nulls are excluded, returns the population covariance
COVAR_SAMP( expr1, expr2 ) Given a set of pairs, expr1 and expr2, where nulls are excluded, returns the sample covariance
CUME_DIST(expr[,expr...]) WITHIN GROUP (ORDER BY expr [DESC|ASC] [NULLS [FIRST|LAST])
Given a list of values, finds and returns the cumulative distribution of a single value within that list
DENSE_RANK(expr[,expr...]) WITHIN GROUP (ORDER BY expr)
Given an ordered group of rows, finds and returns the rank of a single value within that group
FIRST ORDER BY expr [DESC|ASC] [NULLS [FIRST|LAST])
Returns the first row or rows from a set based on the specified sort order. If multiple rows tie as “first” then all tied rows will be returned. Used in an aggregate function.
GROUP_ID() Used in GROUP BY specification to distinguish duplicate groups
GROUPING(expr) Used to distinguish superaggregate rows from regular grouped rows when ROLLUP and CUBE are used
GROUPING_ID(expr[,expr...]) Returns the number of the GROUPING bit vector for a row
LAST ORDER BY expr [DESC|ASC] [NULLS [FIRST|LAST])
Returns the last row or rows from a set based on the specified sort order. If multiple rows tie as “last” then all tied rows will be returned. Used in an aggregate function.
MAX([DISTINCT|ALL] expr) Returns the maximum value of expr. If the DISTINCT keyword is used, duplicate rows will be excluded from the calculation.
15
Function What it does
MIN([DISTINCT|ALL] expr) Returns the minimum value of expr. If the DISTINCT keyword is used, duplicate rows will be excluded from the calculation.
PERCENTILE_CONT(expr) WITHIN GROUP (ORDER BY expr [DESC|ASC])
Given a list of values and a specified percentile ranking, returns the interpolated value of that percentile by assuming a continuous distribution of data in the list
PERCENTILE_DISC(expr) WITHIN GROUP (ORDER BY expr [DESC|ASC])
Given a list of values and a specified percentile ranking, returns the smallest value that meets or exceeds that percentile rank by assuming a discrete distribution of data in the list
PERCENT_RANK(expr) WITHIN GROUP (ORDER BY expr [DESC|ASC][NULLS FIRST|LAST])
Given a list of values, calculates the hypothetical rank of a single value within that list
RANK(expr) WITHIN GROUP (ORDER BY expr [DESC|ASC][NULLS FIRST|LAST])
Returns the rank (ordering) of expr in the group of values returned by the order by expression
STDDEV([DISTINCT|ALL] expr) Returns the standard deviation of expr
STDDEV_POP([DISTINCT|ALL] expr) Returns the square root of the population variance from computing the standard deviation of expr
STDDEV_SAMP([DISTINCT|ALL] expr) Returns the square root of the cumulative sample standard deviation of expr
SUM([DISTINCT|ALL] expr) Returns the sum of expr. Distinct eliminates duplicates from the set of values being summed.
VAR_POP(expr) Returns the population variance of expr. Nulls are removed from the calculation.
VAR_SAMP(expr) Returns the sample variance of expr. Nulls are removed from the calculation.
VARIANCE([DISTINCT|ALL] expr) The variance of expr, with duplicates removed if DISTINCT is specified
16
Table 1-12. Regression Functions
Function What it does
REGR_SLOPE(expr,expr2) Returns the slope of a least squares regression line of the set of number pairs defined by (expr,expr2)
REGR_INTERCEPT(expr,expr2) Returns the Y intercept of a least squares regression line of the set of number pairs defined by (expr,expr2)
REGR_COUNT(expr,expr2) Returns the number of NOT NULL pairs used to fit the least squares regression line of the set of number pairs defined by (expr,expr2)
REGR_R2(expr,expr2) Returns the R2 value (coefficient of determination) of a least squares regression line of the set of number pairs defined by (expr,expr2)
REGR_AVGX(expr,expr2) Returns the average value of expr2 of a least squares regression line of the set of number pairs defined by (expr,expr2) after removing nulls from the calculation
REGR_AVGY(expr,expr2) Returns the average value of expr of a least squares regression line of the set of number pairs defined by (expr,expr2) after removing nulls from the calculation
REGR_SXX(expr,expr2) Returns the value of calculating REGR_COUNT(expr, expr2) * VAR_POP(expr2) with nulls removed from the calculation
REGR_SYY(expr,expr2) Returns the value of calculating REGR_COUNT(expr, expr2) * VAR_POP(expr) with nulls removed from the calculation
REGR_SXY(expr,expr2) Returns the value of calculating REGR_COUNT(expr, expr2) * COVAR_POP(expr,expr2) with nulls removed from the calculation
Analytical Functions
17
All of the aggregate functions described above can also have analytic functionality, using the OVER (analytical_clause) syntax. For space considerations, we've declined to list them twice. Note that you cannot nest analytic functions.
Table 1-13. Analytical Functions
Function What it does
FIRST_VALUE(expr) OVER (analytical_clause) Returns the first in the ordered set of expr
LAG(expr[,offset][,default]) OVER (analytical_clause)
Provides access at a point offset prior to the cursor in a series of rows returned by expr
LAST_VALUE(expr) OVER (analytical_clause) Returns the last in the ordered set of expr
LEAD(expr[,offset][,default]) OVER (analytical_clause)
Provides access at a point offset beyond the cursor in a series of rows returned by expr
NTILE(expr) OVER (analytical_clause) Divides the ordered dataset into expr number of buckets
RATIO_TO_REPORT(expr) OVER (analytical_clause)
Returns the ratio of expr to the sum returned by analytical_clause
ROW_NUMBER(expr) OVER ([partition_clause]order_by_clause)
Assigns a unique number to each row
Object Reference Functions
Table 1-14. Object Reference Functions
Function What it does
DEREF(expr) Returns the object reference of expr. Without this, an the object ID of the reference would be returned.
MAKE_REF(table|view,key [,key...])
Returns a REF to a row of an object view or table
REF(correlation_var) Returns the REF value of correlation_var
REFTOHEX(expr) Converts expr to its hexadecimal equivalent where expr is a REF
VALUE(correlation_var) Returns the value associated with the correlation_var
18
Date Format Models
Table 1-15. Date Format Models
Element Value Returned
- / , . ; “text” Quoted text and punctuation are reproduced in the result
AD A.D. Indicates date that is AD. Periods optional
AM A.M. PM P.M.
Before or after noon. Periods optional
BC B.C. Indicates date that is BC. Periods optional
CC SCC Century (SCC precedes BC century with -)
D The day of week (1–7)
DAY The name of the day of the week (Monday, Tuesday, etc.). Padded to 9 characters.
DD Day of month (1–31)
DDD The number of the day of year (1–366)
DY The name of the day of the week, abbreviated
E Abbreviated era name (for Japanese Imperial, ROC Official, and Thai Buddha calendars)
EE Full era name
FF [1–9] Fractional seconds. 1–9 specifies the number of digits
HH Hour of day(12-hour clock)
19
Element Value Returned
HH12 Hour of day (12-hour clock)
HH24 Hour of day (24-hour clock)
IW Number of Week of the year
IYY IY I Last 3, 2, or 1 digit(s) of ISO year
IYYY 4-digit ISO year
J Julian day(number of days since January 1, 4712 BC)
MI Minute (0–59)
MM Month (01–12)
MON JAN, FEB, MAR, etc.
MONTH Full month name, padded to 9 characters
Q Quarter of year where JAN–MAR = 1
RM Month in Roman numerals (I–XII; JAN = I)
RR Last two digits of the year, for years in previous or next century (where previous if current year is <=50, next if current year >50)
RRRR Round year. Accepts 4 or 2 digit input, 2 digit returns as RR.
SS Seconds (0–59)
SSSSS Seconds past midnight (0–86399)
TZD Abbreviated Time Zone String with Daylight Savings
TZH Time zone hour
TZM Time zone minute
WW The week of the year (1–53)
20
Element Value Returned
W The week of the month
X Local radix character
Y, YYY Year, with comma as shown
YEAR
SYEARYear, fully spelled out. For SYEAR, BC dates use “-”
Y
YY
YYY
Final one, two, or three digits of the year
Date Prefixes and Suffixes
The following prefixes can be added to date formats:
FM The fill mode toggle. Suppresses blank padding of MONTH or DAY
FX Specifies that the format of TO_DATE functions must be an exact match
The following suffixes may be added to date formats:
TH converts to an ordinal number ("5TH")
SP Spells out the number ("FIVE")
SPTH or THSP Spells out the ordinal number ("FIFTH")
Number Format Models
Table 1-16. Number Format Models
Element Example Value Returned
, 9,999 Returns a comma at the position specified
. 99.99 Returns a period (decimal point) at the position specified
21
Element Example Value Returned
$ $9999 Leading dollar sign
0 0999 Returns value with leading zeros
0 9990 Returns value with trailing zeros
9 9999 Returns value with the specified number of digits. Leading space if positive, – if negative. Leading zeros are blank, except when integer portion is zero, then a single leading zero is returned.
B B9999 As in 9, above, but returns a blank in all cases for leading zeros
C C999 Returns the ISO currency symbol
D 99D99 Returns the NLS decimal character in the specified position
EEEE 9.9EEEE Returns value in scientific notation
FM FM90.9 Returns a value without leading or trailing blanks
G 9G999 Returns the value with the NLS group separator in the specified position
L L999 Returns the value with the NLS Local Currency Symbol in the specified position. Negative values have a trailing minus sign (–), positive values with a trailing blank.
PR 9999PR Returns negative values in <angle brackets>, positives have leading and trailing blanks
RN rn RN rn Returns the value as Roman numerals, in the case-specified
S S9999 9999S
Returns the value with a + or – sign denoting positive or negative value in the position shown (can only be first or last position).
TM TM “Text minimum.” Returns the smallest number of characters possible and is case-insensitive. Default is TM9 that uses fixed notation up to 64 characters, then scientific notation.
U U9999 Returns the “Euro” (or other) NLS dual currency symbol in the specified position
22
V 999V99 Returns a value multiplied by 10 times the number of 9s specified after the V
X XXXX Returns the Hexadecimal value. Precede with a 0 to have leading zeros, or FM to remove the leading blank.
Advanced cursors Introduction to Oracle SQL & PL/SQLUpdated 03/20/2005
Cursor FOR Loops Parameterized Cursors (passing parameters to cusors)
Ref Cursor BULK COLLECT INTO
Cursor FOR Loops
The cursor FOR loop provides an elegant, simple syntax to to iterate over a result set. To underscore the advantages of cursor FOR loops, consider the following PL/SQL block which uses a basic loop.
SET SERVEROUTPUT ONDECLARE -- EMP_CURSOR will retrieve all columns and all rows from the EMP table CURSOR emp_cursor IS SELECT * FROM emp; emp_record emp_cursor%ROWTYPE;BEGIN OPEN emp_cursor; LOOP
--Advance the pointer in the result set, assign row values to EMP_RECORD FETCH emp_cursor INTO emp_record; --Test to see if no more results EXIT WHEN emp_cursor%NOTFOUND; DBMS_OUTPUT.PUT_LINE(emp_record.ename||' [' ||emp_record.empno||']'); END LOOP; CLOSE emp_cursor;END;/
Now examine the same query using a cursor FOR loop:
DECLARE -- EMP_CURSOR will retrieve all columns and all rows from the EMP table CURSOR emp_cursor IS SELECT * FROM emp;BEGIN FOR emp_record IN emp_cursor LOOP DBMS_OUTPUT.PUT_LINE(emp_record.ename||' ['||emp_record.empno||']'); END LOOP;END;/
You can use a cursor for loop without a declared cursor by including a query in the FOR statement. This can enable very compact code.
BEGIN FOR emp_record IN (SELECT * FROM emp) LOOP DBMS_OUTPUT.PUT_LINE(emp_record.ename||' ['||emp_record.empno||']'); END LOOP;END;/
While you can use EXIT statement within a FOR cursor loop, you should not use a cursor FOR loop if you may need to exit the LOOP prematurely. Use a basic or WHILE loop instead.
Parameterized Cursors (passong parameters to cursors)
Cursors can use variables to adjust which rows they select when opened. Instead of hard-coding a value into the WHERE clause of a query, you can use a variable as a placeholder for a literal value. The variable placeholder will substituted with the value of the variable when the cursor is opened. This makes a query more flexible.
/* Since v_deptno and v_job are declared above, they are in scope, * and can be referenced in the cursor body. They will be used as * placeholders until the cursor is opened, at which * point the values of the variables will be substituted (bound) * into the query as literals. */ CURSOR emp_stats_cursor IS
24
SELECT SUM(sal) sum_sal FROM emp WHERE deptno=v_deptno AND job=v_job; BEGIN v_deptno:=10; v_job:='MANAGER';
OPEN emp_stats_cursor; /* When the cursor is opened, the values of the PL/SQL * variables are bound into the query. * In this example, the cursor would return the * result set using the following query: SELECT SUM(sal) sum_sal FROM emp WHERE deptno=10 --current value of v_deptno is 10 AND job='MANAGER'; --current value of v_job is 'MANAGER' */
FETCH emp_stats_cursor INTO v_sum_sal; CLOSE emp_stats_cursor; DBMS_OUTPUT.PUT_LINE(v_deptno||' : '||v_job||' : '||v_sum_sal);
v_deptno:=30; v_job:='SALESMAN';
OPEN emp_stats_cursor; /* In this example, the cursor would * return the result set using the following query:
SELECT SUM(sal) sum_sal FROM emp WHERE deptno=30 --current value of v_deptno is 30 AND job='SALESMAN'; --current value of v_job is 'SALESMAN' */
FETCH emp_stats_cursor INTO v_sum_sal; CLOSE emp_stats_cursor; DBMS_OUTPUT.PUT_LINE(v_deptno||' : '||v_job||' : '||v_sum_sal);END;/
This method works, but there is a better way. You can declare a cursor using parameters; then whenever you open the cursor, you pass in appropriate parameters. This technique is just as flexible, but is easier to maintain and debug. The above example adapted to use a parameterized cursor:
DECLARE
v_sum_sal NUMBER;
/* The parameters are declared in the cursor declaration. * Parameters have a datatype, but NO SIZE; that is, you * can declare a parameter of datatype VARCHAR2, but never * VARCHAR2(20). * As above, the parameters will be placeholders (that is, * formal parameters) until the cursor is opened, at which * point the actual parameter values will be substituted * (bound) into the query as literals. * The parameters are in scope (that is, they can be referenced)
25
* only inside the cursor body. */
CURSOR emp_stats_cursor(cp_deptno NUMBER, cp_job VARCHAR2) IS SELECT SUM(sal) sum_sal FROM emp WHERE deptno=cp_deptno AND job=cp_job;
BEGIN
OPEN emp_stats_cursor(10,'MANAGER'); /* When the cursor is opened, the values of the parameters * are bound into the query. In other words, the actual parameters * (values) will replace the formal parameters (placeholders). * In this example, the cursor would return the result set using * the following query:
SELECT SUM(sal) sum_sal FROM emp WHERE deptno=10 AND job='MANAGER'; */
FETCH emp_stats_cursor INTO v_sum_sal; CLOSE emp_stats_cursor;
OPEN emp_stats_cursor(30,'SALESMAN'); /* In this example, the cursor would return the result set * using the following query:
SELECT SUM(sal) sum_sal FROM emp WHERE deptno=30 AND job='SALESMAN'; */
FETCH emp_stats_cursor INTO v_sum_sal; CLOSE emp_stats_cursor; DBMS_OUTPUT.PUT_LINE('30 : SALESMAN : '||v_sum_sal);END;/
Parameterized cursors are open easier to debug in larger PL/SQL blocks. This is because the the declaration of the cursor body is often far from where the cursor is opened, but processing of the cursor's result set is usually close to where the cursor is opened.
o When opening a cursor which uses variables, you must assign appropriate values to those variables before opening the cursor. So when you are debugging how the cursor is opened, you must confirm the appropriate variable names where the cursor is declared . This is often inconvenient.
o When using PL/SQL variables, it's difficult to confirm the values of the variables when the cursor is opened because the values could be set at an any point from the declaration on.
Parameterized cursors eliminate both these problems because the values used in the cursor can be determined in one place, the OPEN statement. And you don't need to know the names of the cursor parameters. (Though you do need to know the order of the parameters.)
An example which combines a cursor FOR loop with a parameterized query:
26
DECLARE v_sum_sal NUMBER; CURSOR emp_stats_cursor(cp_deptno NUMBER, cp_job VARCHAR2) IS SELECT SUM(sal) sum_sal FROM emp WHERE deptno=cp_deptno AND job=cp_job;
BEGIN FOR dept_job_rec IN (SELECT DISTINCT deptno,job FROM emp) LOOP OPEN emp_stats_cursor(dept_job_rec.deptno, dept_job_rec.job); FETCH emp_stats_cursor INTO v_sum_sal; CLOSE emp_stats_cursor; DBMS_OUTPUT.PUT_LINE(dept_job_rec.deptno ||' : '||dept_job_rec.job||' : '||v_sum_sal); END LOOP;END;/
Ref Cursor
Ref Cursor is THE method to returns result sets to client applications (like C, VB, etc). You cannot define ref cursors outside of a procedure or function in a package specification or body. Ref cursors can only be processed in the defining procedure or returned to a client application. Also, a ref cursor can be passed from subroutine to subroutine and a cursor cannot. To share a static cursor like that, you would have to define it globally in a package specification or body. Because using global variables is not a very good coding practice in general, Ref cursors can be used to share a cursor in PL/SQL without having global variables getting into the mix.
Last, using static cursors—with static SQL (and not using a ref cursor) —is much more efficient than using ref cursors, and the use of ref cursors should be limited to
Returning result sets to clients Sharing cursors across many subroutines (very similar to the above point, actually) Achieving your goal when there is no other efficient/effective means of doing so, such as
when dynamic SQL must be used
In short, you want to use static SQL first and use a ref cursor only when you absolutely have to.An Example of Ref cursor is here:
create or replace function sp_ListEmp return types.cursortype as l_cursor types.cursorType; begin open l_cursor for select ename, empno from emp order by ename; return l_cursor; end; /
Or like this for a procedure:
create or replace procedure getemps( p_cursor in out types.cursorType )asbegin open p_cursor for select ename, empno from emp order by ename;end;
Cursor variables are cursors opened by a pl/sql routine and fetched from by another application or pl/sql routine (in 7.3 pl/sql routines can fetch from cursor variables as well as open them). The cursor variables are opened with the privelegs of the owner of the procedure and behave just like they were completely
27
contained within the pl/sql routine. It uses the inputs to decide what database it will run a query on. Here is an example:
create or replace package types as type cursorType is ref cursor; end; /
create or replace function sp_ListEmp return types.cursortype as l_cursor types.cursorType; begin open l_cursor for select ename, empno from emp order by ename; return l_cursor; end; /create or replace procedure getemps( p_cursor in out types.cursorType )asbegin open p_cursor for select ename, empno from emp order by ename;end;/
BULK COLLECT INTO
Introduced in Oracle8i, BULK COLLECT allows you to retrieve multiple rows of data directly into PL/SQL Collections. It will raise NO_DATA_FOUND if it doesn't find any rows, but it certainly doesn't raise TOO_MANY_ROWS if it finds more than one! More information can be obtained HERE.
DECLARE TYPE title_aat IS TABLE OF magazine.title%TYPE INDEX BY BINARY_INTEGER;
l_titles title_aat;BEGIN SELECT title BULK COLLECT INTO l_titles FROM magazine;END;
My advice regarding the kinds of cursors to use when fetching data from Oracle in PL/SQL programs it to whenever possible, use BULK COLLECT—it offers dramatic performance gains. In Oracle9i Release 2, you can even use BULK COLLECT to fetch multiple rows directly into a collection of records. Of course, when you want/need to fetch just a single row, BULK COLLECT doesn't make sense.
Explicit Cursors Introduction to Oracle SQL & PL/SQLUpdated 03/20/2005
Concepts Working with explicit cursors Cursor Attributes Records and %ROWTYPE
Oracle uses cursors to process all SQL statements. From SQL*Plus, you issue a command and Oracle takes care of creating a cursor and processing the command. These types of cursors are called implicit cursors, because you (the user) cannot not name or control the cursor directly. In PL/SQL you also use implicit cursors for DML statements and single select statements.
Implicit (static) cursor: commonly refers to the good old SELECT INTO, in which Oracle implicitly opens, executes and closes the cursor for you, depositing any selected values of a single row INTO program data structures.
CREATE OR REPLACE PROCEDURE show_title (author_in IN magazine.author%TYPE)IS l_title magazine.title%TYPE;BEGIN SELECT title INTO l_title FROM magazine WHERE author = author_in;END;
The single select is a simple solution, but insufficient to solve the following problems.
You may need to process more general result sets which return more or less than one row You may need to process rows in a specific order You may need to control the execution of your program depending on the result set.
To address these problems you need to use explicit cursors.
Working with explicit cursors
Explicit cursors work the same way implicit cursors work, but you control the execution explicitly.
CURSOR emp_cursor IS SELECT empno, ename FROM emp;BEGIN OPEN emp_cursor; LOOP FETCH emp_cursor INTO v_empno, v_ename;
30
EXIT WHEN emp_cursor%ROWCOUNT>10 or emp_cursor%NOTFOUND; DBMS_OUTPUT.PUT_LINE(INITCAP(v_ename)||' ['||v_empno||']'); END LOOP; CLOSE emp_cursor;END;/
Records and %ROWTYPE
Instead of fetching values into a collection of variables, you could fetch the entire row into a record like so.
DECLARE CURSOR emp_cursor IS SELECT empno, ename, sal, job, deptno FROM emp WHERE deptno=30; -- This creates a record named emp_row -- based on the structure of the cursor emp_cur emp_row emp_cursor%ROWTYPE; BEGIN OPEN emp_cursor; LOOP FETCH emp_cursor INTO emp_row; EXIT WHEN emp_cursor%NOTFOUND; DBMS_OUTPUT.PUT_LINE(emp_row.ename||' [' ||emp_row.empno||'] makes '||TO_CHAR(emp_row.sal*12,'$99,990.00')); END LOOP;END;/
You can reference the fields of a record using the syntax record_name.field_name.
In addition to basing a record on a cursor, you can also define records based on tables like so.
DECLARE CURSOR emp_cursor IS SELECT * FROM emp WHERE deptno=30;
emp_row emp%ROWTYPE; -- This creates a record named EMP_ROW -- based on the structure of the EMP tableBEGIN OPEN emp_cursor; LOOP FETCH emp_cursor INTO emp_row; EXIT WHEN emp_cursor%NOTFOUND; DBMS_OUTPUT.PUT_LINE(emp_row.ename||' ['||emp_row.empno ||'] makes '||TO_CHAR(emp_row.sal*12,'$99,990.00')); END LOOP;END;/
BLOB varies 0 - 4 GB stored separate from tableCLOB varies 0 - 4 GB stored separate from tableNCLOB varies 0 - 4 GB stored separate from table
BFILE ?? ?? pointer to O/S file
ROWID 8 n/a row identifier within block
* Long datatypes are discouraged in Oracle 8. Note that are long and blob
32
datatypes are incompatible.
====== PL-SQL data types (differences) ======
Type Storage Range/Length Comments----------------- ---------- -------------- ----------------------------NUMERIC
VARCHARVARCHAR2
BLOB must be read in 32k chunksCLOBNCLOB
Creating a table
PCTFREE = Amount of space to leave in block during insert operations. Allows room for records to grow within the same area.PCUSED = The threshold at which the block is placed back on the free block list.INITIAL/NEXT = The initial disk allocated, and the next extent size.LOGGING = Indicates whether operations are written to the redo logs.
SELECT RESUME INTO EBLOB FROM VEMP_RES WHERE EMP_ID =:NEW.EMP_ID AND VER_NO = VER1 FOR UPDATE ;
UPDATE VEMP_RES SET RESUME = VBLOB WHERE EMP_ID =:NEW.EMP_ID AND VER_NO = VER1 ;
END;
Renaming a table
35
RENAME COMPANY TO CORPORATION ;
Synonyms and Database Links
-- Synonym Creation
GRANT SELECT ON USER5.COMPANY TO USER6 ;
CREATE SYNONYM USER6.COMPANY5 FOR USER5.COMPANY ;
-- Database Link
CREATE DATABASE LINK ARCHIVE_DATA CONNECT TO USER5 IDENTIFIED BY TIGER USING 'SERVER5' ;
/* user within this system can now reference tables using ARCHIVE_DATA.tablename */
Changing a column's type
ALTER TABLE CORPORATION MODIFY (COMPANY_NM VARCHAR2(100));
Moving a table
ALTER TABLE COMPANY MOVE STORAGE ( INITIAL 200K NEXT 200K PCTINCREASE 0 MAXEXTENTS 50 ) TABLESPACE TS_01 ;
Using SQL-Plus
SQL-Plus is a query / command line utility which has some powerful formatting capabilities. Getting Started ; Command line terminator/ Execute the current batch of commandsSET SERVEROUTPUT ON Allow messages from PL-SQL to be displayedSHOW ERRORS Show errors from last batchEDIT Run editor, and load bufferCLEAR BUFFER Clear buffer commands& Prompt for value@ Run commands in @filename
36
/**** Examples ****/
/* prompt for process id, and kill */
alter system kill session '&Victim'/
Creating a stored procedure
Below is a simple stored procedure which deletes an invoice. Note:- variable declaration placement - the syntax for comments /* --- */- ALL select statements must have an into statement for the result set. Oracle stored procedures must use "out" variables to return results to client programs.- the declaration of INV_ID1 uses the column def as a prototype CREATE OR REPLACE PROCEDURE PROC_DELETE_INVOICE ( USERID1 VARCHAR2, INV_ID1 INVOICE.INV_ID%TYPE )AS INV_COUNT NUMBER ;
BEGIN
INV_COUNT := 0;
/* check if invoice exists */
SELECT COUNT(*) INTO INV_COUNT FROM INVOICE WHERE INV_ID = INV_ID1 ;
IF INV_COUNT > 0 THEN
DELETE FROM INVOICE WHERE INV_ID = INV_ID1 ; COMMIT ;
END IF ;
END ;
Displaying output
All SELECT statements in PL-SQL must have an INTO clause; therefore another method is needed to display output to the console.
DBMS_OUTPUT.PUT_LINE('TEST OUTPUT');
salary := 24000;
dbms_output.put_line(salary);
37
Output variables
Output variables are used to return data to another procedure, or to an external application which has invoked the stored procedure.
/* sample procedure header using output variables */
TYPE INV_ARRAY IS TABLE OF NUMBER(8) INDEX BY BINARY_INTEGER ;
CREATE OR REPLACE PROCEDURE PROC_GET_INV_NOS ( USERID1 IN VARCHAR2, INV_IDS OUT INV_ARRAY)AS
...
Arrays and structures
Arrays and structures are implemented thought the use of "tables" and "records" in PL-SQL.
/* EXAMPLE OF A SIMPLE RECORD TYPE */
TYPE INVOICE_REC_TYPE IS RECORD (INV_ID INVOICE.INV_ID%TYPE, INV_DT INVOICE.INV_DT%TYPE ) ;
/* ARRAY DECLARATION */
TYPE NAME_TABLE_TYPE IS TABLE OF VARCHAR2(20)INDEX BY BINARY_INTEGER ;
NAME_TABLE NAME_TABLE_TYPE ;
/* ARRAY SUBSCRIPTING */
I := I + 1;
NAME_TABLE(I) := 'JSMITH';
Conditionals
Sample formats of conditional branching are given below:
IF <condition> THEN <statement> ;
IF <condition> THEN <statements> ; END IF;
/* sample statement, note the pipes for concatenation */IF (COUNT1 = 0) AND (COUNT2 > 0) THEN RETMSG := 'Security attributes have not been assigned, ' ||
38
'you are restricted.';ELSE RETMSG := 'You are OK';END IF;
Looping
WHILE (I < 10)LOOP /* ... SOME CMDS ... */
I = I + 1;END LOOP;
Cursors
The first example depicts dbase-style row processing ; the second a more traditional "fetch" approach.
PROCEDURE PROC_SCAN_INVOICES (EXPIRE_DT IN DATE)IS
CURSOR INVOICE_CUR IS SELECT INV_ID, INV_DT FROM INVOICE ;
TYPE INVOICE_REC_TYPE IS RECORD (INV_ID INVOICE.INV_ID%TYPE, INV_DT INVOICE.INV_DT%TYPE ) ;
INVOICE_REC INVOICE_REC_TYPE ;
BEGIN
FOR INVOICE_REC1 IN INVOICE_CUR LOOP
IF INVOICE_REC.INV_DT < EXPIRE_DT THEN
DELETE FROM INVOICE WHERE INV_ID = INV_REC.INV_ID ;
CREATE OR REPLACE PROCEDURE PROC_DOCEXPIRE_RPT ( RPT_BODY OUT LONG RAW )IS RPT_LINE VARCHAR2(1900); RPT_PART VARCHAR2(1900); RPT_LEAD VARCHAR2(200); GLIB_ID1 NUMBER ; GLIB_ID2 VARCHAR(12); ORIG_LOC_CD1 VARCHAR2(12); AUTHOR_ID1 VARCHAR2(30); CONTRIBUTORS1 VARCHAR2(80); TOPIC1 VARCHAR2(80); NBR_ACCESS1 NUMBER ; NBR_ACCESS2 VARCHAR2(12); TOT_EXPIRED1 NUMBER ; TOT_EXPIRED2 VARCHAR2(12); COUNT1 NUMBER ; RPT_BODY_PART LONG ;
CURSOR CUR1 IS SELECT GLIB_ID, ORIG_LOC_CD, AUTHOR_ID, CONTRIBUTORS, TOPIC, NBR_ACCESS FROM GEN_DOC WHERE EXPIRE_DT < (SYSDATE + 30) ORDER BY ORIG_LOC_CD, GLIB_ID ;
EXCEPTION WHEN OTHERS THEN BEGIN DBMS_OUTPUT.PUT_LINE('ERROR: PROC_DOCSTAT_RPT'); GLIB_ID1 := UTL_RAW.LENGTH(RPT_BODY); DBMS_OUTPUT.PUT_LINE(GLIB_ID1); END;
END;
41
Packages
A package is a construct which bounds related procedures and functions together. Variables declared in the declaration section of a package can be shared among the procedures/functions in the body of the package. /* package */
CREATE OR REPLACE PACKAGE INVPACKIS
FUNCTION COUNTINV (SALESREP IN VARCHAR2) RETURN INTEGER;
PROCEDURE PURGEINV (INV_ID IN INTEGER) ;
END INVPACK;
/* package body */
CREATE OR REPLACE PACKAGE BODY INVPACKIS
COUNT1 NUMBER;
FUNCTION COUNTINV (SALESREP IN VARCHAR2) RETURN INTEGER IS BEGIN
SELECT COUNT(*) INTO COUNT1 FROM INVOICE WHERE SALES_REP_ID = SALESREP ;
RETURN COUNT1 ; END COUNTINV;
PROCEDURE PURGEINV (INV_ID1 IN INTEGER) IS BEGIN
DELETE FROM INVOICE WHERE INV_ID = INV_ID1
END PURGEINV;
/* initialization section for package */BEGIN
COUNT1 := 0 ;
END INVPACK;
Exception Handling
The following block could appear at the end of a stored procedure:
EXCEPTION
42
WHEN NO_DATA_FOUND THEN DBMS_OUTPUT.PUT_LINE('End of data !!); WHEN OTHERS THEN BEGIN DBMS_OUTPUT.PUT_LINE('OTHER CONDITION OCCURRED !'); END;
Using Blobs
Blob variables require special handling in PL-SQL. When reading from a file to a blob, only one statement is required. When reading from a blob field to a PL-SQL variable, only 32k blocks can be processed, thus necessitating a loop construct.
/*---------------------------------------*//* Read a blob from a file, and write *//* it to the database. *//*---------------------------------------*/
set serveroutput on size 500000 ;
truncate table image_test ;
create or replace directory image_dir as '/apps/temp/images' ;
create or replace procedure proc_imp_jpg (fname1 in varchar2, image_id1 in numeric) is
file1 bfile ;lblob blob ;len int ;e_blob blob ;
begin
file1 := bfilename('IMAGE_DIR',fname1);
e_blob := empty_blob();
insert into image_test (image_id, image_data) values (image_id1, e_blob ) returning image_data into lblob ;
exception when others then begin dbms_output.put_line(sqlerrm); dbms_lob.filecloseall(); commit; end;
43
end ;/
call proc_imp_jpg('jada.jpg',101)/
/*-----------------------------*//* determine the length of *//* a blob field *//* by reading it *//*-----------------------------*/CREATE OR REPLACE PROCEDURE PROC_BLOB_LENGTH (PART_ID1 NUMBER)IS SRC_LOB BLOB; BUFFER RAW(100); AMT BINARY_INTEGER := 100; POS INTEGER := 1; COUNTER INTEGER :=0;
BEGIN SELECT PART_PHOTO INTO SCR_LOB FROM PARTS WHERE PART_ID=PART_ID1 ;
IF (SRC_LOB IS NOT NULL) THEN LOOP DBMS_LOB.READ (SRC_LOB, AMT, POS, BUFFER); POS := POS + AMT; COUNTER:=COUNTER+1; END LOOP;ELSE DBMS_OUTPUT.PUT_LINE('** Source is null');END IF;
EXCEPTION WHEN NO_DATA_FOUND THEN DBMS_OUTPUT.PUT_LINE('End of data, total bytes:'); DBMS_OUTPUT.PUT_LINE(POS);END;
/* ============ Other blob length examples ====== *//**** Note ! These functions may return null, if the column is null ... an Oracle bug */
X := UTL_RAW.LENGTH(RPT_BODY) ;
Y := DBMS_LOB.GETLENGTH(LONG_RAW_COL);
Using the Context cartridge
Managing Context is an arduous task. The best approach is to use the command line utility as much as possible. Below is a code sample which creates a policy (a policy is a construct which informs context which column on what table to scan during a search operation). The next example illustrates how to perform a search, and stored the result keys in a table. /* create a policy, on the emp_resume table */
SELECT s.segment_name,s.segment_type,s.tablespace_name,s.next_extentFROM dba_segments sWHERE NOT EXISTS (SELECT 1 FROM dba_free_space f WHERE s.tablespace_name=f.tablespace_name HAVING max(f.bytes) > s.next_extent);
List table blocks, empty blocks, extent count, and chain block count
SELECT blocks as BLOCKS_USED, empty_blocksFROM dba_tablesWHERE table_name=TNAME;
SELECT chain_cnt AS CHAINED_BLOCKS
48
FROM dba_tablesWHERE table_name=TNAME;
SELECT COUNT(*) AS EXTENT_COUNTFROM dba_extentsWHERE segment_name=TNAME;
Information about all rollback segments in the database
Statistics of the rollback segments currently used by instance
SELECT T1.NAME, T2.EXTENTS, T2.RSSIZE, T2.OPTSIZE, T2.HWMSIZE, T2.XACTS, T2.STATUSFROM V$ROLLNAME T1, V$ROLLSTAT T2WHERE T1.USN = T2.USN AND T1.NAME LIKE '%RBS%';
List sessions with active transactions
SELECT s.sid, s.serial# FROM v$session s WHERE s.saddr in (SELECT t.ses_addr FROM V$transaction t, dba_rollback_segs r WHERE t.xidusn=r.segment_id AND r.tablespace_name='RBS');
SELECT index_name,table_name,uniquenessFROM dba_indexesWHERE index_name in (SELECT constraint_name FROM dba_constraints WHERE table_name = TNAME AND constraint_type in ('P','U')) ;
select b.uniqueness, a.index_name, a.table_name, a.column_name from user_ind_columns a, user_indexes bwhere a.index_name=b.index_name order by a.table_name, a.index_name, a.column_position;
Trigger listing
50
SELECT trigger_name, status FROM dba_triggers ;
Tuning: library cache
Glossary: pins = # of time an item in the library cache was executedreloads = # of library cache misses on executionGoal: get hitratio to be less than 1 Tuning parm: adjust SHARED_POOL_SIZE in the initxx.ora file, increasing by small increments
Glossary: gets = # of requests for the item getmisses = # of requests for items in cache which missedGoal: get rcratio to be less than 1 Tuning parm: adjust SHARED_POOL_SIZE in the initxx.ora file, increasing by small increments
Calculation:buffer cache hit ratio = 1 - (phy reads/(db_block_gets + consistent_gets))Goal:get hit ratio in the range 85 - 90%Tuning parm:adjust DB_BLOCK_BUFFERS in the initxx.ora file, increasing by small increments
SELECT NAME, VALUEFROM V$SYSSTAT WHERE NAME IN ('DB BLOCK GETS','CONSISTENT GETS','PHYSICAL READS');
Tuning: sorts
Goal: Increase number of memory sorts vs disk sorts Tuning parm:adjust SORT_AREA_SIZE in the initxx.ora file, increasing by small increments
51
SELECT NAME, VALUEFROM V$SYSTATWHERE NAME LIKE '%SORT%';
Goal: Try to avoid increasing 'undo header' countsTuning method: Create more rollback segments, try to reduce countsSELECT CLASS,COUNTFROM V$WAITSTATWHERE CLASS LIKE '%UNDO%' ;
Tuning: physical file placement
Informational in checking relative usages of the physical data files.
Runaway processes can be killed on the UNIX side, or within server manager.
/* Kill a session, specified by the returned sess-id / serial number */
SELECT sid, serial#, username from v$session
ALTER SYSTEM KILL SESSION 'sessid,ser#'
Archive Log Mode Status
/* Status of Archive Log Subsystem */
ARCHIVE LOG LIST
52
/* log mode of databases */
SELECT name, log_mode FROM v$database;
/* log mode of instance */
SELECT archiver FROM v$instance;
Recovering an Instance
An incomplete recovery is the only option if backups are run periodically on a cold instance. Complete recovery is possible if archive logging is enabled, and backups are run while the database is active.
/* diagnose data file problem */select * from v$recover_file ;
/* diagnose data file problem, by displaying tablespace info */select file_id, file_name, tablespace_name, statusfrom dba_data_files ;
/* find archive log files */select * from v$recovery_log ;
/* incomplete recovery #1 */
svrmgrl> shutdown abort
[[ In Unix copy data files from backup area to data directory(s). ]]
svrmgrl> connect;svrmgrl> startup;
/* incomplete recovery #2 */
svrmgrl> shutdown abort;svrmgrl> connect;svrmgrl> startup mount;svrmgrl> alter database rename file '/data2/ts05.dbf' to '/backups/ts05.dbf'svrmgrl> alter database open;
/* incomplete recovery #3, for user error (i.e. drop table ) */Note: archive logs must exist in LOG_ARCHIVE_DEST
svrmgrl> shutdown abort
[[ backup all files ]] [[ restore required data file(s), using OS commands ]]
svrmgrl> connect;svrmgrl> startup mount;svrmgrl> recover database until time '2002-03-04:15:00:00' ;svrmgrl> alter database open resetlogs;
53
/* complete recovery #1, for major recovery operations, closed instance */Note: archive logs must exist in LOG_ARCHIVE_DEST
/* complete recovery #2, for major/minor recovery operations, open instance */Note: archive logs must exist in LOG_ARCHIVE_DEST
svrmgrl> shutdown abort
[[ backup all files ]] [[ restore corrupted data files, using OS commands ]]
svrmgrl> connect;svrmgrl> startup mount;svrmgrl> set autorecovery on ;svrmgrl> recover tablespace ts03 ; < or >svrmgrl> recover datafile 4 ;svrmgrl> startup open;
List log file information
These queries list the status / locations of the redo log files.
select group#, member, status from v$logfile ;
select group#,thread#,archived,status from v$log ;
A Simple Monitoring Tool
This tool loops a specified number of times, displaying memory usage along with user process counts for a specific username.
--=================================================---- proc_ora_monitor---- parm1: username to count-- parm2: number of loops, 5 sec duration------=================================================
54
set serveroutput on ;
create or replace procedure proc_ora_monitor ( user1 in varchar, reps1 in integer )is
i number ;usercount1 number ;memory1 number ;date1 varchar(20) ;msg varchar(99) ;
begin
i := 0 ;
while ( i < reps1 ) loop msg := '=> ' || to_char(SYSDATE, 'HH:MM:SS PM');
select count(1) into usercount1 from sys.v_$session where username = user1 ;
select round(sum(bytes)/1024/1024 ,2) into memory1 from sys.v_$sgastat where pool = 'shared pool' and name = 'free memory' ;
msg := msg || ', free mb = ' || memory1 ;
select round(sum(bytes)/1024/1024 ,2) into memory1 from sys.v_$sgastat where pool = 'shared pool' and name = 'processes' ;
msg := msg || ', processes mb = ' || memory1 ;
dbms_output.put_line(msg) ;
dbms_lock.sleep(5) ;
i := i + 1 ;end loop ;
end;/
show errors ;
execute proc_ora_monitor('SILVERUSER',2) ;
exit
55
Connection Errors
-------------------------------------------------------ORA-01034: ORACLE not available-------------------------------------------------------TNS-12564: TNS:connection refused-------------------------------------------------------TNS-12530: Unable to start a dedicated server process-------------------------------------------------------Connection errors can crop up out of nowhere ; the error message tend to be vague, and not useful at all. Here's a plan of attack which will solve many connection issues. Try each step, and proceed if the problem persists.
1) Check your environment ; verify the variables depicted below are set. ( NT: check the registry ) The example below details a Solaris/CSH environment. Note the TWO_TASK setting ...
Also verify the oracle user owns the oracle directory tree.
6) Check the pfile, verify the settings detailed below. For this example, the machine should have at least 512mb of memory, to handle the OS and other processes.
# 100 MB shared pool memory shared_pool_size = 104857600
# 65 processes need 130 MB of additional memory
processes = 65 sessions = 65
Solaris: check the "shared memory" and "semaphores" settings
57
also, in the /etc/system file.
7) Look at sqlnet.log ; also check the alert log in $ORACLE_HOME/admin/$ORACLE_SID/bdump
8) Verify the Oracle version, SQLNet version, and patched OS are all compatible.
9) If the problem is still a mystery, the server may need to be restarted.
Explain Plan: syntax
Below is sample syntax for explain plan ( getting output from the optimizer )
delete from plan_table where statement_id = '9999';commit;
COL operation FORMAT A30COL options FORMAT A15COL object_name FORMAT A20
/* ------ Your SQL here ------*/
EXPLAIN PLAN set statement_id = '9999' forselect count(1) from asia_monthly_pricing_data where order_id > 5000/
/*----------------------------*/
select operation, options, object_name from plan_table where statement_id = '9999'start with id = 0connect by prior id=parent_id and prior statement_id = statement_id;
exit/
58
Oracle 9i Articles
Oracle9i Database: New Features For Administrators OCP Exam Articles Oracle9i Database Release 2: New Features Oracle9i Installation Articles Oracle9i XML Articles Oracle9i Web Articles Oracle9i Miscellaneous Articles Oracle9i Application Server Articles
Oracle9i Database: New Features For Administrators OCP Exam Articles
Oracle9i: New Features For Administrators Exam Tips - Some tips on what to expect when upgrading your OCP to Oracle9i.
ANSI ISO SQL Support In Oracle9i - Check out the new SQL enhancements to bring Oracle in line with the ANSI/ISO SQL: 1999 standards.
Automatic Segment Free Space Management - Reduce segment header contention and wasted space within blocks by switching from using FreeLists to Automatic Segment Free Space Management.
Automatic Undo Management - Replace you existing rollback segments with self-tuning undo segments.
Bitmap Join Indexes - Increase the performance and reduce the size of your data warehouse.
Character Semantics And Globalization - Prevent storage problems associated with mutlibyte character sets by using character semantics when defining table columns.
Data Guard - Oracle9i Data Guard is the new name for Oracle8i Standby Database incorporating a large number of new features. This article discusses those relevant to the Oracle9i Database: New Features For Administrators OCP exam.
Export And Import Enhancements In Oracle9i - See what new functionality has been incorporated into the Export and Import utilities in Oracle9i.
Flashback Query - Get a consistent view of the your data at a previous point in time.
High Availability Enhancements in Oracle9i - Reduce downtime for users by using the new high availability features of Oracle9i.
Index Organized Table (IOT) Enhancements in Oracle9i - Better support for secondary indexes and improved online maintenance make IOTs nearly as flexible as heap tables.
Index Skip Scanning - See how Oracle9i uses composite indexes even when the leading edge is not referenced.
LOB Enhancements In Oracle9i - Kickstart the conversion from LONG and RAW columns to CLOB and BLOB columns.
Logminer Enhancements In Oracle9i - A summary of the new features introduced in Oracle9i.
Memory Management In Oracle9i - See how easy memory management has become in Oracle9i.
Metadata API - Extract DDL or XML definitions of all database objects using this simple API.
Multiple Block Sizes - Improve efficiency by having multiple block sizes that relate more closely to the operations that are being performed.
Oracle Managed Files - Let Oracle manage operating system level file placement, naming and cleanup.
Partitioning Enhancements In Oracle9i - Check out the additions and enhancements to partitioning in Oracle9i.
Performance Enhancements In Oracle9i - Read about some of the new performance features in Oracle9i.
Persistent Initialization Parameters - Make database parameter changes persist between shutdowns.
Real Application Clusters - A brief introduction to the Oracle9i replacement for Oracle Parallel Server.
Recovery Enhancements In Oracle9i - Reduce unplanned downtime by using the new crash, instance and media recovery features of Oracle9i.
Recovery Manager (RMAN) Enhancements In Oracle9i - Use the latest RMAN features which make backup and recovery quicker and more reliable.
Resource Manager Enhancements In Oracle9i - Manage system resources more precisely using the Resource Manager enhancements in Oracle9i.
Resumable Space Allocation - Make long running operations suspend rather than abort if they encounter space errors.
Scalable Session Management - Learn about the new session management features in Oracle9i.
Security Enhancements In Oracle9i - A run through the new security features available in Oracle9i, focusing on those relevant for the Oracle9i Database: New Features For Administrators OCP exam.
SQL New Features In Oracle9i - Check out the new SQL features with emphasis on those relevant for the Oracle9i Database: New Features For Administrators OCP exam.
Workspace Management In Oracle9i - Allow multiple transactionally consistent environments to exist within one database.
Oracle9i Database Release 2: New Features
Associative Arrays - Oracle9i Release 2 allows you to index-by string values using this renamed collection.
Bulk Binds and Record Processing in Oracle9i Release 2 - Take advantage of bulk binds for performance improvements whilst using record structures.DBNEWID Utility - Change the internal DBID and the database name using this new utility without rebuilding your controlfile.
DBMS_XPLAN - Easily format the output of an explain plan with this replacement for the utlxpls.sql script.
Export BLOB Contents Using UTL_FILE - Use the new UTL_FILE functionality to write binary data to files.
FTP From PL/SQL - A description of two methods for triggering FTP jobs directly from PL/SQL.
InterMedia - Import-Export Of Images - Use Oracle interMedia to store and retrieve images without using Java stored procedures.
Renaming Columns And Constraints - Oracle9i Release 2 now allows the renaming of columns and constraints. Check out the syntax here.
SQL/XML - Oracle9i Release 2 includes functionality to support the emerging SQL/XML standard to simplify XML generation from SQL queries.
STATISTICS_LEVEL - Let Oracle9i Release 2 control the collection of statistics and advisories with a single parameter.
Streams - Based on Advanced Queuing and LogMinor, Oracle Streams form a distributed messaging technology that can be used for a variety of tasks including messaging, replication and ETL processes.
UTL_FILE Enhancements - Oracle9i Release 2 includes some long overdue enhancements including basic file handling and support for NCHAR and RAW data.
UTL_FILE - Random Access of Files - Use the UTL_FILE package for random access of files from PL/SQL.
XML DB - Store and retrieve XML documents from the Oracle XML DB repository using HTTP, FTP and WebDAV in seconds.
XMLSEQUENCE - Use this operator to split multi-value results from XMLTYPE queries into multiple rows.
Oracle9i (9.2.0.4.0) Installation On Fedora Core 1 Linux - A brief guide to installing Oracle9i (9.2.0.4.0) on Fedora Core 1 Linux.
Oracle9i (9.2.0.1.0) Installation On RedHat 8.0 Linux - A brief guide to installing Oracle9i (9.2.0.1.0) on RedHat 8.0 Linux.
Oracle9i (9.2.0.1.0) Installation On RedHat 9.0 Linux - A brief guide to installing Oracle9i (9.2.0.1.0) on RedHat 9.0 Linux.
Oracle9i (9.2.0.4.0) Installation On RedHat Advanced Server 2.1 Linux - A brief guide to installing Oracle9i (9.2.0.4.0) on RedHat Advanced Server 2.1 Linux.
Oracle9i (9.2.0.4.0) Installation On RedHat Advanced Server 3.0 Linux - A brief guide to installing Oracle9i (9.2.0.4.0) on RedHat Advanced Server 3.0 Linux.
Oracle9i (9.2.0.1.0) Installation On Tru64 5.1b - A brief guide to installing Oracle9i (9.2.0.1.0) on Tru64 5.1b.
Oracle9i RAC Installation On Tru64 - A brief guide to installing Oracle9i (9.2.0.4.0) Real Application Clusters (RAC) on Tru64 5.1b.
Manual Oracle Uninstall - Having trouble removing all Oracle software using the OUI? Try these methods.
Oracle9i XML Articles
Load XMLTYPE From File - A simple method to load XMLTYPE data from a file.
Parse XML Documents - Explode unstructured XML documents into relational tables using the new integrated XDB packages.
XML DB - Store and retrieve XML documents from the Oracle XML DB repository using HTTP, FTP and WebDAV in seconds.
SQL/XML - Oracle9i Release 2 includes functionality to support the emerging SQL/XML standard to simplify XML generation from SQL queries.
XMLSEQUENCE - Use this operator to split multi-value results from XMLTYPE queries into multiple rows.
XMLType Datatype - Store XML documents in tables and query them using SQL.
XML Generation In Oracle9i Using DBMS_XMLQuery, DBMS_XMLGen, Sys_XMLGen And Sys_XMLAgg -
Generate XML and perform XSL transformations with ease using the new XML features of Oracle9i.
XML-Over-HTTP - XML-over-HTTP was the precursor to web services allowing easy access to XML via HTTP GETs and POSTs.
XSQL Servlet and XSQL Pages - Publish dynamic XML documents through HTTP using the XSQL Servlet utility.
Oracle9i Web Articles
Consuming Web Services - Access web services directly from PL/SQL using this simple API.
Email From PL/SQL In Oracle9i - Email from PL/SQL rather than using external procedures or Java.
File Upload and Download Procedures - Upload and download files directly from the database using Database Access Descriptors.
FTP From PL/SQL - A description of two methods for triggering FTP jobs directly from PL/SQL.
Images from Oracle Over HTTP - Retrieve images directly from the database over HTTP.
Java Server Pages - Use Java as a scripting language to interact with the database from web pages.
PL/SQL Server Pages - Use PL/SQL as a scripting language to generate web pages directly from the database.
PL/SQL Web Toolkit - Generate web pages directly from the database using this simple toolkit.
SQL*Plus Web Reports - Generate HTML reports directly from SQL*Plus.
Stateless Locking Methods - Learn how to avoid data loss in stateless environments.
Oracle9i Miscellaneous Articles
Advanced Queuing In Oracle9i - Get to grips with the basics of advanced queuing in Oracle9i.
Archivelog Mode On RAC - The differences between resetting the archive log mode on a single node instance and a Real Application Cluster (RAC).
CASE Expressions And Statements - Learn how to use CASE expressions in both SQL and PL/SQL. In addition, learn how to use the CASE statement in PL/SQL.
Complete Data Audit - A simple and generic solution for auditing before and after snapshots of data.
Compressed Tables - Compress whole tables or individual table partitions to reduce disk space requirements.
Duplicate a Database Using RMAN - Use RMAN to create a duplicate, or clone, of a database from a recent backup.
DBMS_LDAP - Accessing LDAP From PL/SQL - Use the DBMS_LDAP package to query and modify LDAP entries from PL/SQL.
DBMS_LIBCACHE - Warm up the library cache of an instance by compiling the SQL and PL/SQL statements from the library cache of another instance.
DBMS_PROFILER - Profile the run-time behaviour of PL/SQL code to identify potential bottlenecks.
DBMS_TRACE - Trace the run-time behaviour of PL/SQL code to identify potential bottlenecks.
Oracle9iAS (9.0.2.0.1) Portal Installation On Windows 2000 - A brief guide to installing Oracle9iAS (9.0.2.0.1) Portal on Windows 2000.
SQL*Loader
Maximazing SQL*Loader Performance
Use Direct Path Loads - The conventional path loader essentially loads the data by using standard insert statements. The direct path loader (direct=true) loads directly into the Oracle data files and creates blocks in Oracle database block format. There are certain cases, however, in which direct path loads cannot be used (clustered tables). To prepare the database for direct path loads, the script $ORACLE_HOME/rdbms/admin/catldr.sql.sql must be executed.
Disable Indexes and Constraints. For conventional data loads only, the disabling of indexes and constraints can greatly enhance the performance.
Use a Larger Bind Array. For conventional data loads only, larger bind arrays limit the number of calls to the database and increase performance. The size of the bind array is specified using the bindsize parameter. The bind array's size is equivalent to the number of rows it contains (rows=) times the maximum length of each row.
Use ROWS=n to Commit Less Frequently. For conventional data loads only, the rows parameter specifies the number of rows per commit. Issuing fewer commits will enhance performance.
Use Parallel Loads. Available with direct path data loads only, this option allows multiple SQL*Loader jobs to execute concurrently.
Use Fixed Width Data. Fixed width data format saves Oracle some processing when parsing the data. The savings can be tremendous.
Disable Archiving During Load. While this may not be feasible in certain environments, disabling database archiving can increase performance considerably.
Use unrecoverable. The unrecoverable option (unrecoverable load data) disables the writing of the data to the redo logs. This option is available for direct path loads only.
Using the table table_with_one_million_rows, the following benchmark tests were performed with the various SQL*Loader options. The table was truncated after each test.
direct=falsebindsize=512000rows=10000database in noarchivelog
85 37%
direct=true 47 65%
direct=trueunrecoverable
41 70%
direct=trueunrecoverablefixed width data
41 70%
The results above indicate that conventional path loads take the longest. However, the bindsize and rows parameters can aid the performance under these loads. The test involving the conventional load didn’t come close to the performance of the direct path load with the unrecoverable option specified.It is also worth noting that the fastest import time achieved for this table (earlier) was 67 seconds, compared to 41 for SQL*Loader direct path – a 39% reduction in execution time. This proves that SQL*Loader can load the same data faster than import. These tests did not compensate for indexes. All database load operations will execute faster when indexes are disabled.
SQL*Loader Control File
The control file is a text file written in a language that SQL*Loader understands. The control file describes the task that the SQL*Loader is to carry out. The control file tells SQL*Loader where to find the data, how to parse and interpret the data, where to insert the data, and more. See Chapter 4, "SQL*Loader Case Studies" for example control files. Although not precisely defined, a control file can be said to have three sections:
1. The first section contains session-wide information, for example: o global options such as bindsize, rows, records to skip, etc. o INFILE clauses to specify where the input data is located o data character set specification
2. The second section consists of one or more "INTO TABLE" blocks. Each of these blocks contains information about the table into which the data is to be loadedsuch as the table name and the columns of the table.
3. The third section is optional and, if present, contains input data.
Examples
Case 1: Loading Variable-Length Data Loads stream format records in which the fields are delimited by commas and may be enclosed by quotation marks. The data is found at the end of the control file.
Case 2: Loading Fixed-Format Fields: Loads a datafile with fixed-length fields, stream-format records, all records the same length.
Case 3: Loading a Delimited, Free-Format File Loads data from stream format records with delimited fields and sequence numbers. The data is found at the end of the control file.
Case 4: Loading Combined Physical Records Combines multiple physical records into one logical record corresponding to one database row
Case 5: Loading Data into Multiple Tables Loads data into multiple tables in one run
Case 6: Loading Using the Direct Path Load Method Loads data using the direct path load method
Case 7: Extracting Data from a Formatted Report Extracts data from a formatted report
Case 8: Loading Partitioned Tables Loads partitioned tables.
Case 9: Loading LOBFILEs (CLOBs) Adds a CLOB column called RESUME to the table emp, uses a FILLER field (RES_FILE), and loads multiple LOBFILEs into the emp table.
Case 10: How to use TRIM, TO_NUMBER, TO_CHAR, User Defined Functions with SQL*Loader How to use the functions TRIM, TO_CHAR/TO_NUMBER, and user defined functions in connection with SQL*Loader
Case 11: Calling Stored Functions How to call a Function from SQL*Loader
OPTIONS Clause
Continue Interrupted Load
Identifying Data Files
Loading into Non-Empty Tables
Loading into Multiple Tables
Case 1: Loading Variable-Length Data
A simple control file identifying one table and three columns to be loaded. Including data to be loaded from the control file itself, so there is no separate datafile. Loading data in stream format, with both types of delimited fields -- terminated and enclosed.
Control File 1) LOAD DATA2) INFILE *3) INTO TABLE dept4) FIELDS TERMINATED BY ',' OPTIONALLY ENCLOSED BY '"'5) (deptno, dname, loc)6) BEGINDATA
Notes:1. The LOAD DATA statement is required at the beginning of the control file. 2. INFILE * specifies that the data is found in the control file and not in an external file. 3. The INTO TABLE statement is required to identify the table to be loaded (DEPT) into. By default,
SQL*Loader requires the table to be empty before it inserts any records. 4. FIELDS TERMINATED BY specifies that the data is terminated by commas, but may also be enclosed
by quotation marks. Datatypes for all fields default to CHAR. 5. Specifies that the names of columns to load are enclosed in parentheses. Since no datatype is
specified, the default is a character of length 255.
BEGINDATA specifies the beginning of the data.
Invoking SQL*LoaderTo run this example, invoke SQL*Loader with the command:sqlldr userid=scott/tiger control=ulcase1.ctl log=ulcase1.log
Case 2: Loading Fixed-Format Fields
A separate datafile. Data conversions.
In this case, the field positions and datatypes are specified explicitly.Control File1) LOAD DATA2) INFILE 'ulcase2.dat'3) INTO TABLE emp4) (empno POSITION(01:04) INTEGER EXTERNAL, ename POSITION(06:15) CHAR, job POSITION(17:25) CHAR, mgr POSITION(27:30) INTEGER EXTERNAL, sal POSITION(32:39) DECIMAL EXTERNAL, comm POSITION(41:48) DECIMAL EXTERNAL,5) deptno POSITION(50:51) INTEGER EXTERNAL,6) modifieddate "SYSDATE", 7) customerid constant "0")Notes:
1. The LOAD DATA statement is required at the beginning of the control file. 2. The name of the file containing data follows the keyword INFILE. 3. The INTO TABLE statement is required to identify the table to be loaded into. 4. Lines 4 and 5 identify a column name and the location of the data in the datafile to be loaded into
that column. EMPNO, ENAME, JOB, and so on are names of columns in table EMP. The datatypes (INTEGER EXTERNAL, CHAR, DECIMAL EXTERNAL) identify the datatype of data fields in the file, not of corresponding columns in the EMP table.
68
5. Note that the set of column specifications is enclosed in parentheses. 6. This statement let me insert the current sysdate in this field 7. This statement let me put a constant value
Datafile
Below are a few sample data lines from the file ULCASE2.DAT. Blank fields are set to null automatically.
7782 CLARK MANAGER 7839 2572.50 107839 KING PRESIDENT 5500.00 107934 MILLER CLERK 7782 920.00 107566 JONES MANAGER 7839 3123.75 207499 ALLEN SALESMAN 7698 1600.00 300.00 307654 MARTIN SALESMAN 7698 1312.50 1400.00 30.Case 3: Loading a Delimited, Free Format File
Loading data (enclosed and terminated) in stream format Loading dates using the datatype DATE Using SEQUENCE numbers to generate unique keys for loaded data Using APPEND to indicate that the table need not be empty before inserting new records Using Comments in the control file set off by double dashes Overriding general specifications with declarations for individual fields
In this case, the field positions and datatypes are specified explicitly.Control File
This control file loads the same table as in Case 2, but it loads three additional columns (HIREDATE, PROJNO, LOADSEQ). The demonstration table EMP does not have columns PROJNO and LOADSEQ. So if you want to test this control file, add these columns to the EMP table with the command:ALTER TABLE EMP ADD (PROJNO NUMBER, LOADSEQ NUMBER)The data is in a different format than in Case 2. Some data is enclosed in quotation marks, some is set off by commas, and the values for DEPTNO and PROJNO are separated by a colon.1) -- Variable-length, delimited and enclosed data format LOAD DATA2) INFILE *3) APPEND INTO TABLE emp4) FIELDS TERMINATED BY "," OPTIONALLY ENCLOSED BY '"' (empno, ename, job, mgr,5) hiredate DATE(20) "DD-Month-YYYY", sal, comm, deptno CHAR TERMINATED BY ':', projno,6) loadseq SEQUENCE(MAX,1))7) BEGINDATA8) 7782, "Clark", "Manager", 7839, 09-June-1981, 2572.50,, 10:101 7839, "King", "President", , 17-November-1981,5500.00,,10:102 7934, "Miller", "Clerk", 7782, 23-January-1982, 920.00,, 10:102 7566, "Jones", "Manager", 7839, 02-April-1981, 3123.75,, 20:101 7499, "Allen", "Salesman", 7698, 20-February-1981, 1600.00, (same line continued) 300.00, 30:103 7654, "Martin", "Salesman", 7698, 28-September-1981, 1312.50, (same line continued) 1400.00, 3:103 7658, "Chan", "Analyst", 7566, 03-May-1982, 3450,, 20:101Notes:
1. Comments may appear anywhere in the command lines of the file, but they should not appear in data. They are preceded with a double dash that may appear anywhere on a line.
69
2. INFILE * specifies that the data is found at the end of the control file. 3. Specifies that the data can be loaded even if the table already contains rows. That is, the table
need not be empty. 4. The default terminator for the data fields is a comma, and some fields may be enclosed by double
quotation marks ("). 5. The data to be loaded into column HIREDATE appears in the format DD-Month-YYYY. The length of
the date field is a maximum of 20. If a length is not specified, the length is a maximum of 20. If a length is not specified, then the length depends on the length of the date mask.
6. The SEQUENCE function generates a unique value in the column LOADSEQ. This function finds the current maximum value in column LOADSEQ and adds the increment (1) to it to obtain the value for LOADSEQ for each row inserted.
7. BEGINDATA specifies the end of the control information and the beginning of the data. 8. Although each physical record equals one logical record, the fields vary in length so that some
records are longer than others. Note also that several rows have null values for COMM.
Case 4: Loading Combined Physical Records
Combining multiple physical records to form one logical record with CONTINUEIF Inserting negative numbers. Indicating with REPLACE that the table should be emptied before the new data is inserted Specifying a discard file in the control file using DISCARDFILE Specifying a maximum number of discards using DISCARDMAX Rejecting records due to duplicate values in a unique index or due to invalid data values
Control File LOAD DATA INFILE 'ulcase4.dat'1) DISCARDFILE 'ulcase4.dsc'2) DISCARDMAX 9993) REPLACE4) CONTINUEIF THIS (1) = '*' INTO TABLE emp (empno POSITION(1:4) INTEGER EXTERNAL, ename POSITION(6:15) CHAR, job POSITION(17:25) CHAR, mgr POSITION(27:30) INTEGER EXTERNAL, sal POSITION(32:39) DECIMAL EXTERNAL, comm POSITION(41:48) DECIMAL EXTERNAL, deptno POSITION(50:51) INTEGER EXTERNAL, hiredate POSITION(52:60) INTEGER EXTERNAL)Notes:
DISCARDFILE specifies a discard file named ULCASE4.DSC. DISCARDMAX specifies a maximum of 999 discards allowed before terminating the run (for all
practical purposes, this allows all discards). REPLACE specifies that if there is data in the table being loaded, then SQL*Loader should delete
that data before loading new data. CONTINUEIF THIS specifies that if an asterisk is found in column 1 of the current record, then the
next physical record after that record should be appended to it to from the logical record. Note that column 1 in each physical record should then contain either an asterisk or a non-data value.
Data FileThe datafile for this case, ULCASE4.DAT, is listed below. Note the asterisks in the first position and, though not visible, a new line indicator is in position 20 (following "MA", "PR", and so on). Note that CLARK's commission is -10, and SQL*Loader loads the value converting it to a negative number.
70
*7782 CLARK MANAGER 7839 2572.50 -10 2512-NOV-85*7839 KING PRESIDENT 5500.00 2505-APR-83*7934 MILLER CLERK 7782 920.00 2508-MAY-80*7566 JONES MANAGER 7839 3123.75 2517-JUL-85*7499 ALLEN SALESMAN 7698 1600.00 300.00 25 3-JUN-84*7654 MARTIN SALESMAN 7698 1312.50 1400.00 2521-DEC-85*7658 CHAN ANALYST 7566 3450.00 2516-FEB-84* CHEN ANALYST 7566 3450.00 2516-FEB-84*7658 CHIN ANALYST 7566 3450.00 2516-FEB-84
Rejected RecordsThe last two records are rejected, given two assumptions. If there is a unique index created on column EMPNO, then the record for CHIN will be rejected because his EMPNO is identical to CHAN's. If EMPNO is defined as NOT NULL, then CHEN's record will be rejected because it has no value for EMPNO.Case 5: Loading Data in Multiple Tables
Loading multiple tables Using SQL*Loader to break down repeating groups in a flat file and load the data into normalized
tables -- one file record may generate multiple database rows Deriving multiple logical records from each physical record Using a WHEN clause Loading the same field (EMPNO) into multiple tables
Control File -- Loads EMP records from first 23 characters -- Creates and loads PROJ records for each PROJNO listed -- for each employee LOAD DATA INFILE 'ulcase5.dat' BADFILE 'ulcase5.bad' DISCARDFILE 'ulcase5.dsc'1) REPLACE2) INTO TABLE emp (empno POSITION(1:4) INTEGER EXTERNAL, ename POSITION(6:15) CHAR, deptno POSITION(17:18) CHAR, mgr POSITION(20:23) INTEGER EXTERNAL)2) INTO TABLE proj -- PROJ has two columns, both not null: EMPNO and PROJNO3) WHEN projno != ' ' (empno POSITION(1:4) INTEGER EXTERNAL,3) projno POSITION(25:27) INTEGER EXTERNAL) -- 1st proj3) INTO TABLE proj4) WHEN projno != ' ' (empno POSITION(1:4) INTEGER EXTERNAL,4) projno POSITION(29:31 INTEGER EXTERNAL) -- 2nd proj2) INTO TABLE proj5) WHEN projno != ' ' (empno POSITION(1:4) INTEGER EXTERNAL,5) projno POSITION(33:35) INTEGER EXTERNAL) -- 3rd proj
Notes: REPLACE specifies that if there is data in the tables to be loaded (EMP and PROJ), SQL*loader should
delete the data before loading new rows. Multiple INTO clauses load two tables, EMP and PROJ. The same set of records is processed three
times, using different combinations of columns each time to load table PROJ. WHEN loads only rows with non-blank project numbers. When PROJNO is defined as columns
25...27, rows are inserted into PROJ only if there is a value in those columns. When PROJNO is defined as columns 29...31, rows are inserted into PROJ only if there is a value in
those columns.
71
When PROJNO is defined as columns 33...35, rows are inserted into PROJ only if there is a value in those columns.
Use of the direct path load method to load and index data How to specify the indexes for which the data is pre-sorted. Loading all-blank numeric fields as null The NULLIF clause Note: Specify the name of the table into which you want to load data; otherwise, you will see LDR-
927. Specifying DIRECT=TRUE as a command-line parameter is not an option when loading into a synonym for a table.
In this example, field positions and datatypes are specified explicitly.Control File LOAD DATA INFILE 'ulcase6.dat' INSERT INTO TABLE emp1) SORTED INDEXES (empix)2)(empno POSITION(01:04) INTEGER EXTERNAL NULLIF empno=BLANKS, ename POSITION(06:15) CHAR, job POSITION(17:25) CHAR, mgr POSITION(27:30) INTEGER EXTERNAL NULLIF mgr=BLANKS, sal POSITION(32:39) DECIMAL EXTERNAL NULLIF sal=BLANKS, comm POSITION(41:48) DECIMAL EXTERNAL NULLIF comm=BLANKS, deptno POSITION(50:51) INTEGER EXTERNAL NULLIF deptno=BLANKS)Notes:
The SORTED INDEXES clause identifies indexes:presorting data:case study the indexes on which the data is sorted. This clause indicates that the datafile is sorted on the columns in the EMPIX index. This clause allows SQL*Loader to optimize index creation by eliminating the sort phase for this data when using the direct path load method.
The NULLIF...BLANKS clause specifies that the column should be loaded as NULL if the field in the datafile consists of all blanks
Case 7: Extracting Data from a formatted Report Using SQL*Loader with an INSERT trigger Use of the SQL string to manipulate data Different initial and trailing delimiters Use of SYSDATE Use of the TRAILING NULLCOLS clause
72
Ambiguous field length warnings
Note: This example creates a trigger that uses the last value of unspecified fields.Data FileThe following listing of the report shows the data to be loaded: Today's Newly Hired Employees
Dept Job Manager MgrNo Emp Name EmpNo Salary (Comm)---- -------- -------- ----- -------- ----- --------- ------20 Salesman Blake 7698 Shepard 8061 $1,600.00 (3%) Falstaff 8066 $1,250.00 (5%) Major 8064 $1,250.00 (14%)30 Clerk Scott 7788 Conrad 8062 $1,100.00 Ford 7369 DeSilva 8063 $800.00 Manager King 7839 Provo 8065 $2,975.00
Insert Trigger
In this case, a BEFORE INSERT trigger is required to fill in department number, job name, and manager's number when these fields are not present on a data line. When values are present, they should be saved in a global variable. When values are not present, the global variables are used.The INSERT trigger and the package defining the global variables is:CREATE OR REPLACE PACKAGE uldemo7 AS -- Global Package Variables last_deptno NUMBER(2); last_job VARCHAR2(9); last_mgr NUMBER(4); END uldemo7;/
CREATE OR REPLACE TRIGGER uldemo7_emp_insert BEFORE INSERT ON emp FOR EACH ROWBEGIN IF :new.deptno IS NOT NULL THEN uldemo7.last_deptno := :new.deptno; -- save value for later ELSE :new.deptno := uldemo7.last_deptno; -- use last valid value END IF; IF :new.job IS NOT NULL THEN uldemo7.last_job := :new.job; ELSE :new.job := uldemo7.last_job; END IF; IF :new.mgr IS NOT NULL THEN uldemo7.last_mgr := :new.mgr; ELSE :new.mgr := uldemo7.last_mgr; END IF;END;/
Note: The phrase FOR EACH ROW is important. If it was not specified, the INSERT trigger would only fire once for each array of inserts because SQL*Loader uses the array interface.
Control FileLOAD DATA INFILE 'ULCASE7.DAT' APPEND INTO TABLE emp
73
1) WHEN (57) = '.'2) TRAILING NULLCOLS3) (hiredate SYSDATE,4) deptno POSITION(1:2) INTEGER EXTERNAL(3)5) NULLIF deptno=BLANKS, job POSITION(7:14) CHAR TERMINATED BY WHITESPACE6) NULLIF job=BLANKS "UPPER(:job)",7) mgr POSITION(28:31) INTEGER EXTERNAL TERMINATED BY WHITESPACE, NULLIF mgr=BLANKS, ename POSITION(34:41) CHAR TERMINATED BY WHITESPACE "UPPER(:ename)", empno POSITION(45) INTEGER EXTERNAL TERMINATED BY WHITESPACE, sal POSITION(51) CHAR TERMINATED BY WHITESPACE8) "TO_NUMBER(:sal,'$99,999.99')",9) comm INTEGER EXTERNAL ENCLOSED BY '(' AND '%' ":comm * 100" )Notes:
The decimal point in column 57 (the salary field) identifies a line with data on it. All other lines in the report are discarded.
The TRAILING NULLCOLS clause causes SQL*Loader to treat any fields that are missing at the end of a record as null. Because the commission field is not present for every record, this clause says to load a null commission instead of rejecting the record when only six fields are found instead of the expected seven.
Employee's hire date is filled in using the current system date. This specification generates a warning message because the specified length does not agree with
the length determined by the field's position. The specified length (3) is used. Because the report only shows department number, job, and manager when the value changes,
these fields may be blank. This control file causes them to be loaded as null, and an RDBMS insert trigger fills in the last valid value.
The SQL string changes the job name to uppercase letters. It is necessary to specify starting position here. If the job field and the manager field were both
blank, then the job field's TERMINATED BY BLANKS clause would cause SQL*Loader to scan forward to the employee name field. Without the POSITION clause, the employee name field would be mistakenly interpreted as the manager field.
Here, the SQL string translates the field from a formatted character string into a number. The numeric value takes less space and can be printed with a variety of formatting options.
In this case, different initial and trailing delimiters pick the numeric value out of a formatted field. The SQL string then converts the value to its stored form.
Case 8: Loading Partitioned Tables Partitioning of data Explicitly defined field positions and datatypes. Loading using the fixed record length option
Control FileLOAD DATA1) INFILE 'ulcase10.dat' "fix 129"BADFILE 'ulcase10.bad'TRUNCATEINTO TABLE lineitemPARTITION (ship_q1)2) (l_orderkey position (1:6) char, l_partkey position (7:11) char, l_suppkey position (12:15) char, l_linenumber position (16:16) char, l_quantity position (17:18) char, l_extendedprice position (19:26) char,
74
l_discount position (27:29) char, l_tax position (30:32) char, l_returnflag position (33:33) char, l_linestatus position (34:34) char, l_shipdate position (35:43) char, l_commitdate position (44:52) char, l_receiptdate position (53:61) char, l_shipinstruct position (62:78) char, l_shipmode position (79:85) char, l_comment position (86:128) char)Notes:
Specifies that each record in the datafile is of fixed length (129 characters in this example). See Input Data and Datafiles.
Identifies the column name and location of the data in the datafile to be loaded into each column.
Table CreationIn order to partition the data the lineitem table is created using four (4) partitions according to the shipment date:Create table lineitem(l_orderkey number, l_partkey number, l_suppkey number, l_linenumber number, l_quantity number, l_extendedprice number, l_discount number, l_tax number, l_returnflag char, l_linestatus char, l_shipdate date, l_commitdate date, l_receiptdate date, l_shipinstruct char(17), l_shipmode char(7), l_comment char(43))partition by range (l_shipdate)( partition ship_q1 values less than (TO_DATE('01-APR-1996', 'DD-MON-YYYY')) tablespace p01, partition ship_q2 values less than (TO_DATE('01-JUL-1996', 'DD-MON-YYYY')) tablespace p02, partition ship_q3 values less than (TO_DATE('01-OCT-1996', 'DD-MON-YYYY')) tablespace p03, partition ship_q4 values less than (TO_DATE('01-JAN-1997', 'DD-MON-YYYY')) tablespace p04)Input Data File
The datafile for this case, ULCASE8.DAT, is listed below. Each record is 129 characters in length. Note that five(5) blanks precede each record in the file. 1 151978511724386.60 7.04.0NO09-SEP-6412-FEB-9622-MAR-96DELIVER IN PERSONTRUCK iPBw4mMm7w7kQ zNPL i261OPP 1 2731 73223658958.28.09.06NO12-FEB-9628-FEB-9620-APR-96TAKE BACK RETURN MAIL 5wM04SNyl0AnghCP2nx lAi 1 3370 3713 810210.96 .1.02NO29-MAR-9605-MAR-9631-JAN-96TAKE BACK RETURN REG AIRSQC2C 5PNCy4mM 1 5214 46542831197.88.09.06NO21-APR-9630-MAR-9616-MAY-96NONE AIR Om0L65CSAwSj5k6k 1 6564 6763246897.92.07.02NO30-MAY-9607-FEB-9603-FEB-96DELIVER IN PERSONMAIL CB0SnyOL PQ32B70wB75k 6Aw10m0wh 1 7403 160524 31329.6 .1.04NO30-JUN-9614-MAR-9601 APR-96NONE FOB C2gOQj OB6RLk1BS15 igN
75
2 8819 82012441659.44 0.08NO05-AUG-9609-FEB-9711-MAR-97COLLECT COD AIR O52M70MRgRNnmm476mNm 3 9451 721230 41113.5.05.01AF05-SEP-9629-DEC-9318-FEB-94TAKE BACK RETURN FOB 6wQnO0Llg6y 3 9717 1834440788.44.07.03RF09-NOV-9623-DEC-9315-FEB-94TAKE BACK RETURN SHIP LhiA7wygz0k4g4zRhMLBAM 3 9844 1955 6 8066.64.04.01RF28-DEC-9615-DEC-9314-FEB-94TAKE BACK RETURN REG AIR6nmBmjQkgiCyzCQBkxPPOx5j4hB 0lRywgniP1297
Case 9: Loading LOB Files (CLOBs)
Adding a CLOB column called RESUME to the table emp. Using a FILLER field (RES_FILE). Loading multiple LOBFILEs into the emp table.
Control FileLOAD DATAINFILE *INTO TABLE EMPREPLACEFIELDS TERMINATED BY ','( EMPNO INTEGER EXTERNAL, ENAME CHAR, JOB CHAR, MGR INTEGER EXTERNAL, SAL DECIMAL EXTERNAL, COMM DECIMAL EXTERNAL, DEPTNO INTEGER EXTERNAL,1) RES_FILE FILLER CHAR,2) "RESUME" LOBFILE (RES_FILE) TERMINATED BY EOF NULLIF RES_FILE = 'NONE')BEGINDATA7782,CLARK,MANAGER,7839,2572.50,,10,ulcase91.dat7839,KING,PRESIDENT,,5500.00,,10,ulcase92.dat7934,MILLER,CLERK,7782,920.00,,10,ulcase93.dat7566,JONES,MANAGER,7839,3123.75,,20,ulcase94.dat7499,ALLEN,SALESMAN,7698,1600.00,300.00,30,ulcase95.dat7654,MARTIN,SALESMAN,7698,1312.50,1400.00,30,ulcase96.dat7658,CHAN,ANALYST,7566,3450.00,,20,NONE
Notes: This is a filler field. The filler field is assigned values from the datafield to which it is mapped. RESUME is loaded as a CLOB. The LOBFILE function is used to specify the name of the field that
specifies name of the file which contains the data for the LOB field.
Case 10: How to use TRIM, TO_NUMBER, TO_CHAR with SQL*Loader This note explains how to use the functions TRIM, TO_CHAR/TO_NUMBER, and user defined functions in connection with SQL*Loader using the following example:
-- Create the table DROP TABLE TEST; CREATE TABLE TEST ( ID NUMBER PRIMARY KEY, FIRST_NAME VARCHAR2(20), LAST_NAME VARCHAR2(20) NOT NULL, DEPARTMENT VARCHAR2(20) NOT NULL,
SALARY NUMBER(10,2) NOT NULL, BONUS NUMBER(10,2), DESCRIPTION VARCHAR2(50), TOTAL NUMBER(10,2) );
-- Create the user defined functions (used by SQL*Loader) CREATE OR REPLACE FUNCTION GET_BONUS (dept IN VARCHAR2) RETURN NUMBER AS retval NUMBER(10,2); BEGIN retval := NULL; if upper (dept) in ('CLERK', 'SALESMAN') then if to_char (sysdate, 'YYYY') = '2002' then retval := 9.2; else retval := 7.88; end if; elsif upper (dept) = 'ANALYST' then retval := 18.7; elsif upper (dept) = 'MANAGER' then retval := -5.92; end if; return (retval); END; /
CREATE OR REPLACE FUNCTION CALC_SAL (sal IN NUMBER, bon IN NUMBER) RETURN NUMBER AS retval NUMBER(10,2); BEGIN if bon is null then retval := sal; else retval := round (sal + (sal * bon / 100), 2); end if; return (retval); END; /
The table TEST will be loaded with this control file:
LOAD DATA INFILE * INTO TABLE TEST TRUNCATE FIELDS TERMINATED BY ';' OPTIONALLY ENCLOSED BY '"' TRAILING NULLCOLS ( ID SEQUENCE, FIRST_NAME "TRIM (:FIRST_NAME)", -- 1) LAST_NAME "TRIM ('x' FROM :LAST_NAME)", -- 2) DEPARTMENT, SALARY "TO_NUMBER (:SALARY, '99999D99', -- 3) 'NLS_NUMERIC_CHARACTERS='',.''')", BONUS "GET_BONUS (:DEPARTMENT)", -- 4) DESCRIPTION "'Salary: '||:SALARY||' -> '|| -- 5) DECODE (GET_BONUS (:DEPARTMENT), NULL, 'No bonus',
BEGINDATA " Martin ";"xxxxxxxSmithxxx";CLERK;2459,25 " David ";"xxxxxxxAllenxxx";SALESMAN;4563,9 " Brad ";"xxxxxxxWardxxxx";SALESMAN;4815,81 " Marvin ";"xxxxxxxJonesxxx";MANAGER;9765,33 " Dean ";"xxxxxxxMartinxx";SALESMAN;4214,56 " John ";"xxxxxxxBlakexxx";MANAGER;10333,87 " Clark ";"xxxxxxxGablexxx";MANAGER;11011,11 " Scott ";"xxxxxxxTigerxxx";ANALYST;6865,88 " Ralph ";"xxxxxxxKingxxxx";PRESIDENT;18955,45 " Tina ";"xxxxxxxTurnerxx";SALESMAN;5324,44 " Bryan ";"xxxxxxxAdamsxxx";CLERK;1899,48 " Jesse ";"xxxxxxxJamesxxx";CLERK;2288,99 " John ";"xxxxxxxFordxxxx";ANALYST;7564,83 " John ";"xxxxxxxMillerxx";CLERK;1865,93
1) TRIM deletes the leading/trailing blanks in the column FIRST_NAME (i.e. " Martin " becomes "Martin") 2) TRIM deletes the leading/trailing 'x' characters in the column LAST_NAME (i.e. "xxxxxxxSmithxxx" becomes "Smith") 3) TO_NUMBER shows that the format of the numbers in the column SALARY is in the form: 99999D99. That means max. 5 digits integer with max. 2 digit post-decimal positions. The decimal separator is ','. If the format is not specified, then the records are not loaded (ORA-1722 invalid number, if NLS_NUMERIC_CHARACTERS = '.,') 4) The column BONUS is calculated with the user defined function GET_BONUS. The Function expects an input parameter, DEPARTMENT (VARCHAR2), and returns the value, BONUS (NUMBER(2,2)) 5) The column DESCRIPTION is a composition of the information from the previous columns. The Function DECODE checks if a bonus is available to the department. If no bonus is available, then the message 'No bonus' will be printed. The new thing here is the function TO_CHAR. This function modifies the format of the BONUS in this form: sign, 2 integer digits with leading zeros, decimal separator, 2 post-decimal positions with trailing zeros. 6) The column TOTAL is calculated with the user defined function CALC_SAL (the BONUS, if available, is applied to the SALARY)
The result after the loading procedure looks like this in the table TEST: SQL> select * from test;
ID FIRST_NAME LAST_NAME DEPARTMENT SALARY ---------- -------------------- -------------------- -------------------- ---------- 1 Martin Smith CLERK 2459.25 2 David Allen SALESMAN 4563.9 3 Brad Ward SALESMAN 4815.81 4 Marvin Jones MANAGER 9765.33 5 Dean Martin SALESMAN 4214.56 6 John Blake MANAGER 10333.87 7 Clark Gable MANAGER 11011.11 8 Scott Tiger ANALYST 6865.88 9 Ralph King PRESIDENT 18955.45 10 Tina Turner SALESMAN 5324.44 11 Bryan Adams CLERK 1899.48 12 Jesse James CLERK 2288.99 13 John Ford ANALYST 7564.83 14 John Miller CLERK 1865.93
78
Case 11: Calling a Stored Function from SQL*Loader This small example shows how to call a stored function. It is possible to call any built-in or user-defined function during load process. Usually it's done for date columns, when non-default date format must be used, however user-defined function(s) may be called to perform some application logic. The syntax for such calls is quite simple:
Here LDR_PCK.NAME is name of package and function, :dnname and :deptno are parameters.
When calling user-defined functions we must remember that only conventional path may be used. An attempt to use direct path will cause an error: SQL*Loader-00417 SQL String (on column column_name) not allowed in direct path.
The OPTIONS Clause
The OPTIONS clause is useful when you usually invoke a control file with the same set of options, or when the command line and all its arguments becomes very long. This clause allows you to specify runtime arguments in the control file rather than on the command line.
SKIP = n -- Number of logical records to skip (DEFAULT 0) LOAD = n -- Number of logical records to load (DEFAULT all) ERRORS = n -- Number of errors to allow (DEFAULT 50) ROWS = n -- Number of rows in conventional path bind array (DEFAULT 64) BINDSIZE = n -- Size of conventional path bind array in bytes SILENT = {HEADER | FEEDBACK | ERROR | DISCARDS | ALL }
Values specified on the command line override values specified in the control file. With this precedence, the OPTIONS keyword in the control file established default values that are easily changed from the command line.
Continuing Interrupted Loads
If SQL*Loader runs out of space for data rows or index entries, the load is discontinued. (For example, the table might reach its maximum number of extents.) Discontinued loads can be continued after more space is made available.
79
When a load is discontinued, any data already loaded remains in the tables, and the tables are left in a valid state. SQL*Loader's log file tells you the state of the tables and indexes and the number of logical records already read from the input data file. Use this information to resume the load where it left off.
For example:
SQLLOAD / CONTROL=FAST1.CTL SKIP=345
CONTINUE\_LOAD DATA statement is used to continue a discontinued direct path load involving multiple tables with a varying number of records to skip. For more information on this command, see chapter 6 of ``ORACLE7 Server Utilities Users Guide''.
Identifying Data Files
To specify the file containing the data to be loaded, use the INFILE or INDDN keyword, followed by the filename. A filename specified on the command line overrides the first INFILE or INDDN statement in the control file. If no filename is specified, the filename defaults to the control filename with an extension or filetype of DAT.
Loading into Non-Empty Database Tables
SQL*Loader does not update existing records, even if they have null columns. If the tables you are loading already contain data, you have three choices for how SQL*Loader should proceed:
INSERT - This is the default option. It requires the table to be empty before loading. SQL*Loader terminates with an error if the table contains rows.
APPEND - If data already exists in the table, SQL*Loader appends the new rows to it; if data doesn't already exist, the new rows are simply loaded.
REPLACE - All rows in the table are deleted and the new data is loaded. This option requires DELETE privileges on the table.
You can create one logical record from multiple physical records using CONCATENATE and CONTINUEIF. See chapter 6 of ``ORACLE7 Server Utilities Users Guide''.
Loading Logical Records into Tables
The INTO TABLE clause allows you to tell which table you want to load data into. To load multiple tables, you would include one INTO TABLE clause for each table you wish to load.
The INTO TABLE clause may continue with some options for loading that table. For example, you may specify different options (INSERT, APPEND, REPLACE) for each table in order to tell SQL*Loader what to do if data already exists in the table.
The WHEN clause appears after the table name and is followed by one or more field conditions. For example, the following clause indicates that any record with the value ``q'' in the fifth column position should be loaded:
WHEN (5) = 'q'
A WHEN clause can contain several comparisons as long as each is preceded by AND. Parentheses are optional but should be used for clarity with multiple comparisons joined by AND. For example:
WHEN (DEPTNO = '10') AND (JOB = 'SALES')
80
To evaluate the WHEN clause, SQL*Loader first determines the values of all the fields in the record. Then the WHEN clause is evaluated. A row is inserted into the table only if the WHEN clause is true.
When the control file specifies more fields for a record than are present in the record, SQL*Loader must determine whether the remaining (specified) columns should be considered null, or whether an error should be generated. TRAILING NULLCOLS clause tells SQL*Loader to treat any relatively positioned columns that are not present in the record as null columns. For example, if the following data
10 Accounting
is read with the following control file
INTO TABLE dept TRAILING NULLCOLS ( deptno CHAR TERMINATED BY " ", dname CHAR TERMINATED BY WHITESPACE, loc CHAR TERMINATED BY WHITESPACE )
and the record ends after DNAME, then the remaining LOC field is set to null. Without the TRAILING NULLCOLS clause, an error would be generated, due to missing data.
Oracle datatypes
Datatype summary for Oracle 7, 8 & 9
Datatype DescriptionMax Size:Oracle 7
Max Size:Oracle 8
Max Size:Oracle 9
Max Size:PL/SQL
PL/SQLSubtypes/Synonyms
VARCHAR2(size)
Variable length character string having maximum length size bytes.You must specify size
2000 bytesminimum is 1
4000 bytesminimum is 1
4000 bytesminimum is 1
32767 bytesminimum is 1
STRINGVARCHAR
NVARCHAR2(size) Variable length national character set string having maximum length size bytes.You must specify
N/A 4000 bytesminimum is 1
4000 bytesminimum is 1
32767 bytesminimum is 1
STRINGVARCHAR
81
size
VARCHAR
Now deprecated - VARCHAR is a synonym for VARCHAR2 but this usage may change in future versions.
- - -
CHAR(size)
Fixed length character data of length size bytes. This should be used for fixed length data. Such as codes A100, B102...
255 bytesDefault and minimum size is 1 byte.
2000 bytesDefault and minimum size is 1 byte.
2000 bytesDefault and minimum size is 1 byte.
32767 bytesDefault and minimum size is 1 byte.
CHARACTER
NCHAR(size)
Fixed length national character set data of length size bytes. This should be used for fixed length data. Such as codes A100, B102...
N/A
2000 bytesDefault and minimum size is 1 byte.
2000 bytesDefault and minimum size is 1 byte.
32767 bytesDefault and minimum size is 1 byte.
NUMBER(p,s) Number having precision p and scale s.
The precision p can range from 1 to 38.
The scale s can range from -84 to 127.
The precision p can range from 1 to 38.
The scale s can range from -84 to 127.
The precision p can range from 1 to 38.
The scale s can range from -84 to 127.
Magnitude1E-130 .. 10E125
maximum precision of 126 binary digits, which is roughly equivalent to 38 decimal digits
The scale s can range from -84 to 127.
For floating point don't specify p,s
REAL has a maximum precision of 63 binary digits,
fixed-point numbers:DECDECIMALNUMERIC
integers:INTEGERINTSMALLINT
floating-point:DOUBLE PRECISION FLOAT
REAL
82
which is roughly equivalent to 18 decimal digits
PLS_INTEGER
signed integersPLS_INTEGER values require less storage and provide better performance than NUMBER values.So use PLS_INTEGER where you can!
PL/SQL only
PL/SQL only
PL/SQL only
magnitude range is -2147483647 .. 2147483647
BINARY_INTEGERsigned integers (older slower version of PLS_INTEGER)
magnitude range is -2147483647 .. 2147483647
LONG
Character data of variable length (A bigger version the VARCHAR2 datatype)
2 Gigabytes
2 Gigabytes
2 Gigabytes - but now deprecated
32760 bytesNote this is smalller than the maximum width of a LONG column
DATE Valid date range
from January 1, 4712 BC to December 31, 4712 AD.
from January 1, 4712 BC to December 31, 9999 AD.
from January 1, 4712 BC to December 31, 9999 AD.
from January 1, 4712 BC to December 31, 9999 AD.(in Oracle7 = 4712 AD)
TIMESTAMP (fractional_seconds_precision)
the number of digits in the fractional part of the SECOND datetime field.
- -
Accepted values of fractional_seconds_precision are 0 to 9. (default = 6)
TIMESTAMP (fractional_seconds_precision) WITH {LOCAL} TIMEZONE
As above with time zone displacement value
- -
Accepted values of fractional_seconds_precision are 0 to 9. (default = 6)
INTERVAL YEAR (year_precision) TO
Time in years and months, where
- - Accepted values are 0 to 9. (default = 2)
83
MONTH
year_precision is the number of digits in the YEAR datetime field.
INTERVAL DAY (day_precision) TO SECOND (fractional_seconds_precision)
Time in days, hours, minutes, and seconds.
day_precision is the maximum number of digits in 'DAY'
fractional_seconds_precision is the max number of fractional digits in the SECOND field.
- -
day_precision may be 0 to 9. (default = 2)
fractional_seconds_precision may be 0 to 9. (default = 6)
RAW(size)
Raw binary data of length size bytes.You must specify size for a RAW value.
Maximum size is 255 bytes.
Maximum size is 2000 bytes
Maximum size is 2000 bytes
32767 bytes
LONG RAW
Raw binary data of variable length. (not intrepreted by PL/SQL)
2 Gigabytes.
2 Gigabytes.
2 Gigabytes - but now deprecated
32760 bytesNote this is smalller than the maximum width of a LONG RAW column
ROWID
Hexadecimal string representing the unique address of a row in its table.(primarily for values returned by the ROWID pseudocolumn.)
Hexadecimal string representing the unique address of a row in its table.(primarily for values returned by the ROWID pseudocolumn.)
UROWID Hex string representing the logical address of a row of an index-organized table
N/A The maximum size and default
The maximum size and default is 4000 bytes
universal rowid - Hex string representing the
See CHARTOROWID and the package:
84
is 4000 bytes
logical address of a row of an index-organized table, either physical, logical, or foreign (non-Oracle)
DBMS_ROWID
MLSLABEL
Binary format of an operating system label.This datatype is used with Trusted Oracle7.
CLOB Character Large Object
4Gigabytes
4Gigabytes
4Gigabytes 4Gigabytes
NCLOB National Character Large Object
4Gigabytes
4Gigabytes 4Gigabytes
BLOB Binary Large Object 4Gigabytes
4Gigabytes 4Gigabytes
BFILEpointer to binary file on disk
4Gigabytes 4Gigabytes
The size of a BFILE is system dependent but cannot exceed four gigabytes (2**32 - 1 bytes).
Notes (pro's & cons)
INTEGERThis ANSI datatype will be accepted by Oracle - it is actually a synonym for NUMBER(38)
VARCHAR2:Storing character data as Varchar2 will save space:
Store 'SMITH' not 'SMITH '
CHAR:Over time, when varchar2 columns are updated they will sometimes create chained rows - because CHAR columns are fixed width they are not affected by this - so less DBA effort is required to maintain performance.
NUMBERWhen retrieving data for a NUMBER column, consider (if you can) using the PL/SQL datatype: PLS_INTEGER
Oracle8i also allows you to rebuild your indexes while online. In the past, creating or rebuilding the index required a full lock on the table. On a large table, this could mean that an application is unusable for several hours.Now, however, Oracle allows you to create or rebuild the index while users can still perform the full range of data processes. To do this, Oracle creates the index structure before populating it. While populating, all changes to the table are recorded in a journal table. As the index is completed, the journal table changes are then built in. Brief table locks are made while the index structure is made and the journal table bought into the index.
To build an index on line, you use the following syntax:CREATE INDEX my_index ON my_table (my_field) ONLINE;
The importance of PCTFREE
86
For a B-Tree index, PCTFREE determines the extent of a leaf-split. In other words, PCTFREE indicates the amount of free-space within a block for “future updates”. However in the case of an index (unlike a table), these updates do not make sense, since an update anyway forces a delete and subsequent insert. In the case of indexes, PCTFREE plays a role mostly at the time of index-creation. A non-zero value specifies the block-splitting ratio. If PCTFREE is set to 20, during index-creation, up to 80% of the leaf may contain key-information.However the remaining 20% should be available for future inserts of key-information into that leaf-block. This ensures that during run-time inserts, there is minimal overhead in terms of incurring leaf-block splits.Even though a higher PCTFREE may cause index-creation time to increase, it prevents the performance-hit from being deferred to actual usage time. So, the end-user, who is waiting for a row to be inserted, does not incur the performance penalty associated with a leaf-block split.Based on this information, the following points emerge:PCTFREE for an index is used primarily during creation. It is ignored during actual usage.Specify a higher PCTFREE for OLTP applications, if the table is a popular one, incurring a lot of DML changes (via interactive user-screens);If the index-creation time is critical specify a lower PCTFREE. This will pack in more rows per leaf-block, thereby avoiding the need for further splitting at creation-time. This is of paramount significance to shops that have “24x7” availability requirements. Index-creation in most cases requires considerable downtime (especially if the table is a multi-million row table). Lesser the amount of index-creation time, smaller can be the maintenance-window. I have seen this tiny, often unnoticed parameter save around 20% of index-creation time. At a high-availability site, an index on a table containing around 11 million rows took me about 80 minutes to build using PCTFREE of 30 and a parallel degree of 4. The same index on the same table, with 13.5 million rows took me around 90 minutes to create with a PCTFREE of 0 (without any hardware/software enhancements). Nologging (minimal redo) was on during both creations.For any column where the values are constantly increasing, it is probably a good idea to set a very low PCTFREE (even, zero). This is because only the rightmost leaf-block will always be inserted into. This will make the tree grow towards the right. The leftmost leaves would remain static. So, there is no sense in leaving any part of those blocks empty with a non-zero PCTFREE.
1- Partitioned IndexesLike tables, indexes can also be partitioned; but with indexes you have a more options because the underlying table might or might not also be partitioned. The objective of this type of index is to separate the index into smaller partitions, just as we do now for a database table. There are essentially two different types of partitioned indexes available:
Global indexes--These are created in a manner different from the underlying partitioning of the table that is indexed.
Local indexes--These are partitioned in the same manner as the underlying table partitioning.
Global IndexesTo create a global partitioned index, use the CREATE INDEX parameter GLOBAL. This specifies that the index will be a global index. Further partitioning of the index is accomplished by using the following parameters:
GLOBAL--This parameter specifies a global partitioned index. PARTITION part_name--This parameter is used to identify the partition. If you do not specify the
partition name, a default name will be provided. It is not usually necessary to provide the partition name.
VALUES LESS THAT--This parameter is used to specify the range that is allocated for that particular partition in the same way as the partition was specified in the CREATE TABLE statement (discussed yesterday).
NOTE: The last partition should contain the keyword MAXVALUE for its range.
Creating a partitioned index.CREATE INDEX "ETW".dogs_ix1ON DOGS (ID)PARTITION BY RANGE (ID)PARTITION pt1 VALUES LESS THAN (`1000') TABLESPACE ts1,
87
PARTITION pt2 VALUES LESS THAN (MAXVALUE) TABLESPACE ts2);
ANLYSIS:This create two partitions, the first holding values of ID that are less than 1,000, the second holding the remaining values of ID. If you do not specify the partition name, as is the case here, a default name will be provided. While this does offer a great deal of flexibility, it is not without cost. Since global partitioned indexes are not directly related to any single table partition, operations that affect any partition in the table can render all global partitioned indexes unusable. Specifically the operations:
Local IndexesIn contrast to the global index, a local partitioned index is individually created on each partition. If you specify a local partitioned index, Oracle automatically maintains the index's partitioning along with that of the underlying table.Local partitioned indexes are created through the use of the LOCAL parameter with the CREATE INDEX statement. It is unnecessary to provide partitioning information because the underlying table partitioning will be used. A local index can be created with the following syntax:
CREATE INDEX "ETW".dogs_ix1ON DOGS (ID)LOCAL;
Because the index is local, all partition changes to the table will be automatically reflected on the index partitions as well.Local partitioned indexes have some inherent advantages that are similar to the advantages you get from partitioned tables. These advantages include the following:
Because the index exists entirely on one partition, any maintenance operations affect only that one partition.
The Oracle optimizer can use the local index to generate better query plans based on the fact that a local index is used.
If a partition is lost and must be recovered, only the data and index for that particular partition needs to be recovered. With a global index, the entire index would need recovery.
As you can see, there are many advantages of using both global and local partitioned indexes.
2- Index-Only TablesMany systems contain several small tables (1 to 3 columns) where all of the elements form the primary key. This is typically the case of tables created to physically implement conceptual relations of the type O,n O,n. However, there exists an extremely efficient way to create such tables, by using a B*-Tree structure. In ORACLE 8, an index-organized table, that is a table with the same physical structure as an index, allows us to do exactly that. In an index-organized table, the database engine will place the data values in a « table » segment, but with a B*-tree structure.An index-only table is a schema object introduced in Oracle8. An index-only table is similar to an index, but whereas an index contains the primary key value and a ROWID pointing to where the data is kept, the index-only table stores the column data in the leaf block of the index.Because the leaf blocks of the Oracle index are traditionally very small and tightly packed, there can be some drawbacks to having large rows stored there. Oracle has developed a way to compensate for this: If rows become too large (by a set threshold), the row data is stored in an overflow area as specified in the CREATE TABLE statement. This creates storage more like the traditional index and table relationship.An index-only table contains the same structure as the Oracle B*-tree index. Only the leaf blocks have changed. Index-only tables have many of the attributes of both indexes and tables, but there are a few exceptions:
Because it is part index and part table, no other indexes can be added to the index-only table. The UNIQUE constraint is not allowed on an index-only table. A trigger can be added to the index-only table.
88
An index-only table cannot be stored in a cluster. Replication is not supported at this time.
As you can see, there are some restrictions on index-only tables, but there is also a great deal of benefits. When performing inserts, there is a performance improvement, since only a single segment needs to be updated, which is the table itself. Data retrieval is also faster since the optimizer processes the table just as if it were an index. Furthermore, one read operation is saved since ORACLE doesn't have to read the index prior to performing the read in the table.
When to Use Index-Only TablesIndex-only tables are very useful whenever data is always accessed via the primary key index. If this is the case with your data, the index-only table will cut down on the space used by both the index and the table (by combining them) and improve performance. Performance is improved because, by the time the ROWID would have been retrieved, you have the data.Tables that are not accessed via the primary key value are not good candidates for index-only tables. Also, tables whose primary key values are updated and tables that have frequent insertions are not good candidates for index-only tables.
How to Create Index-Only TablesIndex-only tables are created with the CREATE TABLE command; the ORGANIZATION INDEXED qualifier is used to identify the table as index-only. The following qualifiers are used in creating index-only tables:
ORGANIZATION INDEXED--This qualifier specifies an index-only table organization. OVERFLOW TABLESPACE ts_name--This qualifier specifies the overflow tablespace name. PCTTHRESHOLD threshold--This qualifier specifies the percent of a block that a row must be larger
than in order to be offloaded to the overflow tablespace.
Creating an index-only table with the CREATE TABLE command.CREATE TABLE "ETW".DOGS (ID NUMBER,NAME VARCHAR2(40),OWNER_ID NUMBER,BREED_ID NUMBER,RANK NUMBER NULL,NOTES VARCHAR2(80)PRIMARY KEY(ID) )ORGANIZATION INDEXEDPCTTHRESHOLD 40OVERFLOW TABLESPACE "DOGS2"TABLESPACE "DOGS";
ANLYSIS:This specifies that the index-only tablespace be created on the DOGS tablespace, whereas the overflow tablespace used is DOGS2.
NOTE: It is necessary to specify the PRIMARY KEY value when creating an index-only table. This is the value on which the index is created.
Unfortunately, there are also some disadvantages to using index-organized tables. For example, it is not possible to create additional indexes since the occurrences of this type of table do not have a ROWID. It is also impossible to add new columns or to modify existing columns. The message « ORA-25182 feature not currently available for index-organized table » is used to alert us to these restrictions. Another factor to consider is the case where updating key values is allowed. ORACLEmust delete the old record and do an insert based on the new key value, that is relocate a leaf of the B*-tree to another location in the B*-tree. The net result is 2 SQL operations. Therefore, one should weight the advantages and disadvantages before choosing this type of table, even though it is relatively easy to convert an index-organized table back to a conventional format using create table as and then doing an Import/Export to that table.
3- Bitmap IndexesAnother type of index available the bitmap index. With the traditional index you saw earlier, Oracle uses a
89
B*-tree method to traverse the index to find the leaf block. With a bitmap index, a bitmap of ROWIDs is kept; this bitmap indicates which rows correspond to the index item. If the bit is set, this indicates that the corresponding row contains the key value; if the bit is not set, the opposite is true.As you can probably tell, bitmap indexes can probably be quite useful under the right circumstances, and useless overhead otherwise.
When to Use Bitmap IndexesAs you can probably guess, the bitmap index works well on items with low cardinality. Low cardinality means there is a small amount of variance in the possible values stored in that column. For example, the column representing the sex of the dog is said to have low cardinality because only two values are possible. Other column types that might have low cardinality include
Marital status Account status (good or bad) Sales region (if there are only a few) Rank (if there are only a few) Special notes (whether there is a note)
With columns that have low cardinality, the bitmap index can greatly improve performance. Columns with high cardinality are not candidates for bitmap indexes. Locking issues affect data manipulation operations in Oracle. As a result, bitmapped indexes are not appropriate for OLTP applications that have a high level of concurrent insert, update and delete operations. Concurrency is usually not an issue in a data-warehousing environment where the data is maintained by bulk loads, inserts and updates. In addition, bitmapped index maintenance is deferred until the end of the bulk DML operation. If 100 rows are inserted into a table, the inserted rows are placed into a sort buffer and the updates of all 100-index entries are applied as a group. As a result, bitmapped indexes are appropriate for most decision support applications (even those that have bulk updates applied on a regular basis). Mass updates, inserts and delete will run faster if you drop the bitmapped indexes, execute the DML and recreate the bitmapped indexes when the DML completes. Run timings using the straight DML and compare it to the total time consumed by the drop bitmapped index/execute DML/recreate bitmapped index process.
How to Create Bitmapped IndexesA bitmap index is created with the CREATE INDEX command with the BITMAP qualifier. For example, the following will create a bitmap index:CREATE BITMAP INDEXTo create a bitmap index on the SEX field in the DOGS table, you can use the following syntax:CREATE BITMAP INDEX "ETW".dogs_bx1ON DOGS (SEX);This simple statement will create the bitmap index on the column specified. At this time, bitmap indexes cannot be created with the graphical tools.
4- Reverse Key IndexesWhen a column that contains an incrementally increasing value (like those provided by sequences) is indexed, there is a very poor distribution of that value across the B-tree, and hot spots can be introduced into the index. Reverse-key indexes can help eliminate these hot spots by providing a much wider distribution of values than would occur in a regular B-tree index. In this situation, simultaneous inserts requested by the users are done in the same leaf of the index. This will generate contention on the same Oracle block buffer. This problem is exacerbated when several tasks are initiated in parallel, all processing updates against the database. Another problem is the phenomena of « sliding » when the system deletes older numbers and inserts new ones. In this case, the index becomes increasingly large as the space occupied by the deleted index entries never gets reused.The answer to this situation is the reverse-key index whereby different index leafs is used, even if the key sequence is chronological.
How to Create Reverse Key IndexesCREATE INDEX my_index ON my_table (my_fields) REVERSE;
90
To make an existing index a reverse index use:ALTER INDEX index_name REBUILD REVERSE;
Substitute no reverse if you want to rebuild you index as a non-reversed one. No options are without a certain cost. While reverse-key indexes can help in the distribution of data across an index, this very strength can be a weakness. Since the actual (non-reversed) values of the index are not stored sequentially in the index, index range-scans cannot be performed. Only fetch-by-key and full index scans can be performed on a reverse-key index. Therefore, it is not a good idea to build a reverse-key index on a column that might use range-scans.
5- Function Based IndexesFunction based indexes are really going to improve the performance of all those queries which use functions such as SUM, AVG in the select or when the where clause includes some kind of other function such as some mathematical calculation on two columns. Suppose you have an application that routinely selects the sum of the two columns SALARY and BONUS from the PAYMENTS table. In the past, such a select may have been fairly slow, because of the calculation being performed on the select. Now, however, the calculation is stored as part of the index, making the overall selection process that much quicker.
How to Create Function Based IndexesCREATE INDEX my_ind ON payments (salary + bonus);
Also, to use a function-based index:The must be analyzed before it can be usedThe query must be guaranteed not to need any NULL values from the indexed expression, since
NULL values are not stored in indexes.
6- Descending IndexesDescending indexes are a special type of function-based index, in which index entries are sorted in
descending order. Using the DESC clause does this. When creating an index, as in the example below:create index ix_descon phonebook2(zip desc);
There are a couple special considerations when using descending indexes: Descending indexes cannot be used on reverse indexes The DESC option is ignored if used in the creation of bitmap indexes The COMPATIBLE initialization parameter must be set to 8.1.0
91
Knowing when to Rebuild Indexes
Where is the index now?
In order to understand what we must do with the index, we must first get an idea of the current state of the index. This can be accomplished by using the ANALYZE INDEX VALIDATE STRUCTURE command. Normally, the ANALYZE INDEX command creates either computed or estimated statistics for the index that can be seen in the DBA_INDEXES view. This action may produce unintentional side effects, especially if the index has not previously been analyzed. The VALIDATE STRUCTURE command can be safely executed without affecting the optimizer. The VALIDATE STRUCTURE command populates the SYS.INDEX_STATS table only. The SYS.INDEX_STATS table can be accessed with the public synonym INDEX_STATS. The INDEX_STATS table will only hold validation information for one index at a time. You will need to query this table before validating the structure of the next index.
Below is an example of ANALYZE INDEX VALIDATE STRUCTURE and sample output from INDEX_STATS:
ANALYZE INDEX shopping_basket_pk VALIDATE STRUCTURE;
SELECT name,height,lf_rows,lf_blks,del_lf_rows,distinct_keys,used_space FROM INDEX_STATS;
There are two rules of thumb to help determine if the index needs to be rebuilt. If it is determined that the index needs to be rebuilt, this can easily be accomplished by the ALTER INDEX REBUILD command. Although not necessarily recommended, this command could be executed during normal operating hours. Rebuilding the index uses the existing index as a basis. The alternative is to drop and re-create the index. Creating an index uses the base table as its data source that needs to put a lock on the table. The index is also unavailable during creation.
First rule of thumb is if the index has height greater than four, rebuild the index. For most indexes, the height of the index will be quite low, i.e. one or two. I have seen an index on a 3 million-row table that had height three. An index with height greater than four may need to be rebuilt as this might indicate a skewed tree structure. This can lead to unnecessary database block reads of the index. It is helpful to know the data structure for the table and index. Most times, the index height should be two or less, but there are exceptions.
The second rule of thumb is that the deleted leaf rows should be less than 20% of the total number of leaf rows. An excessive number of deleted leaf rows indicates that a high number of deletes or updates have occurred to the index column(s). The index should be rebuilt to better balance the tree. The INDEX_STATS table can be queried to determine if there are excessive deleted leaf rows in relation to the total number of leaf rows. Let’s look at an example:
ANALYZE INDEX item_basket_pk VALIDATE STRUCTURE;
SELECT name,height,lf_rows,del_lf_rows, (del_lf_rows/lf_rows)*100 as ratio FROM INDEX_STATS;
NAME HEIGHT LF_ROWS DEL_LF_ROW RATIO ------------------------------ ---------- ---------- ---------- ----------ITEM_BASKET_PK 1 235 74 31.4893617
In this example, the ratio of deleted leaf rows to total leaf rows is clearly above 20%. This is a good candidate for rebuilding. Let’s rebuild the index and examine the results.
ALTER INDEX item_basket_pk REBUILD;
ANALYZE INDEX item_basket_pk VALIDATE STRUCTURE;
92
SELECT name,height,lf_rows,del_lf_rows, (del_lf_rows/lf_rows)*100 as ratio FROM INDEX_STATS;
NAME HEIGHT LF_ROWS DEL_LF_ROW RATIO ------------------------------ ---------- ---------- ---------- ----------ITEM_BASKET_PK 1 161 0 0
The index is rebuilt and validated once again. Examining the INDEX_STATS table shows that the 74 deleted leaf rows were dropped from the index. Notice that the total number of leaf rows went from 235 to 161, which is a difference of 74 leaf rows. This index should provide better performance for the application.
Script to find indexes to rebuild
Below is a sample script that can be run to determine which indexes need to be rebuilt. For those indexes that need to be rebuilt, the ALTER INDEX REBUILD command is dynamically generated as output. The user can tailor the height and percentage of deleted leaf rows by altering the vMaxHeight and vMaxDel variables. The output of this script can be spooled to a file. This file can then be run to rebuild the indexes.
-- validate_idx.sql---- This script will check indexes to find candidates for rebuilding.-- Run this script in SQL*Plus as a user with SELECT ANY TABLE-- privileges.---- This script can be used and modified without permission. Run this-- script at your own risk! The script author is not responsible for-- any problems that may arise from running this script.
set serveroutput on size 100000
DECLARE vOwner dba_indexes.owner%TYPE; /* Index Owner */ vIdxName dba_indexes.index_name%TYPE; /* Index Name */ vAnalyze VARCHAR2(100); /* String of Analyze Stmt */ vCursor NUMBER; /* DBMS_SQL cursor */ vNumRows INTEGER; /* DBMS_SQL return rows */ vHeight index_stats.height%TYPE; /* Height of index tree */ vLfRows index_stats.lf_rows%TYPE; /* Index Leaf Rows */ vDLfRows index_stats.del_lf_rows%TYPE; /* Deleted Leaf Rows */ vDLfPerc NUMBER; /* Del lf Percentage */ vMaxHeight NUMBER; /* Max tree height */ vMaxDel NUMBER; /* Max del lf percentage */ CURSOR cGetIdx IS SELECT owner,index_name FROM dba_indexes WHERE OWNER NOT LIKE 'SYS%';BEGIN /* Define maximums. This section can be customized. */ vMaxHeight := 3; vMaxDel := 20;
/* For every index, validate structure */ OPEN cGetIdx; LOOP FETCH cGetIdx INTO vOwner,vIdxName; EXIT WHEN cGetIdx%NOTFOUND; /* Open DBMS_SQL cursor */
93
vCursor := DBMS_SQL.OPEN_CURSOR; /* Set up dynamic string to validate structure */ vAnalyze := 'ANALYZE INDEX ' || vOwner || '.' || vIdxName || ' VALIDATE STRUCTURE'; DBMS_SQL.PARSE(vCursor,vAnalyze,DBMS_SQL.V7); vNumRows := DBMS_SQL.EXECUTE(vCursor); /* Close DBMS_SQL cursor */ DBMS_SQL.CLOSE_CURSOR(vCursor); /* Does index need rebuilding? */ /* If so, then generate command */ SELECT height,lf_rows,del_lf_rows INTO vHeight,vLfRows,vDLfRows FROM INDEX_STATS; IF vDLfRows = 0 THEN /* handle case where div by zero */ vDLfPerc := 0; ELSE vDLfPerc := (vDLfRows / vLfRows) * 100; END IF; IF (vHeight > vMaxHeight) OR (vDLfPerc > vMaxDel) THEN DBMS_OUTPUT.PUT_LINE('ALTER INDEX ' || vOwner || '.' || vIdxName || ' REBUILD;'); END IF;
END LOOP; CLOSE cGetIdx;END;/
Database Comparision
Table of Contents
1.Introduction
2.Operational Concerns
a.Scalability
b.Platform Availability
c.Networking & Internet Readiness
3.Vendor Related Issues
a.Licensing
b.Support and Maintenance
94
4.User Considerations
a.DBA Concerns
b.Programmability
5.Conclusion
Appendix A - System Requirements for Microsoft SQL Server 7.0
Appendix B - Maximum Sizes and Numbers of SQL Server 7.0
Appendix C - Scorecard of Microsoft’s SQL Server & Oracle’s 8i
Appendix D - Summary of Features of Microsoft’s SQL Server & Oracle’s 8i
Appendix E - Oracle 8 and Oracle 8i Standard Edition Platform Availability
SQL Server 7.0 Introduction
SQL Server 7.0 is designed to scale from laptop databases and small business servers all the way up to terabyte-size databases.SQL Server 7.0 is designed to operate on Microsoft’s Windows 95, 98 and NT operating systems.However, the Windows 95 & 98 versions of SQL Server 7.0 only support desktop, laptop and small workgroup applications.SQL Server 7.0 for Windows NT Workstation has been developed for applications that involve a large numbers of users and transactions.
Microsoft SQL Server had 30% of the Windows NT database market in 1998, while Oracle had 46.1% of the Windows NT market, which was a 55% growth in 1998.This statistic must be understood in the context that it applies only to the Windows NT platform, since that is the only platform that both Microsoft and Oracle have in common.
Although, Microsoft has taken a big step forward in enterprise capability with the SQL Server 7.0, it seems like their product is more appropriate for departmental and small to mid-sized companies.“Rewritten for ease of use, Microsoft’s SQL Server 7.0 is far and away the best choice for smaller organizations or branch offices that need a full-featured relational database.Larger organizations will find SQL Server a better performer than ever before, although competing databases including Oracle 8 and DB2 continue to provide better programmability and scalability.”[ii]
In speaking with a few experienced database administrators and programmers, SQL Server really is not known as a competitor with the “big boys” of the relational database software market.The well-known database software products include Oracle, IBM’s DB2, Sybase and Informix.These companies remain leaders in database technology at the enterprise level.
Oracle 8i Introduction
Oracle 8i is a database product that is built upon a mature Oracle 8 product, but also brings increased capabilities to develop and integrate with Internet applications.Oracle’s databases have been developed and proven to handle the largest of enterprise databases.But Oracle also targets smaller, mid-tier companies who find it necessary to have 24 hours by 7 days availability due to increasing Internet business needs.Oracle’s 8i databases are available on a wide variety of platforms.Dell, IBM, Linux, Sun, Fujitsu and Unisys are a few of the 21 listed on Oracle’s web site.
Oracle’s products are definitely not the cheapest on the market. If an evaluation of the application necessitates a high need for reliability, scalability, security and performance then Oracle should be considered. Oracle is the world’s leading supplier of software for information management, holding 27% of
95
the database market share across all platforms.Oracle is the undisputed database leader on UNIX platforms, commanding 60.9% of the market share according to Dataquest.[iii],[iv]
2.Operational Concerns
a. Scalability
Scalability in the context of database software is defined as the software’s ability to continue to perform at a similar level with a larger amount of data and a growing number of users and transactions.
Amount of Data
Both SQL Server 7.0 and Oracle 8i are designed to be client-server database products that can take advantage of distributed database architecture.
A distributed database is a network of databases managed by multiple database servers that appears to a user as a single database. This means the database could be distributed across several disks and servers with multiple processors.The data of all databases in the distributed databases can be simultaneously accessed and modified. The database architecture on the server will dictate how fast the transaction response time is.The speed of transactions can vary greatly based on the database design as well as server hardware configurations, including RAM, the number and speed of the CPUs.
SQL Server 7.0 can grow up to 1,048,516 terra-bytes.Microsoft uses SMP (systems with 4 processors) technology to distribute databases. Other maximum sizes and numbers can be referenced in Appendix C, which outlines other technical specifications of SQL Server 7.0.
Oracle 8i is scalable up to hundreds of terabytes to manage very large databases (VLDB).Oracle takes advantage of distributed processing and storage capabilities through architectural features that use more than one processor to divide the processing for a set of related jobs.This distributed architecture is a good example of the expression “the sum of the parts is greater than the whole”, because as individual processors work on a subset of related tasks, performance of the whole system is improved.
Number of Simultaneous Users
Theoretically, there is no limit to the number of users that can access either the Oracle 8i or SQL Server 7.0 database servers at one time, given infinite processors and infinite speed.In practical terms, there is a limit, but it should not pose any real issues to be concerned with in terms of concurrent data.One consideration is that SQL Servers will require ODBC software to connect with clients that are not PC based.This will require some overhead, but should be pretty negligible.
In a “Score Card” published by ZDNet[v], which is fully documented in Appendix D, the following ratings were published.These ratings really demonstrate the equality of SQL Server and Oracle for these performance criteria.
PC Microsoft SQL Server 7.0
Oracle8i Standard Edition
Server Engine Excellent Good
Support for multiple CPUs Excellent Fair
96
Join and index selection Excellent Excellent
Degree of concurrency Good Excellent
Database Design Good Excellent
Distributed transactions Excellent Excellent
These issues of are fundamental topics when performance is being discussed.
b.Platform Availability
As discussed in the Introduction, SQL Server 7.0 is designed to operate on Microsoft’s Windows 95, 98 and NT 4.0 operating systems.However, the Windows 95 & 98 versions of SQL Server 7.0 will only support desktop, laptop and small workgroup applications and requires an Intel platform.
SQL Server 7.0 for Windows NT Workstation has been developed for applications that involve a large numbers of users and transactions and is limited to Intel or Alpha platforms.
This limitation could cause hurdles for large corporations in terms of performance that can be expected.Brian McCarthy, CEO of Insurance Holdings said “Microsoft said we’d need an all-Microsoft application if we wanted full scalability, but who’s going to rebuild the whole system?”[vi]
It’s especially important to note that although other platforms can be used for clients to access the SQL Server 7.0, a third party ODBC software must be used.ODBC is an interface that allows for data to be accessed in relational databases, independent of the database vendor.
Oracle 8i is supported by a large number of hardware manufacturers, as well as several operating systems.There are currently 21 hardware vendors listed on Oracle’s website, with at least 6 operating systems, counting UNIX as one although the flavors may vary by manufacturer.Reference Appendix F for details on some of the platforms and operating systems that Oracle runs on.Further details can be found on specific platforms at Oracle’s dedicated website:www.platforms.oracle.com.
Networking & Internet Readiness
The need for a database to be Internet ready is quickly becoming a necessity in today’s rapidly growing web based world. At every turn in the software industry, the topic of e-business and e-commerce is a top issue for companies wanting to compete in the future. Therefore, the need for database software to support and enhance Internet application development is a must.
SQL Server 7.0 still lags behind in its ability to support multimedia data support and in programmability, which are necessary for many Internet applications. Third party software will have to be used to store special images, sound, video or geographic data support. SQL Server 7.0 doesn’t support Java, which is an industry standard for developing network applications.
97
Oracle 8i is the best product for companies wanting to move their database applications to the Web. Oracle leads the market in handling of multimedia objects. Multimedia support is particularly relevant when building Web-based applications like online stores that include multimedia items such as pictures or video clips of items for sale. Oracle uses a product call JServer, which brings Java and relational databases together. It allows for controlling the database through Java and supports the creation of JavaBeans. JavaBeans are the basic building blocks for Java-based Internet applications, and are (or will be) supported by just about every high-end Internet application server on the market.
In the ZDNet Scorecard (Appendix D), SQL Server 7.0 and Oracle 8i were rated as follows, in respect to their internet readiness features:
Microsoft SQL Server 7.0 Oracle8i Standard Edition
Multimedia Data Handling
Poor Excellent
Web connectivity Poor Excellent
Support for sound, media, video, images
Poor Excellent
Full text search Good Excellent
3. Vendor Related Issues
a.Licensing
SQL Server
Pricing structures of software can be complex.Microsoft recognizes this and even offers “A Guide to BackOffice Pricing and Licensing” to help readers understand some of the subtleties and complexities before “cutting a check”. SQL Server can be purchased by itself in either of the above-mentioned versions, as an upgrade to certain other database products or as a part of Microsoft BackOffice.A license for the server is distinct from the licenses for the CAL (client access license), but every server is accompanied with a certain number of CALS.Although the number of CALS may vary by application, there would always be a need for at least one CAL or the database could not be accessed to retrieve data.
To compare prices the details of the system architecture must be well understood.Some of those details include the number of servers required to support the database, how many processors a server will have, the number of users needing to access the database, whether the system will be serving an Internet or intranet application.
Based on an application where 250 or more users (CALs) will be accessing one database server, the cost of SQL Server 7.0 Enterprise Version is listed as $28,999 on Microsoft web site.To get an understanding of the price differences between the Enterprise version and the Standard version, SQL Server 7.0 Standard Version and Five CALs would cost $3,999, while the Enterprise version with Five CALs lists at $7999.An upgrade of the SQL Server 7.0 Enterprise version for a customer who is also upgrading the clients accessing the database costs $3969, while a customer who is buying licenses for new clients along with the server license costs $7099.
98
The benefits of the Enterprise Edition over the Standard Edition cited in the Microsoft publications get blurred in the marketing jargon.The Enterprise version is used for increased system scalability and reliability by providing support for SMP (systems with multiple processors) and extended memory
These prices are negotiable and the price varies in terms of how customer acquires the SQL Server.For example, if a customer purchases software that runs on SQL Server or purchases it from an independent software vendor then the pricing would obviously be different.
Oracle 8i
Oracle’s pricing structure is different from Microsoft’s, in that it doesn’t charge per server license or client access license.Rather Oracle charges by licensing units:“named user”, “concurrent system” and “power unit”.
A named user is defined as “an individual who is authorized by his/her company to use the Oracle Software programs, regardless of whether the individual is actively using these programs at any given time.”[vii]
A concurrent device is defined as “an input device accessing the program on the designated system at any given point in time. The number of "Concurrent Devices" you are licensed for is the maximum number of input devices accessing the programs on the Designated System at any given point in time. If multiplexing hardware or software (e.g., a TP Monitor or a Web server product) is used, this number must be measured at the multiplexing front-end.”vii
A power unit is defined as one MHz of power in any Intel compatible or RISC processor in any computer of the Designated Systems on the Order Confirmation page on which the Oracle software programs are installed and operating. (Intel refers to Intel Solaris, Linux, and Windows NT; RISC refers to Sun SPARC Solaris, HP-UX, and IBM/AIX. A "Processor" license shall be for the actual number of processors installed in the licensed computer and running the Oracle program(s), regardless of the number of processors which the computer is capable of running.)”vii
A named user licensing unit costs $600, a concurrent device costs $1495 and a power unit costs $200 for the Oracle 8i Enterprise Edition.These prices are 5 times more than what Oracle charges for the Standard Edition.
The Enterprise Editions includes these advanced features on top of the Standard Edition:large-database partitioning (which helps you keep monster gigabyte-size databases under control), flexible security features, and speed features such as bitmapped indexes, summary tables, and parallelism.
Two other modules that Oracle offers for enhanced web integration and multi-media handling are Oracle JServer Standard Edition and WebDB, which if necessary add to the total cost of the Oracle solution.They are also priced based on the licensing unit discussed above.
b.Support and Maintenance
Availability of qualified database administrators (DBA) and programmers is one issue that cannot be overlooked in considering which database will be best for the given organization and application.Due to the relationship between supply, demand and cost, the shortage of Oracle DBAs and programmers can mean only mean one thing.They are hard to find and when one is available, they command a very high salary.
The nature of Oracle is that it can be more difficult to program and administer, so it requires specially trained personnel.SQL Server, on the other hand, is an easier product to learn and administer so the number of available programmers is higher and less expensive to staff a database project.
No cost information could be obtained on the annual maintenance fees to remain current on the licensing agreements with either Oracle or SQL Server.
99
4. User Considerations
a. Database Administrator (DBA) Concerns
Recovery & Backup
In every database system, the possibility of a system or hardware failure always exists. Should a failure occur and affect the database, the database must be recovered. The goals after a failure are to ensure that the effects of all committed transactions are reflected in the recovered database and to return to normal operations as quickly as possible while insulating users from problems caused by the failure. Databases can fail due power outages, operating system crashes, disk failure or operator error.
Both SQL Server 7.0 and Oracle make commitments on a two-phase commit approach, which allows for users to control a logical set of SQL statements so they all either succeed or fail as a unit. This two-phase mechanism guarantees that no matter what type of system or network failure might occur, a distributed transaction either commits on all involved nodes or rolls back on all involved nodes to maintain data consistency across the global distributed database.
Monitoring & Tuning Capabilities
SQL Server 7.0 is an exceptionally easy product to administer and is more forgiving than previous SQL Server versions.SQL Server 7.0 has an auto-tuning feature that allows for memory to be self-managed and there are several new wizards that simply advanced tasks such as creating databases, scheduling backups, importing and exporting data and configuring replication.This should make the training of database administrators much easier.
Oracle 8i databases can be administered and controlled very tightly, but it is a complex and requires trained database administrators to do so proficiently.“Oracle8i tools are Java-based and can even be run from a Web browser. They provide all the essentials for designing and setting up a database, including some advanced features like letting you selectively delegate authority to users of its Enterprise Manager administration console. This is a handy tool for branch office deployment.Like previous releases of Enterprise Manager, though, this one is a version behind the database, and it doesn't know a thing about new Oracle8i features such as Java stored procedures.”[viii]
b.Programmability
There are languages supported within the database software for programming and controlling the database.For example, since PL/SQL can be stored in the database, network traffic between applications and the database is reduced, thereby increasing application and system performance.
SQL Server 7.0 comes with an internal programming language called Transact-SQL, which has received a poor rating in several reviews.“While everyone else in the SQL database market is moving (or has already moved) to a modern programming language like Java, SQL Server customers are still stuck in the programming Dark Ages—no object orient development, no big class libraries to use, and no code interoperability with anything else.”[ix]The programming can be done, but it will require a lot more work.
Oracle gets an excellent rating for it’s internal language offerings, which include Java and PL/SQL.
5.Conclusion
In comparing these two database products, it became apparent they each hold a different place and purpose in the market.They don’t compete in the same niche.Microsoft SQL Server, a client-server database, continues to make strides toward the enterprise database market, but is still most appropriate
100
for a departmental or small to mid-sized company whose database doesn’t have such high scalability, reliability and availability needs.SQL Server’s greatest weakness is the Windows NT platform, which it operates on, is not mature enough to provide the kind of availability that enterprise worthy systems require.“In the small-business market, the differentiating factors are ease of database administration, Web connectivity, the speed and features of the database server engine, branch-office and mobile support, and the ability to warehouse data efficiently. SQL Server 7.0 shines in all of these areas except Web connectivity. Its administration tools include many wizards and self-tuning settings that make it the only database we reviewed that might not require a specially trained administrator.”[x]
Oracle, also a client-server database, operates on the high end of the database market and is also reaching out to start ups, small to medium sized businesses who have a need for a complete, integrated platform for critical applications for the internet. Oracle is harder to administer is an expensive choice, unless the application being developed requires its Java or multimedia features.Another selling point to Oracle is that is it sold on a multitude of platforms, in comparison to SQL Server 7.0, which may be appealing to some customers who are seeking a more mature platform.
Appendix A
System Requirements for Microsoft SQL Server 7.0*
Client Access Licenses required
Server
PC with a Pentium (166 MHz or higher) or Alpha processor
Microsoft Windows NT Server operating system version 4.0 or Windows NT Server 4.0 Enterprise Edition with Service Pack 4 or later (Service Pack 4 included)
Microsoft Internet Explorer 4.01 with Service Pack 1 or later (both included)
32 MB of RAM
Hard-disk space required:
65–180 MB for Server; approximately 170 MB for typical installation
35–50 MB for OLAP services; approximately 50 MB for typical installation
24–36 MB for English Query; approximately 36 MB for typical installation
CD-ROM drive
VGA or higher-resolution monitor; Super VGA recommended
Microsoft Mouse or compatible pointing device
Note SQL Server 7.0 can utilize up to four processors. Additional processor support is available with SQL Server 7.0 Enterprise Edition.
DesktopIdentical to Server requirements with the following exceptions:
101
Each installation of SQL Server Desktop requires a per-seat client access license for SQL Server 7.0; SQL Server Desktop will only interact with SQL Server in per-seat mode
65–180 MB available hard-disk space; approximately 170 MB for typical installationNote The Desktop version of SQL Server 7.0 can utilize up to two processors.
Networking Support Windows 95, Windows 98, or Windows NT built-in network software (additional network software is not required unless you are using Banyan VINES or AppleTalk ADSP; Novell NetWare client support is provided by NWLink)
Clients Supported Windows 95, Windows 98, or Windows NT Workstation, UNIX,** Apple Macintosh,** and OS/2**
*Actual requirements will vary based on your system configuration and the features you choose to install.
**Requires ODBC client software from a third-party vendor.
Appendix B
Maximum Sizes and Numbers of SQL Server 7.0
This table specifies the maximum sizes and numbers of various objects defined in Microsoft SQL Server databases, or referenced in Transact-SQL statements.
Object SQL Server 7.0
Batch size 128 *Network Packet Size
Bytes per character or binary column 8000
Bytes per text, ntext, or image column 2GB-2
102
Bytes per GROUP BY, ORDER BY 8060
Bytes per index 900
Bytes per foreign key 900
Bytes per primary key 900
Bytes per row 8060
Bytes in source text of a stored procedure
Batch size
Clustered indexes or constraints per table
1
Columns in GROUP BY, ORDER BY Limited only by number of bytes
Columns or expressions in a GROUP BY WITH CUBE or WITH ROLLUP statement
10
Columns per index 16
Columns per foreign key 16
Columns per primary key 16
Columns per base table 1024
Columns per SELECT statement 4096
Columns per INSERT statement 1024
Connections per client Max. value of configured connections
Database size 1,048,516 TB
Files per database 32,767
File size (data) 32 TB
Object SQL Server 7.0
File size (log) 4 TB
FOREIGN KEY constraints per table 63
Foreign key table references per table 63
Identifier length (in characters) 128
103
Index key size (bytes) 900
Locks per connection Max. value of locks configured
Nested subqueries 64
Nested trigger levels 32
Nonclustered indexes or constraints per table
250
Objects in a database * 2,147,483,647
Parameters per stored procedure 1024
PRIMARY KEY constraints per table 1
Rows per table Limited by available storage
SQL string length 128 *TDS packet size
Tables per database Limited by number of objects in a database
Tables per SELECT statement 256
Triggers per table Limited by number of objects in a database
UNIQUE constraints per table 250 nonclustered and 1 clustered
* Database objects include all tables, views, stored procedures, extended stored procedures, triggers, rules, defaults, and constraints.
Appendix C
Scorecard of Microsoft’s SQL Server & Oracle’s 8i
PC Microsoft SQL Server Oracle8i Standard Edition
104
7.0
Server Administration Excellent Good
Graphical tools Excellent Good
Ease of maintenance Excellent Good
Server Engine Excellent Excellent
Support for multiple CPUs Excellent Good
Join and index selection Excellent Excellent
Degree of concurrency Good Excellent
Multimedia Data Handling Poor Excellent
Web connectivity Poor Excellent
Support for sound, media, video, images
Poor Excellent
Full text search Good Excellent
Interoperability Good Fair
Links with other databases Good Poor
Single log-on Good Good
Operating-system support Fair Good
Programmability Fair Excellent
Stored procedures and triggers
Good Excellent
Internal programming language
Poor Excellent
Database Design Good Excellent
SQL language support Excellent Excellent
Object-oriented design Poor Excellent
Branch Office Support Excellent Excellent
Replication Excellent Excellent
Distributed transactions Excellent Excellent
Remote administration Good Excellent
105
Data Warehousing and Reporting
Excellent Excellent
Loading tools Excellent Excellent
Appendix D
Summary of Features of Microsoft’s SQL Server & Oracle’s 8i
Microsoft SQL Server 7.0 Oracle 8i Standard Edition
List price $1,399 $3,925 per CPU
Number of users included 5 users (named or concurrent) 5 concurrent users
Price for each additional concurrent user / named user
$127 / $127 $785 / $392.50
Server operating-system support Windows NT, Windows 9x Windows NT, multiple Unix flavors
Client software operating-system support Windows NT, Windows 9x All server platforms plus Windows 9x
Network protocols supported AppleTalk, IPX, Named Pipes, TCP/IP, Vines IP
IPX, Named Pipes, TCP/IP
ADMINISTRATION
Graphical tools for:
Installing the database server Yes Yes
Creating and managing databases/disk devices
Yes Yes Yes Yes
Creating and managing tables/indexes Yes Yes Yes Yes
Creating and managing stored procedures Yes Yes
Creating and managing users Yes Yes
Creating and managing replication links Yes Yes
Backup and restore Yes Yes
106
Web publishing Yes Yes
Database diagramming Yes Optional
Submitting SQL and viewing query results Yes Yes
Viewing all currently executing SQL code Yes Optional
[ii] Dyck, Timothy. “SQL Server makes enterprise in roads.” PC Week. November 10, 1998.November 6, 1999 <http://www.zdnet.com/pcweek/stories/news/0,4153,372285,00.html.
[iii] O’Neill, Paige. “Oracle Trumps Microsoft in Battle for NT Database Marketshare.”March 29, 1999.October 31, 1999. <www.oracle.com/cgi-bin/press/printpr.cgi?file=199903290500.29144.html&mode=corp.
[iv]“Oracle Charts Landmark Year for Oracle 8; Sets the Stage for the Next Release, Code-Named Emerald.”July 2, 1999. November 5, 1999 <www.uk.oracle.com/info/news/emerald.html.
[v] “Score Card.” PC Magazine.July 29, 1999.October 27, 1999 <www.zdnet.com/products/stories/reviews/0,4161,2304448,00.html.
[vi] Deck, Stewart. “SQL users turn to Oracle 8 for bulk.” Computerworld. May 10, 1999.October 15, 1999 <www.computerworld.com/home/print.nsf/all/990510A506.
I will try to explain here at some of the Oracle features and techniques that can be employed to speed up data loads from flat files into Oracle tables. To demonstrate and compare data loading methods, I loaded a sample data set using each of the techniques that Oracle provides. I compared elapsed time, CPU time, and caveats of each method, but please note that timings can vary from one run to the next and all results depends on DB Activity at that time.
The Sample Data Set
To demonstrate various techniques for loading flat file data into Oracle tables, I worked with a flat file that contains 100,000 records of data into a call center table. The file is approximately 6 Mb in size, and a few sample records in the file look like this:
82302284384,04-18-2003:13:18:58,5001,COMPLAINT,SYS TICKET 183487923 82302284385,04-18-2003:13:18:59,3352,INFO-REQUEST,PAYMENT ADDRESS 82302284386,04-18-2003:13:19:01,3142,DOC-REQUEST,2002 YE CONSOL STMT
The CALLS table looks like this:
Name Null? Type Comment ------------ --------- ------------- ----------------- CALL_ID NOT NULL NUMBER Primary key CALL_DATE NOT NULL DATE Non-unique index EMP_ID NOT NULL NUMBER CALL_TYPE NOT NULL VARCHAR2(12) DETAILS VARCHAR2(25)
1- Single Row Inserts
About the simplest way for an application to load data into Oracle is to insert one row at a time using the INSERT statement with the VALUES clause. This technique is convenient for loading small amounts of data, such as a SQL*Plus script that creates seed data at the time of application installation. However, this approach is quite slow when compared to more sophisticated techniques, and therefore is not appropriate for loading large volumes of data into Oracle. Depending on the application and data volume involved, this most basic method for loading data into Oracle might give acceptable performance. If that is the case, then there is no need to over-engineer an unnecessarily complicated load program. However, if single row inserts are not fast enough, then there are more sophisticated data load methods to consider. The chief advantages of the single row insert method are simplicity and flexibility. The key disadvantage of this technique is that it is the slowest and most CPU-resource intensive.
When a row is inserted into a table, Oracle needs to update all indexes on the table at the same time. It is typically faster for Oracle to build an index from scratch after the table is populated rather than repeatedly update an index as rows are inserted. It is often true that the index will be more compact and efficient as well. These rules of thumb are especially true when bitmap indexes are involved.From this, it follows that one way to speed up data loads would be to drop the indexes before loading the data and recreate the indexes after the load is complete. For primary and unique key constraints, you can get the same effect by disabling or dropping the constraint. (Be careful of the impact this might have on foreign key constraints in other tables.)This technique might not be appropriate if you are loading data into a table that already has a lot of rows in it. Consider a table with 99 million rows and you wish to load 1 million more rows. The time saved in loading the 1 million new rows will be lost when Oracle has to rebuild an index on the 99 million existing rows plus the 1 million new rows.Speeding up index creation is another issue to consider. Briefly, you can reduce the amount of sorting that must take place on disk by increasing the sort_area_size in your session (if you are not using Oracle 9i PGA aggregate targets). This allows your session to perform more of the sorting during index creation in memory. Also, you can use the NOLOGGING keyword to reduce the amount of redo Oracle generates during the index build. NOLOGGING has significant impacts on recoverability and standby databases, so do your homework before using the NOLOGGING keyword.I modified the application used in the last section to disable the primary key on the CALLS table and drop its one non-unique index before loading the data, putting both back after the load was complete. In this example, the CALLS table was empty before the data load. Factoring in the amount of time required to recreate the two indexes, elapsed time for the load dropped from 172 seconds to 130 seconds. CPU time used by the database server process dropped from 52 seconds to 35 seconds.Dropping and rebuilding indexes before and after a data load can speed up the load and yield more efficient indexes. Some drawbacks include the added complexity and potential embedding of schema design information into the application code. (When you add another index to the table being loaded, will you have to update your application code?) Dropping indexes before a load could also have significant performance impacts if users need to be able to query the target table while the load is taking place. Finally, dropping or disabling primary or unique key constraints could cause difficulties if foreign key constraints reference them.
Data Loading Method Elapsed Seconds Database ServerCPU Seconds
Single row inserts without indexes(time includes index rebuild usingNOLOGGING and large sort area)
130 35
3-Bulk Inserts Without Indexes
114
I modified the application used in the last example to load call center records into arrays in memory and perform bulk inserts 100 rows at a time instead of one row at a time. I retained the logic that dropped the indexes and rebuilt them after the data load. Elapsed time to load the data dropped from 130 seconds to 14 seconds, while CPU time used by the database server process dropped from 35 seconds to 7 seconds. Of course, the amount of time required to rebuild the indexes was not affected by the use of bulk inserts. The actual time to load the data (setting aside the index rebuild time) dropped by about 95%.A clear advantage of the bulk insert technique is that load time drops dramatically, as does CPU usage. One disadvantage of this technique is slightly increased complexity in application coding and a greater opportunity for bugs. This disadvantage is very modest.
We apply this technique for First Data and Bank of America.
Data Loading Method Elapsed Seconds Database ServerCPU Seconds
Bulk row inserts 100 rows at a timewithout indexes (time includesindex rebuild using NOLOGGINGand large sort area)
14 7
4-CREATE as SELECT Using an Oracle 9i External Table
An external table looks somewhat like a regular table in that it has columns with standard Oracle data types and you can query it just like any other table. However, the table data is not stored inside the database. Instead, the external table is associated with a flat file on the database server. Whenever you query the external table, Oracle parses the flat file and returns the rows to you as if the data were stored in Oracle.We apply this technique for Bank of America and BankLink.You can join external tables to other tables in your queries, but you cannot index external tables nor can you insert, update, or delete rows. If the flat file on the database server changes or is deleted, this will affect the outcome of future queries against the external table.External tables open the door to new strategies for loading data into Oracle. We can put the flat file on the database server and create an external table in the database. At that time we can instantly query the data as if it had been loaded into a conventional Oracle table. If the flat file gets removed or overwritten, the old contents will no longer be accessible in the database. Probably we can implement this for issuedata and images files?However, we can (if needed) use an external table as a vehicle to copy data quickly from a flat file into a conventional Oracle table.
I wrote a SQL*Plus script to drop the CALLS table, recreate it from the CALLS_EXTERNAL table as shown above, and add the primary key and non-unique index. Populating the CALLS table in this way took 15 seconds, using 8 seconds of CPU time in the database server process. This case was slightly slower than the bulk insert method discussed in the last section.One advantage of this technique is that it achieves very good performance with very little coding effort. It is also a method that works entirely within the database, so we can even schedule data loads using the Oracle dbms_job scheduler.
Data Loading Method Elapsed Seconds Database ServerCPU Seconds
CREATE as SELECT from anexternal table with NOLOGGING(time includes index build using
15 8
115
NOLOGGING and large sort area)
5- SQL*Loader Conventional and Direct Path
SQL*Loader is a utility provided by Oracle specifically for the purpose of loading large volumes of data from flat files into Oracle tables. It is very powerful, flexible, and fast. However, we must launch it from the operating system. (Invoking SQL*Loader within a dbms_job or a PL/SQL stored procedure is tricky but we can do it.). SQL*Loader still seems to be about the fastest and most efficient way to get flat file data into Oracle. By default, SQL*Loader uses what it calls "conventional path" loading–bulk inserts, basically. The performance is not phenomenal, and there are faster alternatives. However, with a simple "direct=true" on the command line, we can invoke "direct path" loading. In a direct path load, SQL*Loader writes rows directly into new data blocks above the table's high water mark. This is like inserting with the Append hint as seen in the last section, but it's even better. In a direct path load, SQL*Loader also updates indexes using a very efficient bulk method.Loading the call center data using SQL*Loader with conventional path load took about 81 seconds. The database server process used about 12 seconds of CPU time. This was with indexes in place and SQL*Loader bulk inserting rows 100 at a time. With a direct path load, SQL*Loader got the data into the database in just 9 seconds, with only 3 CPU seconds used by the database server process. This was with indexes in place.Direct path SQL*Loader is fast and efficient. It is even fast when indexes on the target table are not dropped before the load. As for disadvantages, direct path loading has implications for recovery akin to the NOLOGGING keyword. Also, indexes on the target table are unusable for a period during the load. This can impact users trying to access the target table while a load is in progress. Also, indexes can be left in an unusable state if the SQL*Loader session were to crash midway through the load.
Data Loading Method Elapsed Seconds Database ServerCPU Seconds
SQL*Loader conventional path(indexes in place and rows=100)
81 12
SQL*Loader direct path (indexesin place)
9 3
Conclusion
There are many different ways to load data into Oracle. Each technique offers its own balance between speed, simplicity, scalability, recoverability, and data availability.To recap, here are all of the timing figures in one place:
Data Loading Method Elapsed Seconds Database ServerCPU Seconds
Single row inserts 172 52
Single row inserts without indexes(time includes index rebuild usingNOLOGGING and large sort area)
130 35
Bulk row inserts 100 rows at a timewithout indexes (time includesindex rebuild using NOLOGGINGand large sort area)
14 7
116
CREATE as SELECT from anexternal table with NOLOGGING(time includes index build usingNOLOGGING and large sort area)
15 8
SQL*Loader conventional path(indexes in place and rows=100)
81 12
SQL*Loader direct path (indexesin place)
9 3
Please keep in mind that I did not even touch on the subject of parallelism in data loads. (Inserts with the Append hint can use parallelism in the Enterprise Edition of the Oracle software.
Oracle XML
What is XML and what is it used for?
XML (eXtensible Markup Language) is a W3C initiative that allows information and services to be encoded with meaningful structure and semantics that both computers and humans can understand. XML is great for information exchange, and can easily be extended to include user-specified and industry-specified tags. Look at this simple example defining a FAQ: <?xml version="1.0"?>
<!DOCTYPE question-list SYSTEM "faq.dtd"> <?xml-stylesheet type="text/xml" href="faq.xsl"?>
A Document Type Definition (DTD) defines the elements or record structure of a XML document. A DTD allows your XML files to carry a description of its format with it. The DTD for the above XML example looks like this:
Notes: #PCDATA (parsed character data) means that the element contains data that can be parsed by a
parser like HTML The + sign in the example above declares that the "QUESTION" element must occur one or more
times inside the "FAQ-LIST" element. The * sign in the example above declares that the "QUERY" element can occur zero or more times
inside the "QUESTION" element.
117
The W3C also formulated a new standard, called XML Schemas that superceded DTD's. Schemas allow for more complex data types within your tags and better ways to constrain (validate) data within these tags.
What XML compliant products do Oracle provide?
XMLDB
Standard option that ships with the Oracle 9i database (from 9.2.0). Previously called Project XDB.
XML-SQL Utility (XSU)
Programatic interfaces (packages) for PL/SQL and Java
XML Developer's kits (XDK) for Java, C, C++ and PL/SQL.See demo programs in the $ORACLE_HOME/xdk/ directory.
XSQL ServletProcessing SQL queries and generating an XML result setSee http://technet.oracle.com/tech/xml/xsql_servlet/htdocs/relnotes.htm
Other productsOracle integrated XML in various other product offerings like the Oracle iFS, Oracle InterMedia, JDeveloper, etc.
How does one map relational data from tables to XML?
If you're using Oracle 8i, use the DBMS_XMLQUERY and DBMS_XMLSAVE JAVA based packages. For Oracle 9i, use the C-based package DBMS_XMLGEN.
Look at the following Oracle 9i code example:
connect scott/tigerset serveroutput onDECLARE Ctx DBMS_XMLGEN.ctxHandle; -- Var's to convert SQL output to XML xml clob; emp_no NUMBER := 7369;
xmlc varchar2(4000); -- Var's required to convert lob to varchar off integer := 1; len integer := 4000;BEGIN Ctx := DBMS_XMLGEN.newContext('SELECT * FROM emp WHERE empno = '||emp_no); DBMS_XMLGen.setRowsetTag(Ctx, 'EMP_TABLE'); DBMS_XMLGen.setRowTag(Ctx, 'EMP_ROW'); DBMS_XMLGEN.closeContext(Ctx); xml := DBMS_XMLGEN.getXML(Ctx);
DBMS_LOB.READ(xml, len, off, xmlc); -- Display first part on screen DBMS_OUTPUT.PUT_LINE(xmlc);END;/
The same results can be achieved using SQLX (see http://sqlx.org/). Some of the SQLX functions are XMLElement(), XMLForest(), XMLSequence(), etc. Look at this example.
Beginning with the first release of Oracle 8i, Oracle has offered the XDK for the Oracle database. For Oracle 8i releases 1 and 2 (8.1.5 and 8.1.6) you must download the XDK from Oracle Technology Network and install it manually. With Oracle 8i release 3 (8.1.7) and Oracle 9i, the XDK is integrated into the database and is installed automatically when the database is installed.
The XDK may be accessed from PL/SQL, Java, C, and C++ applications. PL/SQL applications must run inside the database (i.e. stored procedures, packages, triggers, or anonymous PL/SQL blocks) in order to access the XDK. Java applications may reside inside or outside the database. C and C++ applications, of course, reside outside the database.
In order to access the XDK from PL/SQL or Java applications residing inside the database, you must install Oracle’s JVM (sometimes called the Java option or Oracle JServer). It may seem counter-intuitive that you must have Oracle’s JVM installed in order to use the XDK from PL/SQL, but there is a reason for it: The XDK is itself written in Java. Oracle merely put PL/SQL wrappers on the Java code in order to make it accessible from PL/SQL.
The XDK contains an XML parser, an XSLT processor, an XPath engine, an XSQL page processor and servlet, and an XML SQL utility. The first three are Oracle’s implementations of the XML 1.0 specification, while the last two are features unique to Oracle.
Note that the XSQL page facility is only accessible from Java applications. Also note that in earlier releases of the XDK, the XML SQL utility was a separate tool that you had to install separately from the XDK. You can download the XML SQL utility from Oracle Technology Network.
Hello! Could you elaborate the example of serializing the XML into a table, let's say the XML file has data which corresponds to 2 tables (repetitive tags for a detail table), is it possible?
Followup:
Sean here...
This is pretty easy to accomplish. There is no automated XML utility in Oracle to insert a single XML document into two different tables... What you could do, however, is create a join view on the two tables, then write an INSTEAD OF trigger on the join view. Insert the XML document into the join view. The INSTEAD OF trigger's job would be to insert rows into the appropriate tables based on the values of the parent key found in each ROWSET of the XML document.
As an example, I have an XML document that looks like SO:
system@SLAP> select * from emp; EMPNO DEPTNO ENAME---------- ---------- ------------------------------ 100 10 MARK JOHNSON 200 20 TOM KYTE 300 20 SEAN DILLON -----------------------------
...and there you have it. Hope that helps!
How can I handle this? One row for the department table and 3 rows for the employee table in the same XML row.<?xml version = "1.0"?><ROWSET> <ROW num="1"> <DEPTNO>10</DEPTNO> <DNAME>SALES</DNAME> <EMPLOYEE> <EMPNO>100</EMPNO> <ENAME>MARK JOHNSON</ENAME> </EMPLOYEE> <EMPLOYEE> <EMPNO>200</EMPNO> <ENAME>VICTOR JAEN</ENAME> </EMPLOYEE> <EMPLOYEE> <EMPNO>300</EMPNO> <ENAME>JHON SMITH</ENAME>
122
</EMPLOYEE> </ROW></ROWSET>
Thanks a lot!
Followup:
1* select dbms_xmlgen.getxml( 'select deptno, dname, cursor( select empno, ename from emp where emp.deptno = dept.deptno ) employee from dept where deptno = 10' ) from dualscott@ORA920> / DBMS_XMLGEN.GETXML('SELECTDEPTNO,DNAME,CURSOR(SELECTEMPNO,ENAMEFROMEMPWHEREEMP.D--------------------------------------------------------------------------------<?xml version="1.0"?><ROWSET> <ROW> <DEPTNO>10</DEPTNO> <DNAME>ACCOUNTING</DNAME> <EMPLOYEE> <EMPLOYEE_ROW> <EMPNO>7782</EMPNO> <ENAME>CLARK</ENAME> </EMPLOYEE_ROW> <EMPLOYEE_ROW> <EMPNO>7839</EMPNO> <ENAME>KING</ENAME> </EMPLOYEE_ROW> <EMPLOYEE_ROW> <EMPNO>7934</EMPNO> <ENAME>MILLER</ENAME> </EMPLOYEE_ROW> </EMPLOYEE> </ROW></ROWSET>
123
Oracle 9i and 8i Database Limits Oracle8i ONLY Advanced Queuing Processes maximum per instance 10 Oracle8i ONLY Job Queue Processes
maximum per instance
36
I/O Slave Processes
maximum per background process (DBWR, LGWR, etc.) maximum per Backup session
15 15
Sessions maximum per instance
32K, limited by PROCESSES and SESSIONS init parameters
LCK Processes
maximum per instance
10
MTS Servers
maximum per instance
Unlimited within constraints set by PROCESSES and SESSIONS init parameters, for instance
Dispatchers maximum per instance
Unlimited within constraints set by PROCESSES and SESSIONS init parameters, for instance.
Parallel Execution Slaves
maximum per instance
Unlimited within constraints set by PROCESSES and SESSIONS init parameters, for instance.
Backup Sessions
maximum per instance
Unlimited within constraints set by PROCESSES and SESSIONS init parameters, for instance.
Oracle 9i Limits
Datatype Limits VARCHAR2 Maximum size is 4000NVARCHAR2 Maximum size is determined by the national
character set definition, with an upper limit of 4000 bytes
NUMBER( p,s) The precision p can range from 1 to 38. The scale s can range from -84 to 127
LONG up to 2 gigabytes, or 231 -1 bytesDATE range from January 1, 4712 BC to December 31,
9999 ADTIMESTAMP( fractional_seconds_precision) fractional_seconds_precisionis the number of digits
in the fractional part of the SECOND datetime field.
124
Accepted values of fractional_seconds_precision are 0 to 9. The default is 6
TIMESTAMP( fractional_seconds_precision) WITH TIME ZONE
fractional_seconds_precisionis the number of digits in the fractional part of the SECOND datetime field. Accepted values are 0 to 9. The default is 6
TIMESTAMP( fractional_seconds_precision)WITH LOCAL TIME ZONE
same as TIMESTAMP( fractional_seconds_precision) WITH TIME ZONE
INTERVAL YEAR( year_precision) TO MONTH year_precision is the number of digits in the YEAR datetime field. Accepted values are 0 to 9. The default is 2
INTERVAL DAY (day_precision) TO SECOND ( fractional_seconds_precision)
day_precision is the maximum number of digits in the DAY datetime field. Accepted values are 0 to 9. The default is 2 fractional_seconds_precision is the number of digits in the fractional part of the SECOND field. Accepted values are 0 to 9. The default is 6
RAW( size) Maximum size is 2000 bytesLONG RAW up to 2 gigabytesROWID Base 64 string representing the unique address of a
row in its table UROWID [( size)] Base 64 string representing the logical address of a
row of an index-organized table. The optional size is the size of a column of type UROWID. The maximum size and default is 4000 bytes
CHAR( size)[BYTE |CHAR] Fixed-length character data of length size bytes.Maximum size is 2000 bytes. Default and minimum size is 1 byte
NCHAR( size) Fixed-length character data of length size characters. Maximum size is determined by the national character set definition, with an upper limit of 2000 bytes. Default and minimum size is 1 character
CLOB Maximum size is 4 gigabytesNCLOB Maximum size is 4 gigabytesBLOB Maximum size is 4 gigabytesBFILE Maximum size is 4 gigabytes
2048 bytes; must be a multiple of operating system physical block size
125
Maximum Operating system dependent; never more than 32 KB
Database Blocks Minimum in initial extent of a segment Maximum per datafile
2 blocks Platform dependent; typically 222-1 blocks
Controlfiles Number of control files Size of a control file
1 minimum; 2 or more (on separate devices) strongly recommended Dependent on operating system and database creation options; maximum of 20,000 x (database block size)
Database files Maximum per tablespace Maximum per database
Operating system dependent; usually 1022 65533. May be less on some operating systems Limited also by size of database blocks and by the DB_FILES initialization parameter for a particular instance
Database extents Maximum 2 GB, regardless of the maximum file size allowed by the operating system
Database file size Maximum Operating system dependent. Limited by maximum operating system file size; typically 222 or 4M blocks
MAXEXTENTS Default value Maximum
Derived from tablespace default storage or DB_BLOCK_SIZE initialization parameter Unlimited
Redo Log Files Maximum number of logfiles Maximum number of logfiles per group
Limited by value of MAXLOGFILES parameter in the CREATE DATABASE statement. Control file can be resized to allow more entries; ultimately an operating system limit Unlimited
Redo Log File Size Minimum size Maximum size
50 KB Operating system limit; typically 2 GB
Tablespaces
Maximum number per database
64 KB Number of tablespaces cannot exceed the number of database files, as each tablespace must include at least one file
Logical Database Limits GROUP BY clause Maximum length The GROUP BY expression and all of the
nondistinct aggregates functions (for example, SUM, AVG) must fit within a single database block.
Indexes Maximum per table Unlimited
126
total size of indexed column
75% of the database block size minus some overhead
Columns Per table Per index (or clustered index)
1000 columns maximum 32 columns maximum
Per bitmapped index 30 columns maximumConstraints
Maximum per column Unlimited
Subqueries Maximum levels of subqueries in a SQL statement
Unlimited in the FROM clause of the top-level query; 255 subqueries in the WHERE clause
Partitions
Maximum length of linear partitioning key Maximum number of columns in partition key Maximum number of partitions allowed per table or index
4 KB - overhead 16 columns 64 K-1 partitions
Rollback Segments
Maximum number per database
No limit; limited within a session by MAX_ROLLBACK_SEGMENTS initialization parameter
Rows
Maximum number per table
Unlimited
SQL Statement Length
Maximum length of statements
64 KB maximum; particular tools may impose lower limits
Stored Packages
Maximum size PL/SQL and Developer/2000 may have limits on the size of stored procedures they can call. The limits typically range from 2000 to 3000 lines of code. See Also: Your PL/SQL or Developer/2000 documentation for details
Trigger Cascade Limit
Maximum value Operating system-dependent, typically 32
Users and Roles Maximum 2,147,483,638
Tables
Maximum per clustered table Maximum per database
32 tablesUnlimited
Process and Runtime Limits Instances per database Maximum number of cluster
database instances per databaseOperating system-dependent
Locks
Row-level Distributed Lock Manager
Unlimited Operating system dependent
SGA size Maximum value Operating system-dependent; typically 2 to 4 GB for 32-bit operating systems, and > 4 GB for 64-bit operating systems
Advanced Queuing Processes Maximum per instance 10 Job Queue Processes
Maximum per instance 1000
I/O Slave Processes
Maximum per background process (DBWR, LGWR, etc.)
15
127
Maximum per Backup session
15
Sessions
Maximum per instance 32K; limited by PROCESSES and SESSIONS initialization parameters
Global Cache Service Processes
Maximum per instance 10
Shared Servers Maximum per instance Unlimited within constraints set by PROCESSES and SESSIONS initialization parameters, for instance
Dispatchers Maximum per instance Unlimited within constraints set by PROCESSES and SESSIONS initialization parameters, for instance
Parallel Execution Slaves Maximum per instance Unlimited within constraints set by PROCESSES and SESSIONS initialization parameters, for instance
Backup Sessions Maximum per instance Unlimited within constraints set by PROCESSES and SESSIONS initialization parameters, for instance
Oracle 8i LimitsDatatype Limits Datatypes Limit CommentsBFILE maximum size: 4GB
maximum size of file name: 255 characters maximum size of open BFILEs: see comments
The maximum number of BFILEs is limited by SESSION_MAX_OPEN_FILES, which is itself limited by the maximum number of open files the operating system will allow.
BLOB 4GB maximum The number of LOB columns per table is limited only by the maximum number of columns per table (i.e., 1000)
CHAR 2000 bytes maximum CHAR VARYING 4000 bytes CLOB 4GB maximum The number of LOB columns per table
is limited only by the maximum number of columns per table (i.e., 1000)
Literals (characters or numbers in SQL or PL/SQL
4000 characters maximum
LONG 231-1 bytes (2GB) maximum Only one LONG column allowed per table
NCHAR 2000 bytes NCHAR VARYING 4000 bytes NCLOB 4GB maximum The number of LOB columns per table is
limited only by the maximum number of columns per table (i.e., 1000)
NUMBER 999...(38 9's)x10 to power of 25 maximum value
Can be represented to full 38-digit precision (the mantissa).
128
-999...(38 9's)x 10 to power of 125 minimum value
Precision 38 significant digits RAW 2000 bytes maximum VARCHAR 4000 bytes maximum VARCHAR2 4000 bytes maximum Physical Database Limits Item Type of Limit Limit ValueDatabase Block Size minimum
maximum
2048 bytes; must be a multiple of O/S physical block sizeO/S-dependent never more than 32KB
Database Blocks minimum in initial extent of a segmentmaximum per datafile
2 blocksplatform dependent; typically 2 to power of 22 blocks
Controlfiles number of controlfiles 1 minimum: 2 or more (on separate devices) strongly recommended
size of controlfile dependent on O/S and database creation options; maximum of 20,000 x (database block size)
Database files maximum per tablespace maximum per database
O/S dependent, usually 1022 65533; may be less on some operating systems; limited also by size of database blocks, and by the DB_FILES init parameter for a particular instance
Database file size maximum O/S dependent, limited by maximum O/S file size; typically 2 to power of 22 or 4M blocks
MAXEXTENTS default value maximum
derived from tablespace default storage or DB_BLOCK_SIZE unlimited
Redo Log Files maximum number of logfiles maximum number of logfiles per group
LOG_FILES initialization parameter, or MAXLOGFILES in CREATE DATABASE; controlfile can be resized to allow more entries; ultimately an O/S limit Unlimited
Redo Log File Size minimum size maximum size
50K bytesO/S limit, typically 2GB
Tablespaces maximum number per database 64K ; Number of tablespaces cannot exceed the number of database files, as each tablespace must include at least one file.
Logical Database Limits Item Type LimitGROUP BY clause maximum length The group-by expression and all
of the non-distinct aggregate (e.g., sum, avg)
129
need to fit within a single database block.
Indexes maximum per table total size of indexed column
Unlimited 40% of the database block size minus some overhead.
Columns table indexed (or clustered index) bitmapped index
1000 columns maximum 32 columns maximum 30 columns maximum
Constraints maximum per column UnlimitedNested Queries maximum number 255Partitions maximum length of linear
partitioning key 4KB - overhead
maximum number of columns in partition key
16 columns
maximum number of partitions allowed per table or index
64K-1 partitions
Rollback Segments maximum number per database
no limit; limited within a session by MAX_ROLLBACK_SEGMENTS init parameter
Rows maximum number per table no limit SQL Statement Length maximum length of
statements 64K maximum; particular tools may impose lower limits
Stored Packages maximum size PL/SQL and Developer/2000 may have limits on the size of stored rocedures they can call. Consult your PL/SQL or Developer/2000 documentation for details. The limits typically range from 2000-3000 lines of code.
Trigger Cascade Limit maximum value O/S dependent, typically 32Users and Roles maximum 2,147,483,638 Tables maximum per clustered table
maximum per database32 tables unlimited
Schema Object Naming Item Limit Names of databases 8 bytes Names of database links 128 bytesAll other schema objects 30 bytes Process / Runtime Limits Item Type LimitInstances per database maximum number of OPS
instances per database O/S dependent
Locks row-level Distributed Lock Manager
unlimited O/S dependent
SGA size maximum value O/S dependent, typically 2-4 GB for 32-bit O/S, > 4 GB for 64 bit O/S
130
Effective Coding Style
Revealing Logical Structure with IndentationIndentation is one of the most common and effective techniques used to display a program's logic via format. As illustrated in the following examples, programs that are indented are easier to read than those that are not indented. Here is an unindented IF statement:
IF to_number(the_value) > 22 THENIF max_totals = 0 THENcalc_totals;ELSE WHILE more_dataLOOPanalyze_results;END LOOP;END IF;END IF;
I have found that a three (or four)-space indentation not only adequately reveals the logical structure of the code but also keeps the statements close enough together to read comfortably. And, with deeply nested structures, you won't run off the right margin as quickly! Here is the three-space indented version of the previous nested IF statement:
131
IF to_number(the_value) > 22 THEN IF max_totals = 0 THEN calc_totals; ELSE WHILE more_data LOOP analyze_results; END LOOP; END IF;END IF;
Using Case to Aid ReadabilityPL/SQL code is made up of many different components: variables, form items, report fields, procedures, functions, loops, declarations, control elements, etc. But they break down roughly into two types of text: reserved words and application-specific names or identifiers.Reserved words are those names of language elements that are reserved by PL/SQL and have a special meaning for the compiler. Some examples of reserved words in PL/SQL are:
WHILEIFBEGINTO_CHAR
Application-specific identifiers are the names that you give to data and program structures that are specific to your application and that vary from system to system. The compiler treats these two kinds of text very differently. You can improve the readability of your code greatly by reflecting this difference in the way the text is displayed. Many developers make no distinction between reserved words and application-specific identifiers. Consider the following lines of code:
if to_number(the_value)>22 and num1 between lval and hval then newval := 100;elsif to_number(the_value) < 1 then calc_tots(to_date('12-jan-95'));else clear_vals;end if;
While the use of indentation makes it easier to follow the logical flow of the IF statement, all the words in the statements tend to blend together. It is difficult to separate the reserved words and the application identifiers in this code. Changing entirely to uppercase also will not improve matters. Indiscriminate, albeit consistent, use of upper- or lowercase for your code reduces its readability. The distinction between reserved words and application-specific identifiers is ignored in the formatting. This translates into a loss of information and comprehension for a developer.
The UPPER-lower StyleYou can easily solve this problem by adopting a guideline for using a mix of upper- and lowercase to your code. I have recoded my previous example below, this time using the UPPER-lower style: all reserved words are written in UPPERCASE and all application names are kept in lowercase:
IF to_number(the_value) > 22 AND num1 BETWEEN lval AND hval THEN newval := 100;ELSIF TO_NUMBER (the_value) < 1 THEN calc_tots (TO_DATE ('12-jan-95'));ELSE clear_vals;END IF;
132
Using a mixture of upper- and lowercase words increases the readability of the code by giving a sense of dimension to the code. The eye can more easily cruise over the text and pick the different syntactical elements of each statement. You can focus quickly on the lowercase words for the application-specific content. Consistent use of this method makes the program listings more attractive and accessible at a glance.
Formatting Single StatementsMost of your code consists of individual statements, such as assignments, calls to modules, and declarations. A consistent approach to formatting and grouping such statements will improve the readability of your program as a whole. This section suggests some guidelines.
Use at most one statement per linePL/SQL uses the semicolon (;) as the logical terminator for a statement, as a result you can have more than one statement on a line and you can continue a single executable statement over more than one line. You will sometimes be tempted to place several statements on a single line, particularly if they are very simple. Consider the following line: new_id := 15; calc_total (new_id); max_dollars := 105 * sales_adj;
It is very difficult to pick out the individual statements in this line, in addition to the fact that a procedure is called in the middle of the line. By placing each statement on its own line you mirror the complexity of a program--the simple lines look simple and the complex statements look complex--and reinforce the top-to-bottom logic of the program: new_id := 15; calc_total (new_id); max_dollars := 105 * sales_adj;
Use whitespace inside a statementYou can use all the indentation and blank lines you want to reveal the logic of a program and still end up with some very dense and unreadable code. It is also important to employ whitespace within a single line to make that one statement more comprehensible. Always include a space between every identifier and separator in a statement. Instead of this: WHILE(total_sales<maximum_sales AND company_type='NEW')LOOPwrite this: WHILE (total_sales < maximum_sales AND company_type = 'NEW') LOOP Use indentation to offset all continuation lines under the first line.This is the most important guideline. The best way to identify continuation lines is to use indentation to logically subsume those lines under the main or first line of the statement. The following call to generate_company_statistics is obscured because the continuation line butts right up against the left margin with the module name:
Formatting SQL StatementsBecause PL/SQL is an extension to the SQL language, you can place SQL statements directly in your PL/SQL programs. You can also define cursors based on SELECT statements. This section summarizes my suggestions for formatting SQL statements and cursors for maximum readability.PL/SQL supports the use of four SQL DML (Data Manipulation Language) statements: INSERT, UPDATE, DELETE, and SELECT. Each of these statements is composed of a series of "clauses," as in the WHERE clause and the ORDER BY clause. SQL statements can be very complex, to say the least. Without a consistent approach to indentation and
133
alignment inside these statements, you can end up with a real mess. I have found the following guidelines useful:
Right-align the reserved words for the clauses against the DML statement.
I recommend that you visually separate the SQL reserved words which identify the separate clauses from the application-specific column andtable names. The following table shows how I use right-alignment on the reserved words to create a vertical border between them and the rest ofthe SQL statement:
SELECT INSERT UPDATE DELETE
SELECT FROM WHERE AND OR GROUP BY HAVING AND OR ORDER BY
INSERT INTO VALUES INSERT INTO SELECT FROM WHERE
UPDATE SET WHERE
DELETE FROM WHERE
Here are some examples of this format in use:SELECT last_name, first_name FROM employee WHERE department_id = 15 AND hire_date < SYSDATE;
SELECT department_id, SUM (salary) AS total_salary FROM employee GROUP BY department_id ORDER BY total_salary DESC;
INSERT INTO employee (employee_id, ... ) VALUES (105 ... );
UPDATE employee SET hire_date = SYSDATE WHERE hire_date IS NULL AND termination_date IS NULL;
This right alignment makes it very easy to identify the different clauses of the SQL statement, particularly with extended SELECTs. You might also consider placing a blank line between clauses of longer SQL statements (this is possible in PL/SQL, but is not acceptable in "native" SQL executed in SQL*Plus).
Use meaningful abbreviations for table and column aliases
It's impossible to read a program when a query has a six-table join and the tables have been assigned aliases A, B, C, D, E, and F. How can you possibly decipher the WHERE clause in the following SELECT?SELECT ... select list ... FROM employee A, company B, history C, bonus D, profile E, sales F WHERE A.company_id = B.company_id AND A.employee_id = C.employee_id AND B.company_id = F.company_id AND A.employee_id = D.employee_id AND B.company_id = E.company_id;
134
With more sensible table aliases (including no tables aliases at all where the table name was short enough already), the relationships are much clearer: SELECT ... select list ... FROM employee EMP, company CO, history HIST, bonus, profile PROF, sales WHERE EMP.company_id = CO.company_id AND EMP.employee_id = HIST.employee_id AND CO.company_id = SALES.company_id AND EMP.employee_id = BONUS.employee_id AND CO.company_id = PROF.company_id;
Formatting Exception HandlersPL/SQL provides a very powerful facility for dealing with errors. An entirely separate exception section contains one or more "handlers" to trap exceptions and execute code when that exception occurs. Logically, the exception section is structured like a conditional CASE statement (which, by the way, is not supported by PL/SQL). As you might expect, the format for the exception section should resemble that of an IF statement. Here is a general example of the exception section:
EXCEPTION WHEN NO_DATA_FOUND THEN executable_statements1;
WHEN DUP_VAL_ON_INDEX THEN executable_statements1;... WHEN OTHERS THEN otherwise_code;END;
Formatting PL/SQL BlocksThe PL/SQL block structure forms the backbone of your code. A consistent formatting style for the block, therefore, is critical. This formatting should make clear these different sections. Consider the following function:
FUNCTIONcompany_name (company_id_in IN company.company_id%TYPE) RETURNVARCHAR2 IS cname company.company_id%TYPE; BEGIN SELECT name INTO cname FROM company WHERE company_id = company_id_in; RETURN cname;EXCEPTION WHEN NO_DATA_FOUND THEN RETURN NULL; END;
You know that this program is a function because the first word in the program is FUNCTION. Other than that, however, it is very difficult to follow the structure of this program. Where is the declaration section? Where does the executable section begin and end? Here is that same function after we apply some straightforward formatting rules to it:
FUNCTION company_name (company_id_in IN company.company_id%TYPE)RETURN VARCHAR2IS cname company.company_id%TYPE;BEGIN SELECT name INTO cname FROM company WHERE company_id = company_id_in; RETURN cname;
EXCEPTION WHEN NO_DATA_FOUND THEN
135
RETURN NULL;END;
The declaration section, which comes after the IS and before the BEGIN, clearly consists of a single declaration of the cname variable. The executable section consists of all the statements after the BEGIN and before the EXCEPTION statement; these are indented in from the BEGIN. Finally, the exception section shows a single specific exception handler and a WHEN OTHERS exception. Generally, indent the statements for a given section from the reserved words which initiate the section. You can also include a blank line before each section, as I do above, for the executable section (before BEGIN) and the exception section (before EXCEPTION). I usually place the IS keyword on its own line to clearly differentiate between the header of a module and its declaration section.
Make Comments Easy to Enter and MaintainYou shouldn't spend a lot of time formatting your comments. You need to develop a style that is clean and easy to read, but also easy to maintain. When you have to change a comment, you shouldn't have to reformat every line in the comment. Lots of fancy formatting is a good indication that you have a high-maintenance documentation style. The following block comment is a maintenance nightmare:
/*===========================================================| Parameter Description || || company_id The primary key to company || start_date Start date used for date range || end_date End date for date range |===========================================================*/
The right-justified vertical lines and column formatting for the parameters require way too much effort to enter and maintain. What happens if you add aparameter with a very long name? What if you need to write a longer description? A simpler and more maintainable version of this comment might be:
/*===========================================================| Parameter - Description|| company_id - The primary key to company| start_date - Start date used for date range| end_date - End date for date range===========================================================*/
Maintain IndentationInline commentary should reinforce the indentation and therefore the logical structure of the program. For example, it is very easy to find the comments in the make_array procedures shown below.
PROCEDURE make_array (num_rows_in IN INTEGER)/* Create an array of specified numbers of rows */IS /* Handles to Oracle Forms structures */ col_id GROUPCOLUMN; rg_id RECORDGROUP;BEGIN /* Create new record group and column */ rg_id := CREATE_GROUP ('array');
136
col_id := ADD_GROUP_COLUMN ('col'); /* || Use a loop to create the specified number of rows and || set the value in each cell. */ FOR row_index IN 1 .. num_rows_in LOOP /* Create a row at the end of the group to accept data */ ADD_GROUP_ROW (return_value, END_OF_GROUP); FOR col_index IN 1 .. num_columns_in LOOP /* Set the initial value in the cell */ SET_GROUP_NUMBER_CELL (col_id, row_index, 0); END LOOP; END LOOP;END;
Documenting the Entire PackageA package is often a complicated and long construct. It is composed of many different types of objects, any of which may be public (visible to programs and users outside of the package) or private (available only to other objects in the package). You can use some very simple documentation guidelines to clarify the structure of the package. As usual when discussing packages, one must consider the specification separately from the body. As a meta-module or grouping of modules, the specification should have a standard header. This header needn't be as complicated as that of a specific module, because you do not want to repeat in the package header any information which also belongs in specific modules. I suggest using the template header shown in the following example. In the "Major Modifications" section of the header, do not include every change made to every object in the package. Instead note significant changes to the package as a whole, such as an expansion of scope, a change in the way the package and global variables are managed, etc. Place this header after the package name and before the IS statement:
Document the Package SpecificationThe package specification is, in essence, a series of declaration statements. Some of those statements declare variables, while others declare modules. Follow the same recommendation in commenting a package as you do in commenting a module's declaration section: provide a comment for each declaration. In addition to the comments for a specific declaration, you may also find it useful to provide a banner before a group of related declarations to make that connection obvious to the reader. Surround the banner with whitespace (blank lines for the start/end of a multiline comment block). While you can use many different formats for this banner, use the simplest possible design that gets the point across. Everything else is clutter. The package specification below illustrates the header and declaration-level comment styles, as well as group banners:
PACKAGE rg_select/*|| Author: Diego Pafumi|||| Overview: Manage a list of selected items correlated with a|| block on the screen.
137
|||| Major Modifications (when, who, what)|| 12/94 - DP - Create package|| 3/95 - IS - Enhance to support coordinated blocks||*/IS /*----------------- Modules to Define the List -------------------*/
/* Initialize the list/record group. */ PROCEDURE init_list (item_name_in IN VARCHAR2);
/* Delete the list */ PROCEDURE delete_list;
/*------------------ Modules to Manage Item Selections -----------*/
/* Mark item as selected */ PROCEDURE select_item (row_in IN INTEGER);
/* De-select the item from the list */ PROCEDURE deselect_item (row_in IN INTEGER);
END rg_select;
Oracle Naming Coding Standards
TablesTable names should reflect the data in the table. The names are a mix of upper and lowercase letter with no underscores and in singular. The names should be fully spelled out and in singular or plural, but please keep only one rule: plural or singular.Example: UserProfile.
[
[
[
[
[
[
v
v
[
[
[
[
[
[
[
[
[
[
[
[
138
ColumnsTable columns should be named in the same was tables are named.Examples: FormID, ScanDate, ZoneName.
Stored ProceduresAtlantis related stored procedures start with "ap_".Project specific stored procedure should be prefixed by "p_".Following the prefix should be an abbreviation for a verb, or action word. Some typical actions on data are select (sel), insert (ins), update (upd) and delete (del). If a combination of actions is possible in a stored procedure, then use the first letters of the action. For example, if a stored procedure can do an insert or update, then use iu. An underscore character should then follow the verb abbreviation.Next, the name of the table affected or some other noun should be used to describe what is affected. Each word in this part of the spec is a mix of upper and lowercase, where the first character is uppercase and the rest lowercase. There should be no underscores in this part of the name.Examples are listed below:ap_ins_Form - This procedure name is an Atlantis stored procedure that inserts a record into the Form table.ap_iu_Document - This procedure name is Atlantis stored procedure that inserts or updates a record into the Document table.ap_sel_Zone - This procedure name is an Atlantis stored procedure that selects records from the Zonetable.p_del_Account - This procedure is project specific procedure that deletes records from the Zone table.
TriggersAtlantis triggers start with "at_" and project specific triggers start with "t_".Following this prefix is an indicator describing the action that triggers the trigger. Use del for delete, ins for insert and upd for update. If a trigger is used for more than one of these operations, then just include the first letter. For example, use iu for an insert/update trigger. Next comes an underscore followed by the suffix. The suffix contains an upper/lowercase name that includes the table name and/or any other descriptive text.Examples: at_del_Document, t_iu_UserProfile.
ViewsAtlantis views will have a prefix of "av_". A project specific view should have a prefix of "v_" or "view_".Following the prefix the view name should contain some sort of descriptive reference. If the view contains a simple join of two tables, then include the table names. For example: v_Table1Table2.The suffix should be upper/lowercase.
IndexesIndex names should have an "in_" prefix. The rest of the name is upper and lowercase. This suffix contains some meaningful text about the nature of the index.Example: in_EmployeeID.
ConstraintsPrimary keys are to be prefixed with "pk_", unique keys with "uk_" or "unique_" and foreign keys start with "fk_".The remainder of the name is upper and lowercase and usually contains the name of the field(s) included in the key.Example: pk_FormID, fk_ImageType.
SequenceSequence names begin with an "s_", followed by an underscore and then the field name (i.e. s_Field). If field name is ambiguous, then precede the field name with table name s_TableField.
