ヘッダーをスキップ
Oracle Database SQL言語クイック・リファレンス
11g リリース1(11.1)
E05749-02
  目次
目次
索引
索引

戻る
戻る
 
次へ
次へ
 

2 SQLファンクション

この章では、SQLファンクションの構文について説明します。

この章では、次の項目について説明します。

SQLファンクションの構文

ファンクションはデータ項目を操作し、単一値を戻すコマンドです。

この項では、各SQLファンクションおよび関連する構文を示します。副次句の構文については、第5章「副次句」を参照してください。


参照:

SQLファンクションの詳細は、『Oracle Database SQL言語リファレンス』の「ファンクション」を参照してください。


ABS

ABS(n)

ACOS

ACOS(n)

ADD_MONTHS

ADD_MONTHS(date, integer)

analytic_function

analytic_function([ arguments ])
   OVER (analytic_clause)

APPENDCHILDXML

APPENDCHILDXML
  ( XMLType_instance, XPath_string, value_expr [, namespace_string ]
  )

ASCII

ASCII(char)

ASCIISTR

ASCIISTR(char)

ASIN

ASIN(n)

ATAN

ATAN(n)

ATAN2

ATAN2(n1 , n2)

AVG

AVG([ DISTINCT | ALL ] expr)
  [ OVER(analytic_clause) ]

BFILENAME

BFILENAME('directory', 'filename')

BIN_TO_NUM

BIN_TO_NUM(expr [, expr ]... )

BITAND

BITAND(expr1, expr2)

CARDINALITY

CARDINALITY(nested_table)

CAST

CAST({ expr | MULTISET (subquery) } AS type_name)

CEIL

CEIL(n)

CHARTOROWID

CHARTOROWID(char)

CHR

CHR(n [ USING NCHAR_CS ])

CLUSTER_ID

CLUSTER_ID ( [ schema . ] model mining_attribute_clause )

CLUSTER_PROBABILITY

CLUSTER_PROBABILITY ( [ schema . ] model
   [ , cluster_id ] mining_attribute_clause )

CLUSTER_SET

CLUSTER_SET ( [ schema . ] model
   [ , topN [ , cutoff ]
   ]
   mining_attribute_clause )

COALESCE

COALESCE(expr [, expr ]...)

COLLECT

COLLECT ( [DISTINCT | UNIQUE] column ORDER BY expr )

COMPOSE

COMPOSE(char)

CONCAT

CONCAT(char1, char2)

CONVERT

CONVERT(char, dest_char_set[, source_char_set ])

CORR

CORR(expr1, expr2)
   [ OVER (analytic_clause) ]

CORR_K、CORR_S

{ CORR_K | CORR_S }
   (expr1, expr2
    [, { COEFFICIENT
       | ONE_SIDED_SIG
       | ONE_SIDED_SIG_POS
       | ONE_SIDED_SIG_NEG
       | TWO_SIDED_SIG
       }
    ]
   )

COS

COS(n)

COSH

COSH(n)

COUNT

COUNT({ * | [ DISTINCT | ALL ] expr })
   [ OVER (analytic_clause) ]

COVAR_POP

COVAR_POP(expr1, expr2)
   [ OVER (analytic_clause) ]

COVAR_SAMP

COVAR_SAMP(expr1, expr2)
   [ OVER (analytic_clause) ]

CUME_DIST(集計)

CUME_DIST(expr[,expr ]...)
   WITHIN GROUP
   (ORDER BY expr [ DESC | ASC ]
                  [ NULLS { FIRST | LAST } ]
             [, expr [ DESC | ASC ]
                     [ NULLS { FIRST | LAST } ]
             ]...
   )

CUME_DIST(分析)

CUME_DIST( )
   OVER ([ query_partition_clause ] order_by_clause)

CURRENT_DATE

CURRENT_DATE

CURRENT_TIMESTAMP

CURRENT_TIMESTAMP [ (precision) ]

CV

CV([ dimension_column ])

DATAOBJ_TO_PARTITION

DATAOBJ_TO_PARTITION ( table, partition_id )

DBTIMEZONE

DBTIMEZONE

DECODE

DECODE(expr, search, result
             [, search, result ]...
       [, default ]
      )

DECOMPOSE

DECOMPOSE( string [ CANONICAL | COMPATIBILITY ] )

DELETXML

DELETEXML
  ( XMLType_instance, XPath_string
    [, namespace_string ]
  )

DENSE_RANK(集計)

DENSE_RANK(expr [, expr ]...) WITHIN GROUP
  (ORDER BY expr [ DESC | ASC ]
                 [ NULLS { FIRST | LAST } ]
            [,expr [ DESC | ASC ]
                   [ NULLS { FIRST | LAST } ]
            ]...
  )

DENSE_RANK(集計)

DENSE_RANK( )
   OVER([ query_partition_clause ] order_by_clause)

DEPTH

DEPTH(correlation_integer)

DEREF

DEREF(expr)

DUMP

DUMP(expr[, return_fmt
            [, start_position [, length ] ]
         ]
    )

EMPTY_BLOB、EMPTY_CLOB

{ EMPTY_BLOB | EMPTY_CLOB }( )

EXISTSNODE

EXISTSNODE
   (XMLType_instance, XPath_string
      [, namespace_string ]
   )

EXP

EXP(n)

EXTRACT(日時)

EXTRACT( { { YEAR
           | MONTH
           | DAY
           | HOUR
           | MINUTE
           | SECOND
           }
         | { TIMEZONE_HOUR
           | TIMEZONE_MINUTE
           }
         | { TIMEZONE_REGION
           | TIMEZONE_ABBR
           }
         }
         FROM { expr }
       )

EXTRACT(XML)

EXTRACT(XMLType_instance, XPath_string
        [, namespace_string ]
       )

EXTRACTVALUE

EXTRACTVALUE
   (XMLType_instance, XPath_string
     [, namespace_string ]
   )

FEATURE_ID

FEATURE_ID ( [ schema . ] model mining_attribute_clause )

FEATURE_SET

FEATURE_SET ( [ schema . ] model
   [ , topN [ , cutoff ]
   ]
   mining_attribute_clause )

FEATURE_VALUE

FEATURE_VALUE ( [ schema . ] model
   [ , feature_id ] mining_attribute_clause )

FIRST

aggregate_function
   KEEP
   (DENSE_RANK FIRST ORDER BY
    expr [ DESC | ASC ]
         [ NULLS { FIRST | LAST } ]
    [, expr [ DESC | ASC ]
            [ NULLS { FIRST | LAST } ]
    ]...
   )
   [ OVER query_partition_clause ]

FIRST_VALUE

FIRST_VALUE (expr [ IGNORE NULLS ])
   OVER (analytic_clause)

FLOOR

FLOOR(n)

FROM_TZ

FROM_TZ (timestamp_value, time_zone_value)

GREATEST

GREATEST(expr [, expr ]...)

GROUP_ID

GROUP_ID( )

GROUPING

GROUPING(expr)

GROUPING_ID

GROUPING_ID(expr [, expr ]...)

HEXTORAW

HEXTORAW(char)

INITCAP

INITCAP(char)

INSERTCHILDXML

INSERTCHILDXML
  ( XMLType_instance, XPath_string, child_expr,
      value_expr [, namespace_string ]
  )

INSERTXMLBEFORE

INSERTXMLBEFORE
   ( XMLType_instance, XPath_string,
      value_expr [, namespace_string ]
   )

INSTR

{ INSTR
| INSTRB
| INSTRC
| INSTR2
| INSTR4
}
(string , substring [, position [, occurrence ] ])

ITERATION_NUMBER

ITERATION_NUMBER

LAG

LAG(value_expr [, offset ] [, default ])
   OVER ([ query_partition_clause ] order_by_clause)

LAST

aggregate_function KEEP
   (DENSE_RANK LAST ORDER BY
    expr [ DESC | ASC ]
         [ NULLS { FIRST | LAST } ]
    [, expr [ DESC | ASC ]
            [ NULLS { FIRST | LAST } ]
    ]...
   )
   [ OVER query_partition_clause ]

LAST_DAY

LAST_DAY(date)

LAST_VALUE

LAST_VALUE(expr [ IGNORE NULLS ])
   OVER (analytic_clause)

LEAD

LEAD(value_expr [, offset ] [, default ])
   OVER ([ query_partition_clause ] order_by_clause)

LEAST

LEAST(expr [, expr ]...)

LENGTH

{ LENGTH
| LENGTHB
| LENGTHC
| LENGTH2
| LENGTH4
}
(char)

LN

LN(n)

LNNVL

LNNVL(condition)

LOCALTIMESTAMP

LOCALTIMESTAMP [ (timestamp_precision) ]

LOG

LOG(n2, n1)

LOWER

LOWER(char)

LPAD

LPAD(expr1, n [, expr2 ])

LTRIM

LTRIM(char [, set ])

MAKE_REF

MAKE_REF({ table | view } , key [, key ]...)

MAX

MAX([ DISTINCT | ALL ] expr)
   [ OVER (analytic_clause) ]

MEDIAN

MEDIAN(expr) [ OVER (query_partition_clause) ]

MIN

MIN([ DISTINCT | ALL ] expr)
   [ OVER (analytic_clause) ]

MOD

MOD(n2, n1)

MONTHS_BETWEEN

MONTHS_BETWEEN(date1, date2)

NANVL

NANVL(n2, n1)

NCHR

NCHR(number)

NEW_TIME

NEW_TIME(date, timezone1, timezone2)

NEXT_DAY

NEXT_DAY(date, char)

NLS_CHARSET_DECL_LEN

NLS_CHARSET_DECL_LEN(byte_count, 'char_set_id')

NLS_CHARSET_ID

NLS_CHARSET_ID ( string )

NLS_CHARSET_NAME

NLS_CHARSET_NAME(number)

NLS_INITCAP

NLS_INITCAP(char [, 'nlsparam' ])

NLS_LOWER

NLS_LOWER(char [, 'nlsparam' ])

NLS_UPPER

NLS_UPPER(char [, 'nlsparam' ])

NLSSORT

NLSSORT(char [, 'nlsparam' ])

NTILE

NTILE(expr)
   OVER ([ query_partition_clause ] order_by_clause)

NULLIF

NULLIF(expr1, expr2)

NUMTODSINTERVAL

NUMTODSINTERVAL(n, 'interval_unit')

NUMTOYMINTERVAL

NUMTOYMINTERVAL(n, 'interval_unit')

NVL

NVL(expr1, expr2)

NVL2

NVL2(expr1, expr2, expr3)

ORA_HASH

ORA_HASH (expr [, max_bucket [, seed_value ] ])

PATH

PATH (correlation_integer)

PERCENT_RANK(集計)

PERCENT_RANK(expr [, expr ]...) WITHIN GROUP
   (ORDER BY
    expr [ DESC | ASC ]
         [NULLS { FIRST | LAST } ]
    [, expr [ DESC | ASC ]
            [NULLS { FIRST | LAST } ]
    ]...
   )

PERCENT_RANK(分析)

PERCENT_RANK( )
   OVER ([ query_partition_clause ] order_by_clause)

PERCENTILE_CONT

PERCENTILE_CONT(expr) WITHIN GROUP
   (ORDER BY expr [ DESC | ASC ])
   [ OVER (query_partition_clause) ]

PERCENTILE_DISC

PERCENTILE_DISC(expr) WITHIN GROUP
   (ORDER BY expr [ DESC | ASC ])
   [ OVER (query_partition_clause) ]

POWER

POWER(n2, n1)

POWERMULTISET

POWERMULTISET(expr)

POWERMULTISET_BY_CARDINALITY

POWERMULTISET_BY_CARDINALITY(expr, cardinality)

PREDICTION

PREDICTION ( [ schema . ] model [ cost_matrix_clause ] mining_attribute_clause )

PREDICTION_BOUNDS

PREDICTION_BOUNDS
( [schema.] model
  [, confidence_level [, class_value]]
  mining_attribute_clause
)

PREDICTION_COST

PREDICTION_COST ( [ schema . ] model [ , class ] cost_matrix_clause
 mining_attribute_clause )

PREDICTION_DETAILS

PREDICTION_DETAILS ( [ schema . ] model mining_attribute_clause )

PREDICTION_PROBABILITY

PREDICTION_PROBABILITY ( [ schema . ] model [ , class ]
   mining_attribute_clause )

PREDICTION_SET

PREDICTION_SET ( [ schema . ] model [ , bestN [ , cutoff ] ]
  [ cost_matrix_clause ] mining_attribute_clause )

PRESENTNNV

PRESENTNNV(cell_reference, expr1, expr2)

PRESENTV

PRESENTV(cell_reference, expr1, expr2)

PREVIOUS

PREVIOUS(cell_reference)

RANK(集計)

RANK(expr [, expr ]...) WITHIN GROUP
   (ORDER BY
    expr [ DESC | ASC ]
         [ NULLS { FIRST | LAST } ]
    [, expr [ DESC | ASC ]
            [ NULLS { FIRST | LAST } ]
    ]...
   )

RANK(分析)

RANK( )
   OVER ([ query_partition_clause ] order_by_clause)

RATIO_TO_REPORT

RATIO_TO_REPORT(expr)
   OVER ([ query_partition_clause ])

RAWTOHEX

RAWTOHEX(raw)

RAWTONHEX

RAWTONHEX(raw)

REF

REF (correlation_variable)

REFTOHEX

REFTOHEX (expr)

REGEXP_COUNT

REGEXP_COUNT (source_char, pattern [, position [, match_param]])


REGEXP_INSTR

REGEXP_INSTR (source_char, pattern
              [, position
                 [, occurrence
                    [, return_opt
                       [, match_param
                          [, subexpr]
                       ]
                    ]
                 ]
              ]


REGEXP_REPLACE

REGEXP_REPLACE(source_char, pattern
               [, replace_string
                  [, position
                     [, occurrence
                        [, match_param ]
                     ]
                  ]
               ]
              )

REGEXP_SUBSTR

REGEXP_SUBSTR(source_char, pattern
              [, position
                 [, occurrence
                    [, match_param
                       [, subexpr
                       ]
                    ]
                 ]
              ]
             )

REGR_AVGX、REGR_AVGY、REGR_COUNT、REGR_INTERCEPT、REGR_R2、REGR_SLOPE、REGR_SXX、REGR_SXY、REGR_SYY

{ REGR_SLOPE
| REGR_INTERCEPT
| REGR_COUNT
| REGR_R2
| REGR_AVGX
| REGR_AVGY
| REGR_SXX
| REGR_SYY
| REGR_SXY
}
(expr1 , expr2)
[ OVER (analytic_clause) ]

REMAINDER

REMAINDER(n2, n1)

REPLACE

REPLACE(char, search_string
        [, replacement_string ]
       )

ROUND(日付)

ROUND(date [, fmt ])

ROUND(数値)

ROUND(n [, integer ])

ROW_NUMBER

ROW_NUMBER( )
   OVER ([ query_partition_clause ] order_by_clause)

ROWIDTOCHAR

ROWIDTOCHAR(rowid)

ROWIDTONCHAR

ROWIDTONCHAR(rowid)

RPAD

RPAD(expr1 , n [, expr2 ])

RTRIM

RTRIM(char [, set ])

SCN_TO_TIMESTAMP

SCN_TO_TIMESTAMP(number)

SESSIONTIMEZONE

SESSIONTIMEZONE

SET

SET (nested_table)

SIGN

SIGN(n)

SIN

SIN(n)

SINH

SINH(n)

SOUNDEX

SOUNDEX(char)

SQRT

SQRT(n)

STATS_BINOMIAL_TEST

STATS_BINOMIAL_TEST(expr1, expr2, p
                    [, { TWO_SIDED_PROB
                       | EXACT_PROB
                       | ONE_SIDED_PROB_OR_MORE
                       | ONE_SIDED_PROB_OR_LESS
                       }
                    ]
                   )

STATS_CROSSTAB

STATS_CROSSTAB(expr1, expr2
               [, { CHISQ_OBS
                  | CHISQ_SIG
                  | CHISQ_DF
                  | PHI_COEFFICIENT
                  | CRAMERS_V
                  | CONT_COEFFICIENT
                  | COHENS_K
                  }
               ]
              )

STATS_F_TEST

STATS_F_TEST(expr1, expr2
             [, { { STATISTIC
                  | DF_NUM
                  | DF_DEN
                  | ONE_SIDED_SIG
    } , expr3
                | TWO_SIDED_SIG
                }
             ]
            )

STATS_KS_TEST

STATS_KS_TEST(expr1, expr2
              [, { STATISTIC | SIG } ]
             )

STATS_MODE

STATS_MODE(expr)

STATS_MW_TEST

STATS_MW_TEST(expr1, expr2
              [, { STATISTIC
                 | U_STATISTIC
                 | ONE_SIDED_SIG , expr3
                 | TWO_SIDED_SIG
                 }
              ]
             )

STATS_ONE_WAY_ANOVA

STATS_ONE_WAY_ANOVA(expr1, expr2
                    [, { SUM_SQUARES_BETWEEN
                       | SUM_SQUARES_WITHIN
                       | DF_BETWEEN
                       | DF_WITHIN
                       | MEAN_SQUARES_BETWEEN
                       | MEAN_SQUARES_WITHIN
                       | F_RATIO
                       | SIG
                       }
                    ]
                   )

STATS_T_TEST_INDEP、STATS_T_TEST_INDEPU、STATS_T_TEST_ONE、STATS_T_TEST_PAIRED

{ STATS_T_TEST_INDEP
| STATS_T_TEST_INDEPU
| STATS_T_TEST_ONE
| STATS_T_TEST_PAIRED
}
(expr1, expr2
  [, { { STATISTIC
       | ONE_SIDED_SIG
       } , expr3
     | TWO_SIDED_SIG
     | DF
     }
  ]
)

STATS_WSR_TEST

STATS_WSR_TEST(expr1, expr2
               [, { STATISTIC
                  | ONE_SIDED_SIG
                  | TWO_SIDED_SIG
                  }
               ]
              )

STDDEV

STDDEV([ DISTINCT | ALL ] expr)
   [ OVER (analytic_clause) ]

STDDEV_POP

STDDEV_POP(expr)
   [ OVER (analytic_clause) ]

STDDEV_SAMP

STDDEV_SAMP(expr)
   [ OVER (analytic_clause) ]

SUBSTR

{ SUBSTR
| SUBSTRB
| SUBSTRC
| SUBSTR2
| SUBSTR4
}
(char, position [, substring_length ])

SUM

SUM([ DISTINCT | ALL ] expr)
   [ OVER (analytic_clause) ]

SYS_CONNECT_BY_PATH

SYS_CONNECT_BY_PATH(column, char)

SYS_CONTEXT

SYS_CONTEXT('namespace', 'parameter' [, length ])

SYS_DBURIGEN

SYS_DBURIGEN({ column | attribute }
             [ rowid ]
               [, { column | attribute }
                  [ rowid ]
               ]...
             [, 'text ( )' ]
            )

SYS_EXTRACT_UTC

SYS_EXTRACT_UTC(datetime_with_timezone)

SYS_GUID

SYS_GUID( )

SYS_TYPEID

SYS_TYPEID(object_type_value)

SYS_XMLAGG

SYS_XMLAGG(expr [, fmt ])

SYS_XMLGEN

SYS_XMLGEN(expr [, fmt ])

SYSDATE

SYSDATE

SYSTIMESTAMP

SYSTIMESTAMP

TAN

TAN(n)

TANH

TANH(n)

TIMESTAMP_TO_SCN

TIMESTAMP_TO_SCN(timestamp)

TO_BINARY_DOUBLE

TO_BINARY_DOUBLE(expr [, fmt [, 'nlsparam' ] ])

TO_BINARY_FLOAT

TO_BINARY_FLOAT(expr [, fmt [, 'nlsparam' ] ])

TO_BLOB

TO_BLOB ( raw_value )

TO_CHAR(文字)

TO_CHAR(nchar | clob | nclob)

TO_CHAR(日時)

TO_CHAR({ datetime | interval } [, fmt [, 'nlsparam' ] ])

TO_CHAR(数値)

TO_CHAR(n [, fmt [, 'nlsparam' ] ])

TO_CLOB

TO_CLOB(lob_column | char)

TO_DATE

TO_DATE(char [, fmt [, 'nlsparam' ] ])

TO_DSINTERVAL

TO_DSINTERVAL ( ' { sql_format | ds_iso_format } ' )

TO_LOB

TO_LOB(long_column)

TO_MULTI_BYTE

TO_MULTI_BYTE(char)

TO_NCHAR(文字)

TO_NCHAR({char | clob | nclob})

TO_NCHAR(日時)

TO_NCHAR({ datetime | interval }
         [, fmt [, 'nlsparam' ] ]
        )

TO_NCHAR(数値)

TO_NCHAR(n [, fmt [, 'nlsparam' ] ])

TO_NCLOB

TO_NCLOB(lob_column | char)

TO_NUMBER

TO_NUMBER(expr [, fmt [, 'nlsparam' ] ])

TO_SINGLE_BYTE

TO_SINGLE_BYTE(char)

TO_TIMESTAMP

TO_TIMESTAMP(char [, fmt [, 'nlsparam' ] ])

TO_TIMESTAMP_TZ

TO_TIMESTAMP_TZ(char [, fmt [, 'nlsparam' ] ])

TO_YMINTERVAL

TO_YMINTERVAL
  ( '  { [+|-] years - months
       | ym_iso_format
       } ' )

TRANSLATE

TRANSLATE(expr, from_string, to_string)

TRANSLATE ...USING

TRANSLATE ( char USING
          { CHAR_CS | NCHAR_CS }
          )

TREAT

TREAT(expr AS [ REF ] [ schema. ]type)

TRIM

TRIM([ { { LEADING | TRAILING | BOTH }
         [ trim_character ]
       | trim_character
       }
       FROM
     ]
     trim_source
    )

TRUNC(日付)

TRUNC(date [, fmt ])

TRUNC(数値)

TRUNC(n1 [, n2 ])

TZ_OFFSET

TZ_OFFSET({ 'time_zone_name'
          | '{ + | - } hh : mi'
          | SESSIONTIMEZONE
          | DBTMEZONE
          }
         )

UID

UID

UNISTR

UNISTR( string )

UPDATEXML

UPDATEXML
      (XMLType_instance,
        XPath_string, value_expr
          [, XPath_string, value_expr ]...
        [, namespace_string ]
      )

UPPER

UPPER(char)

USER

USER

ユーザー定義ファンクション

[ schema. ]
{ [ package. ]function | user_defined_operator }
[ @ dblink. ]
[ ( [ [ DISTINCT | ALL ] expr [, expr ]... ] ) ]

USERENV

USERENV('parameter')

VALUE

VALUE(correlation_variable)

VAR_POP

VAR_POP(expr) [ OVER (analytic_clause) ]

VAR_SAMP

VAR_SAMP(expr) [ OVER (analytic_clause) ]

VARIANCE

VARIANCE([ DISTINCT | ALL ] expr)
        [ OVER (analytic_clause) ]

VSIZE

VSIZE(expr)

WIDTH_BUCKET

WIDTH_BUCKET
   (expr, min_value, max_value, num_buckets)

XMLAGG

XMLAGG(XMLType_instance [ order_by_clause ])

XMLCAST

  XMLCAST ( value_expression AS datatype )


XMLCOLATTVAL

XMLCOLATTVAL
  (value_expr [ AS { c_alias  | EVALNAME value_expr } ]
    [, value_expr [ AS { c_alias  | EVALNAME value_expr } ]
      ]...
  )

XMLCOMMENT

XMLCOMMENT ( value_expr )


XMLCDATA

 XMLCDATA ( value_expr )

XMLCONCAT

XMLCONCAT(XMLType_instance [, XMLType_instance ]...)

XMLDIFF

XMLDiff ( XMLType_document, XMLType_document [ , integer, string ] )

XMLELEMENT

XMLELEMENT
 ( [ENTITYESCAPING | NOENTITYESCAPING]
   [ NAME ]
     { identifier
     | EVALNAME value_expr
     }
   [, XML_attributes_clause ]
   [, value_expr [ AS c_alias ]]...
 )

XMLEXISTS

  XMLEXISTS ( XQuery_string [ XML_passing_clause ] )


XMLFOREST

XMLFOREST
  ( value_expr [ AS { c_alias | EVALNAME value_expr } ]
    [, value_expr [ AS { c_alias | EVALNAME value_expr } ]
      ]...
  )

XMLPARSE

XMLPARSE
  ({ DOCUMENT | CONTENT } value_expr [ WELLFORMED ]
  )

XMLPATCH

XMLPatch ( XMLType_document, XMLType_document )

XMLPI

XMLPI
 ( { [ NAME ] identifier
   | EVALNAME value_expr
   } [, value_expr ]
 )


XMLQUERY

XMLQUERY
 ( XQuery_string
   [ XML_passing_clause ]
   RETURNING CONTENT [NULL ON EMPTY]
 )

XMLROOT

XMLROOT
  ( value_expr, VERSION
  { value_expr | NO VALUE }
  [, STANDALONE { YES | NO | NO VALUE } ]
  )

XMLSEQUENCE

XMLSEQUENCE( XMLType_instance
           | sys_refcursor_instance [, fmt ]
           )

XMLSERIALIZE

XMLSERIALIZE
  ( { DOCUMENT | CONTENT } value_expr [ AS datatype ]
    [ ENCODING xml_encoding_spec]
    [ VERSION string_literal ]
    [ NO INDENT | { INDENT [SIZE = number] } ]
    [ { HIDE | SHOW } DEFAULTS ]
  )

XMLTABLE

XMLTABLE
 (
  [ XMLnamespaces_clause , ] XQuery_string XMLTABLE_options
 )

XMLTRANSFORM

XMLTRANSFORM(XMLType_instance, { XMLType_instance
                               | string
                               }
                   )