#
# Copyright (C) 2008 Search Solution Corporation. All rights reserved by Search Solution. 
#
#   This program is free software; you can redistribute it and/or modify 
#   it under the terms of the GNU General Public License as published by 
#   the Free Software Foundation; version 2 of the License. 
#
#  This program is distributed in the hope that it will be useful, 
#  but WITHOUT ANY WARRANTY; without even the implied warranty of 
#  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 
#  GNU General Public License for more details. 
#
#  You should have received a copy of the GNU General Public License 
#  along with this program; if not, write to the Free Software 
#  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA 
#

# $Revision: 1.5 $
				   
!GENERAL

Help is available on the following topics.

    ALTER          : 클래스, 가상클래스의 정의를 변경하는 명령어.
    CALL           : 인스턴스 또는 클래스의 메소드를 실행하는 명령어.
    COMMIT         : 현재의 트랜잭션을 커밋하는 명령어.
    CREATE         : 클래스 또는 가상클래스를 생성하는 명령어.
    DELETE         : 클래스의 인스턴스를 삭제하는 명령어.
    DROP           : 클래스, 인덱스, 트리거, deferred 트리거 액션들을 삭제하는 명령어.
    EXECUTE        : deferred 트리거 액션들을 실행하는 명령어.
    GET            : 세션 인자들(트랜잭션, 트리거 등)의 값을 얻는 명령어.
    GRANT          : 클래스에 대한 권한을 허용하는 명령어.
    INDEX          : 속성에 대한 인덱스를 생성하는 명령어.
    INSERT         : 클래스에 대한 새로운 인스턴스를 생성하는 명령어.
    RENAME         : 클래스, 가상클래스, 트리거의 이름을 바꾸는 명령어.
    REVOKE         : 클래스에 대한 권한을 취소하는 명령어.
    ROLLBACK       : 현재의 트랜잭션을 철회하는 명령어.
    SELECT         : 클래스의 인스턴스들에 대하여 질의하는 명령어.
    SET            : 세션 인자들 (트랜잭션, 트리거 등)의 값을 설정하는 명령어.
    STATISTICS     : 데이터베이스 통계를 갱신하는 명령어.
    TRIGGER        : 트리거의 정의를 생성 또는 변경하는 명령어.
    UPDATE         : 클래스의 인스턴스들을 변경하는 명령어.
    PARTITION      : 파티션을 생성하거나, 파티션을 일반 클래스로 전환하는 명령어.
    STORED PROCEDURE : 저장 프로시저를 생성하거나 삭제하는 명령어.
    USER           : 사용자를 생성하거나 삭제하는 명령어.

*
  구체적인 도움말 주제를 보세요.
*
  구체적인 도움말 주제를 보세요.
*
!ALTER

클래스, 가상클래스의 정의를 변경하는 명령어.
*

<alter> ::= ALTER [ <class_type> ] <class_name> <alter_clause> ;

<class_type> ::= CLASS | TABLE | VCLASS | VIEW

<alter_clause> ::= ADD <alter_add> [ INHERIT <resolution_comma_list> ] |
                   DROP <alter_drop> [ INHERIT <resolution_comma_list> ] |
		   RENAME <alter_rename> [ INHERIT <resolution_comma_list> ] |
                   CHANGE <alter_change> |
		   INHERIT <resolution_comma_list>

<alter_add> ::= [ ATTRIBUTE | COLUMN ] <class_element_comma_list> |
		CLASS ATTRIBUTE <attribute_definition_comma_list> |
		FILE <file_name_comma_list> |
		METHOD <method_definition_comma_list> |
		QUERY <select_statement> |
		SUPERCLASS <class_name_comma_list>

<alter_change> ::= FILE <file_path_name> AS <file_path_name> |
		   METHOD <method_definition_comma_list> |
		   QUERY [ <unsigned_integer_literal> ] <select_statement> |
		   <general_attribute_name> DEFAULT <value_specifiation>

<alter_drop> ::= [ ATTRIBUTE | COLUMN | METHOD ]
		 <general_attribute_name_comma_list> |
		 FILE <file_name_comma_list> |
		 QUERY [ <unsigned_integer_literal> ] |
		 SUPERCLASS <class_name_comma_list> |
		 CONSTRAINT <constraint_name>

<alter_rename> ::= [ ATTRIBUTE | COLUMN | METHOD ] 
		   <general_atttribute_name> AS <attribute_name> |
		   FUNCTION OF <general_attribute_name> AS <function_name>
		   FILE <file_path_name> AS <file_path_name>

<resolution> ::= <general_attribute_name> OF <class_name>
                 [ AS <attribute_name> ]

<class_element> ::= <attribute_definition> | <class_constraint>

*
        ALTER CLASS procedings ADD SUPERCLASS reports
          INHERIT editor OF reports;

        ALTER CLASS employee ADD ATTRIBUTE 
          name string,
          age integer DEFAULT 20;

        ALTER CLASS employee DROP name, age;

        ALTER CLASS employee CHANGE age 30;

	ALTER CLASS employee DROP CONSTRAINT unique_age;
*
!CALL

인스턴스 또는 클래스의 메소드를 실행하는 명령어.
*

<call> ::= CALL <method_name> ( [ <argument_value_comma_list> ] ) 
           ON <call_target> [ <to_variable> ] ;

<argument_value> ::= <value_specification>

<call_target> ::= <variable_name> | <metaclass_specification>

<metaclass_specification> ::= CLASS <class_name>

*
        CALL find_employee('smith') ON CLASS employee TO myvariable;
        
        CALL update_status() ON myvariable;
*
!COMMIT

현재의 트랜잭션을 커밋하는 명령어.
*
<commit> ::= COMMIT WORK ;

*
        COMMIT WORK;
*
!CREATE

클래스 또는 가상클래스를 생성하는 명령어.
*        
<create> ::= <create_class> | <create_virtual_class>

<create_class> ::= CREATE {CLASS | TABLE} <class_name>
                   [ <subclass_definition> ]
                   [ ( <class_element_comma_list> ) ]
		   [ CLASS ATTRIBUTE ( <attribute_definition_comma_list> ) ]
                   [ METHOD <method_definition_comma_list> ]
                   [ FILE <method_file_comma_list> ]
                   [ INHERIT <resolution_comma_list> ]
                   ;

<create_virtual_class> ::= CREATE {VCLASS | VIEW} <class_name>
			   [ <subclass_definition> ]
                           [ ( <view_attribute_def_comma_list> ) ]
			   [ CLASS ATTRIBUTE
                             ( <attribute_definition_comma_list> ) ]
                           [ METHOD <method_definition_comma_list> ] 
                           [ FILE <method_file_comma_list> ]
                           [ INHERIT <resolution_comma_list> ]
                           [ AS <query_statement> ]
                           [ WITH CHECK OPTION ]
                           ;

<subclass_definition> ::= AS SUBCLASS OF <class_name_comma_list>

<class_element> ::= <attribute_definition> | <class_constraint>

<attribute_definition> ::= <general_attribute_name> <attribute_type>
                           [ <default_or_shared> ]
                           [ <attribute_constraint_list> ]

<class_constraint> ::= [ CONSTRAINT <constraint_name> ]
                       UNIQUE ( <attribute_name_comma_list> ) |
                       [PRIMARY KEY ( <attribute_name_comma_list> )] |
                       [referential_constraint]

<view_attribute_definition> ::= <attribute_definition> | <attribute_name>

<default_or_shared> ::= SHARED [ <value_specification> ] |
                        DEFAULT <value_specification>

<attribute_constraint> ::= NOT NULL | UNIQUE

<method_definition> ::= <general_method_name>
                        [ ( [ <argument_type_comma_list> ] ) ]
                        [ <result_type> ]
                        [FUNCTION <function_name>]

<resolution> ::= <general_attribute_name> OF <class_name>
                 [ AS <attribute_name> ]

<general_attribute_name> ::= [ CLASS ] <attribute_name>
<general_method_name>    ::= [ CLASS ] <method_name>

<attribute_type> ::= <domain_name>
<argument_type>  ::= <domain_name>
<result_type>    ::= <domain_name>

<referential_constraint> ::= FOREIGN KEY 
                             [constraint-name] (attribute_name_comma_list)
                             REFERENCES 
                             [referenced_table_name] (attribute_name_comma_list)
                             [ <referential_triggered_action>]

<referential_triggered_action> ::= <update_rule>
                                   [ <delete_rule> [ <cache_object_rule> ]]

<update_rule> ::= ON UPDATE <referential_action>

<delete_rule> ::= ON DELETE <referential_action>

<cache_object_rule> ::= ON CACHE OBJECT cache_object_column_name

<referential_action> ::= CASCADE | RESTRICT | NO ACTION 

*
	CREATE CLASS address (street string, city string);

        CREATE CLASS person (
            name      string,
            birthday  date,
            residence address,
            UNIQUE (name))
        METHOD get_age () integer 
        FILE "/p/xsql/current/bin/person.o";

        create class album
        (id          char(10) NOT NULL PRIMARY KEY, 
         title       varchar(100),
         artist      varchar(100)
        );

        create class track 
        (album     char(10),
         dsk       integer,
         posn      integer,
         song      varchar(255),
         FOREIGN KEY (album) REFERENCES album(id)
        );
                
*
!DELETE

클래스의 인스턴스를 삭제하는 명령어.
*
<delete> ::= DELETE FROM <class_specification> [ WHERE <search_condition> ] ;

<class_specification> ::= <class_hierarchy> | ( <class_hierarchy_comma_list )

<class_hierarchy> ::= [ ONLY ] <class_name> |
		      ALL <class_name> [ EXCEPT <class_specification> ]

*
	DELETE FROM employee;

        DELETE FROM ONLY hotel WHERE name = 'Hilton';

	DELETE FROM location
  	  WHERE lodging IN (SELECT name FROM resort);
*
!DROP

클래스, 인덱스, 트리거, deferred 트리거 액션들을 삭제하는 명령어.
*
<drop> := <drop_class> | <drop_index> | <drop_trigger> | <drop_deferred>

<drop_class> ::= DROP [ <class_type> ] <class_specification_comma_list> ;

<class_specification> ::= <class_hierarchy> | ( <class_hierarchy_comma_list )

<class_hierarchy> ::= [ ONLY ] <class_name> |
		      ALL <class_name> [ EXCEPT <class_specification> ]

<drop_index> ::= DROP [REVERSE] [UNIQUE] INDEX [index_name] ON <class_name> 
                 ( <attribute_name> ) ;

<drop_trigger> ::= DROP TRIGGER <trigger_name_comma_list> ;

<drop_deferred> ::= DROP DEFERRED TRIGGER <trigger_spec> ;

<trigger_spec> ::= <trigger_name_comma_list> | ALL TRIGGERS ;

*
	DROP address;
        DROP person, employee;

	DROP INDEX ON employee (name);
	DROP INDEX ON employee (ssn, name);

	DROP TRIGGER check_salary;

	DROP DEFERRED TRIGGER check_salary, check_age;
	DROP DEFERRED TRIGGER ALL TRIGGERS;
*
!EXECUTE

deferred 트리거 액션들을 실행하는 명령어.
*

<execute_deferred> ::= EXECUTE DEFERRED TRIGGER <trigger_spec> ;

<trigger_spec> ::= <trigger_name_comma_list> | ALL TRIGGERS

*
	EXECUTE DEFERRED TRIGGER check_age, check_name;

	EXECUTE DEFERRED TRIGGER ALL TRIGGERS;

*
!GET

세션 인자들(트랜잭션, 트리거 등)의 값을 얻는 명령어.
*
<get> := GET <session_parameter> [ <to_variable> ] ;

<session_parameter> := TRANSACTION ISOLATION LEVEL |
                       TRANSACTION LOCK TIMEOUT |
                       OPTIMIZATION LEVEL |
		       OPTIMIZATION LIMIT |
		       TRIGGER TRACE |
		       TRIGGER MAXIMUM DEPTH

*
        GET OPTIMIZATION LEVEL INTO level;
	GET TRANSACTION LOCK TIMEOUT;
	GET TRIGGER TRACE;
	GET TRIGGER MAXIMUM DEPTH;

*
!GRANT

클래스에 대한 권한을 허용하는 명령어.
*
<grant> ::= GRANT <privileges> ON <class_specification_comma_list>
              TO <user_name_comma_list> [ WITH GRANT OPTION ] ;

<privileges> ::= ALL [ PRIVILEGES ] | <privilege_comma_list>

<privilege> ::= SELECT | INSERT | DELETE | UPDATE | ALTER | INDEX | EXECUTE

<user_name> ::= <identifier>

<class_specification> ::= <class_hierarchy> | ( <class_hierarchy_comma_list )

<class_hierarchy> ::= [ ONLY ] <class_name> |
		      ALL <class_name> [ EXCEPT <class_specification> ]
*
        GRANT SELECT, INSERT, UPDATE ON employee TO jones;

        GRANT ALL PRIVILEGES ON person, student, TO smith, brown;
*
!INDEX

속성에 대한 인덱스를 생성하는 명령어.
*
<index> ::= CREATE [REVERSE] [UNIQUE] INDEX [index_name] 
            ON <index_specification>;

<index_specification> ::= <class_name> ( <attribute_name_comma_list> ) ;

*
        CREATE INDEX ON employee (name);

        CREATE INDEX ON person (name, social_security_number);
*
!INSERT

클래스에 대한 새로운 인스턴스를 생성하는 명령어.
*
<insert> ::= INSERT INTO <class_name> <insert_spec> ;

<insert_spec> ::= [ ( [ <attribute_name_comma_list> ] ) ] <value_clause> |
		  DEFAULT VALUES;

<value_clause> ::= VALUES ( [ <insert_item_comma_list> ] )
		   [ TO <variable_name> ] |
		   <query_statement>

<insert_item> ::= <expression> | <method_call>

*
        INSERT INTO person(name, age, residence)
            VALUES ('Amy', 20, (INSERT INTO address(street, city)
                                 VALUES ('1 Wolf St. ', 'Austin')));
*
!RENAME

클래스, 가상클래스, 트리거의 이름을 바꾸는 명령어.
*
<rename> ::= <rename_class> | <rename_trigger>

<rename_class> ::= RENAME CLASS <class_name> AS <class_name> ;

<rename_trigger> ::= RENAME TRIGGER <trigger_name> AS <trigger_name> ;

*
        RENAME CLASS employee AS company_employee;

	RENAME TRIGGER check_age AS check_employee_age;

*
!REVOKE

클래스에 대한 권한을 취소하는 명령어.
*
<revoke> ::= REVOKE <privileges> ON <class_specification_comma_list> 
             FROM <user_name_comma_list> ;

<privileges> ::= ALL [ PRIVILEGES ] | <privilege_comma_list>

<privilege> ::= SELECT | INSERT | DELETE | UPDATE | ALTER | INDEX | EXECUTE

<user_name> ::= <identifier>

<class_specification> ::= <class_hierarchy> | ( <class_hierarchy_comma_list )

<class_hierarchy> ::= [ ONLY ] <class_name> |
		      ALL <class_name> [ EXCEPT <class_specification> ]
*
        REVOKE INSERT, UPDATE ON employee FROM smith;

        REVOKE SELECT ON manufacturing_site FROM jones, brown;
*
!ROLLBACK

현재의 트랜잭션을 철회하는 명령어.
*
<rollback> ::= ROLLBACK WORK ;
*
        ROLLBACK WORK;
*
!SELECT

클래스의 인스턴스들에 대하여 질의하는 명령어.
*

<select_statement> ::= <query_specification> ;

<query_specification> ::= SELECT [ <qualifier> ] <select_expressions> 
                          [ { TO | INTO } <variable_comma_list ]
			  FROM <table_specification_comma_list>
			  [ WHERE <search_condition> ]
			  [ GROUP BY <path_expression_comma_list> ]
			  [ HAVING <search_condition> ]

<qualifier> ::= ALL | DISTINCT | UNIQUE

<select_expressions> ::= * | <expression_comma_list>

<table_specification> ::= <class_specfication> [ <correlation> ] |
			  <metaclass_specification> [ <correlation> ] |
			  <subquery> <correlation> |
			  TABLE ( <expression> ) <correlation>

<correlation> ::= [ AS ] <identifier> [ ( <identifier_comma_list> ) ]

<class_specification> ::= <class_hierarchy> | ( <class_hierarchy_comma_list )

<class_hierarchy> ::= [ ONLY ] <class_name> |
		      ALL <class_name> [ EXCEPT <class_specification> ]

<metaclass_specification> ::= CLASS <class_name>

<query_statement> ::= <query_expression>
                      [ ORDER BY <sort_specification_comma_list> ]

<query_expression> ::= <query_term>
                       [ <table_operator> [ <qualifier> ] <query_term> ] ...

<query_term> ::= <query_specification> | <subquery>

<subquery> ::= ( <query_statement> )

<table_operator> ::= UNION | DIFFERENCE | INTERSECTION

<sort_specification> ::= <path_expression> [ ASC | DESC ] |
                         <unsigned_integer_literal [ ASC | DESC ]

*
        SELECT * FROM resort;
        SELECT lodging FROM location WHERE country = 'Jamaica';
        SELECT country, AVG(cost) FROM hotel
              WHERE allows_children = 'yes' AND
                    number_of_pools > 0
              GROUP BY country HAVING AVG(cost) <= $150.00;
*
!SET

세션 인자들 (트랜잭션, 트리거 등)의 값을 설정하는 명령어.
*
<set> := SET <session_parameter_and_value> [ <to_variable> ] ;

<session_parameter_and_value> := <isolation_level_setting> |
                                 <lock_timeout_setting> |
                                 <optimization_level_setting> |
				 <trigger_trace> |
				 <trigger_maximum_depth> 

<isolation_level_setting> := TRANSACTION ISOLATION LEVEL <isolation_level>

<isolation_level> := SERIALIZABLE |
                     CURSOR STABILITY |
                     <schema_isolation> [ , <instance_isolation> ] |
                     <instance_isolation> [ , <schema_isolation> ]

<schema_isolation> := REPEATABLE READ { SCHEMA | CLASS } |
                      READ COMMITTED { SCHEMA | CLASS } |
                      READ UNCOMMITTED { SCHEMA | CLASS }

<instance_isolation> := REPEATABLE READ INSTANCES |
                        READ COMMITTED INSTANCES |
                        READ UNCOMMITTED INSTANCES

<lock_timeout_setting> := TRANSACTION LOCK TIMEOUT <timeout>

<timeout> := OFF |
             INFINITE |
             <unsigned_integer_literal>

<optimization_setting> := OPTIMIZATION <optimization_level>

<optimization_level> := ON | OFF | <unsigned_integer_literal>

<trigger_trace> ::= TRIGGER TRACE <trace_setting>

<trace_setting> ::= ON | OFF | <unsigned_integer_literal>

<trigger_maximum_depth> ::= TRIGGER MAXIMUM DEPTH <depth_setting>

<depth_setting> ::= NONE | <unsigned_integer_literal>

*
        SET OPTIMIZATION LEVEL ON;
	SET TRANSACTION ISOLATION LEVEL REPEATABLE READ INSTANCES;
	SET TRIGGER TRACE OFF;
	SET TRIGGER MAXIMUM DEPTH 100;

*
!STATISTICS

데이터베이스 통계를 갱신하는 명령어.
*
<statistics> ::= UPDATE STATISTICS ON { <only_class_name_comma_list> | 
                                        ALL CLASSES | 
                                        CATALOG CLASSES } ;

<only_class_name> ::= [ ONLY ] <class_name>

*
        UPDATE STATISTICS ON employee, person;

        UPDATE STATISTICS ON all classes;

        UPDATE STATISTICS ON catalog classes;
*
!TRIGGER

트리거의 정의를 생성 또는 변경하는 명령어.
*
<create_trigger> ::= CREATE TRIGGER <trigger_name>
                     [ <status_spec> ]
                     [ <priority_spec> ]
                     <event_time> <event_type> [ <event_target> ]
		     [ IF <trigger_condition> ]
                     EXECUTE [ <delayed_action_time> ] <trigger_action> ;

<alter_trigger> ::= ALTER TRIGGER <trigger_name> <alter_trigger_clause> ;

<alter_trigger_clause> ::= <status_spec> | <priority_spec>


<status_spec> ::= STATUS <trigger_status>

<trigger_status> := ACTIVE | INACTIVE;

<priority_spec> ::= PRIORITY <unsigned_real>

<event_time> ::= BEFORE | AFTER | DEFERRED;

<delayed_action_time> ::= AFTER | DEFERRED;

<event_type> ::= INSERT | STATEMENT INSERT | UPDATE | STATEMENT UPDATE | 
		 DELETE | STATEMENT DELETE | COMMIT | ROLLBACK

<event_target> ::= ON <class_name> [ ( <attribute_name> ) ]

<trigger_condition> ::= <search_condition> | <call_statement>

<trigger_action> ::= REJECT | INVALIDATE TRANSACTION | 
	             PRINT <string_literal> |
                     EVALUATE <expression> |
                     <insert_statement> |
                     <update_statement> |
                     <delete_statement> |
                     <call_statement>

*
	CREATE TRIGGER check_age_update
	    BEFORE UPDATE ON person(age)
	    IF new.age < obj.age
	    EXECUTE REJECT;

	CREATE TRIGGER emit_message_on_commit
	    BEFORE COMMIT
	    EXECUTE PRINT "Committing transaction.";

	ALTER TRIGGER check_age_update PRIORITY 10.0;

	ALTER TRIGGER emit_message_on_commit STATUS INACTIVE;

*
!UPDATE

클래스의 인스턴스들을 변경하는 명령어.
*

<update> ::= UPDATE { <class_specification> | <metaclass_specification> }
             SET <assignment_comma_list>
             [ WHERE <search_condition> ]
             ;

<class_specification> ::= <class_hierarchy> | ( <class_hierarchy_comma_list )

<class_hierarchy> ::= [ ONLY ] <class_name> |
		      ALL <class_name> [ EXCEPT <class_specification> ]

<metaclass_specification> ::= CLASS <class_name>

<assignment> ::= [ <class_variable> . ] 
                 <attribute_name> = { <expression> | NULL }

*
        UPDATE resort
            SET cost = $198.00
            WHERE name = 'Tryall Golf, Tennis, and Beach Club';
*
!CREATE VCLASS
가상 클래스를 생성하는 명령어
*        
<create_vclass> ::= CREATE {VCLASS | VIEW} <class_name>
                    { <vclass_definition> }
                    ;

<vclass_definition> ::= [ AS SUBCLASS OF <class_name_comma_list> ]
                        [ CLASS ATTRIBUTE
                          ( <class_attribute_def_comma_list> ) ]
                        [ ( <view_attribute_definition_comma_list> ) ]
                        [ METHOD <method_definition_comma_list> ] 
                        [ FILE <method_file_comma_list> ]
                        [ INHERIT <resolution_comma_list> ]
                        [ AS <query_list> ]
                        [ WITH CHECK OPTION ]

<class_attribute_def> ::= <attribute_name> <data_type> 
                          [ DEFAULT <value_specification> ]

<view_attribute_definition> ::= <attribute_definition> | <attribute_name>

<attribute_definition> ::= <attribute_name> <data_type> [ <default_or_shared> ]

<method_definition> ::= [ CLASS ] <method_name>
                        [ ( [ <argument_type_comma_list> ] ) ]
                        [ <result_type> ]
                        [FUNCTION <function_name>]

<default_or_shared> ::= SHARED [ <value_specification> ] |
                        DEFAULT <value_specification>

<resolution> ::= [ CLASS ] <attribute_name> OF <class_name>
                 [ AS <attribute_name> ]

<argument_type> ::= <data_type> | POINTER
<result_type>   ::= <data_type> | POINTER
*
        CREATE VCLASS shipment_r (
            shipment_id  integer,
            product_code integer,
            quantity     integer,
            destination  char(15),
            origin       char(15))
        AS
        SELECT shipment_id, product_code, quantity, to_location, original_loc
        FROM shipment;
*
!PARTITION
파티션을 생성하거나, 파티션을 일반 클래스로 전환하는 명령어.
*
<create_partition> ::= <create_class> <partition_clause>

<alter_partition> ::= ALTER {CLASS | TABLE} <class_name> 
                      <alter_partition_clause>;

<create_class> ::= CREATE {CLASS | TABLE} <class_name>
                   [ <subclass_definition> ]
                   [ ( <class_element_comma_list> ) ]
                   [ CLASS ATTRIBUTE ( <attribute_definition_comma_list> ) ]
                   [ METHOD <method_definition_comma_list> ]
                   [ FILE <method_file_comma_list> ]
                   [ INHERIT <resolution_comma_list> ]
                   ;

<partition_clause> ::= PARTITION BY <partition_type> ( <expression > )
                       <partition_options>
                       
<partition_type> ::= HASH | RANGE | LIST

<partition_options> ::= ( <partition_definition_comma_list> )
                        | PARTITIONS <unsigned_integer>

<partition_definition> ::= PARTITION <partition_name> 
                          <partition_value_definition>

<partition_value_definition> ::= <partition_range> | <partition_list>

<partition_range> ::= VALUES LESS THAN <partition_range_values>

<partition_range_values> ::= MAXVALUE | ( <partition_value> )

<partition_list> ::= VALUES IN ( <partition_value_comma_list> )

<alter_partition_clause> ::= <partition_clause> |
                             REMOVE PARTITIONING
*
        CREATE CLASS person (
            name      string,
            birthday  date,
            residence string,
            UNIQUE (name))
        PARTITION BY RANGE ( name ) (
        PARTITION atoh VALUES LESS THAN ('I'),
        PARTITION itor VALUES LESS THAN ('S'),
        PARTITION etcname VALUES LESS THAN MAXVALUE );

        CREATE CLASS person (
            name      string,
            birthday  date,
            residence string,
            UNIQUE (name))
        PARTITION BY HASH ( name ) 
        PARTITIONS 20;

        ALTER CLASS person 
        PARTITION BY LIST ( SUBSTRING(residence from 1 for 1) ) (
        PARTITION atoh VALUES IN ('A','B','C','D','E','F','G','H'),
        PARTITION itoo VALUES IN ('I','J','K','L','M','N','O'));

        ALTER CLASS person REMOVE PARTITIONING;
*
!STORED PROCEDURE
저장 프로시저를 생성하거나 삭제하는 명령어.
*
<create_stored_procedure> ::= CREATE <name_spec> [IS | AS] LANGUAGE JAVA NAME <java_method_sig>;

<drop_stored_procedure> ::= DROP <sp_type> <name_list>;

<name_spec> ::= <procedure_spec> | <function_spec>

<procedure_spec> ::= PROCEDURE <procedure_name> ( [<parameter_list>] )

<function_spec> ::= FUNCTION <function_name> ( [<parameter_list>] ) RETURN <data_type>

<parameter_list> ::= <parameter> [, <parameter>]*

<parameter> ::= <parameter_name> [<sp_mode>] <data_type> 

<sp_mode> ::= IN | OUT | INOUT | IN OUT

<java_method_sig> ::= <char_string_literal>

<sp_type> ::= PROCEDURE | FUNCTION
*
        CREATE PROCEDURE proc(i varchar)
            AS LANGUAGE JAVA NAME 
            'SpTest.procTest(java.lang.String) return int';
        
        CREATE FUNCTION func(i int) 
            RETURN string AS LANGUAGE JAVA NAME 
            'SpTest.funcTest(int) return java.lang.String';

        DROP PROCEDURE proc;

        DROP FUNCTION func;
*
!USER
사용자를 생성하거나 삭제하는 명령어.
*
<create_user> ::= CREATE USER <user_name> 
                  [PASSWORD password]
                  [GROUPS user_name_comma_list]
                  [MEMBERS user_name_comma_list]; 

<drop_user> ::= DROP USER user_name;

<alter_user> ::= ALTER USER user_name PASSWORD password;

*
        CREATE USER david; 
        CREATE USER company; 
        CREATE USER engineering GROUPS company; 
        CREATE USER engineering MEMBERS david; 
        
        ALTER USER david PASSWORD 'passwd'; 
        
        DROP USER david; 
*