anchor.diff:  ```
   
   <<<
  +[[drop_sequence_statement]]
  +== DROP SEQUENCE Statement
  +
  +The DROP SEQUENCE Statement removes a sequence from the Trafodion database.
  +
  +NOTE: DDL statements are not currently supported in transactions. That means that you cannot run DDL statements inside a user-defined transaction (BEGIN WORK…COMMIT WORK) or when AUTOCOMMIT is OFF. To run these statements, AUTOCOMMIT must be turned ON (the default) for the session.
  +
  +If you want to change the initial value of a sequence, you can drop and then recreate a sequence with the same name and different START WITH value.
  +
  +DROP SEQUENCE is a Trafodion SQL extension.
  +
  +For more inforamation, see <<create_sequence_statement,CREATE SEQUENCE Statement>> or <<alter_sequence_statement,ALTER SEQUENCE Statement>>.
  +
  +```
  +DROP SEQUENCE [[catalog-name.]schema-name.]sequence 
  +```
  +
  +<<<
  +[[drop_sequence_syntax]]
  +=== Syntax Description of DROP SEQUENCE
  +
  +* `[[catalog-name.]schema-name.]sequence`
  +
  ++
  +Specifies the name of the sequence to be dropped, with optional catalog and schema name, where each part of the name is a valid sql identifier with a maximum of 128 characters. 
  +
  +<<<
  +[[drop_sequence_considerations]]
  +=== Considerations for DROP SEQUENCE
  +To issue a DROP SEQUENCE statement, one of the following must be true:
  +
  +* You are DB ROOT.
  +
  +* You are the owner of the sequence.
  +
  +* You have the DROP or DROP_SEQUENCE component privilege for the SQL_OPERATIONS component.
  +
  +<<<
  +[[drop_sequence_examples]]
  +=== Examples of DROP SEQUENCE
  +
  +The following statement drops the sequence named `employee_seq`, which is created in <<create_sequence_examples,Examples of CRAETE SEQUENCE>>.
  +
  +```
  +DROP SEQUENCE employee_seq
  +```
  +
  +<<<
   [[drop_table_statement]]
   == DROP TABLE Statement
   
  
positive.code: == CREATE INDEX Statement
  
  The CREATE INDEX statement creates an SQL index based on one or more columns of a table or table-like object.
  The CREATE VOLATILE INDEX statement creates an SQL index with a lifespan that is limited to the SQL session that
  the index is created. Volatile indexes are dropped automatically when the session ends. See <<Indexes,Indexes>>.
  
  CREATE INDEX is a {project-name} SQL extension.
  
  NOTE: DDL statements are not currently supported in transactions. That means that you cannot run this statement
  inside a user-defined transaction (BEGIN WORK&#8230;COMMIT WORK) or when AUTOCOMMIT is OFF. To run this statement,
  AUTOCOMMIT must be turned ON (the default) for the session.
  
  ```
  CREATE [VOLATILE] INDEX index ON table
     (column-name [ASC[ENDING] | DESC[ENDING]]
     [,column-name [ASC[ENDING] | DESC[ENDING]]]...)
     [HBASE_OPTIONS (hbase-options-list)]
  
negative.code: ```
  CREATE PRIVATE SCHEMA AUTHORIZATION JSmith;
  ```
  
  <<<
  [[create_sequence_statement]]
  == CREATE SEQUENCE Statement
  
  The CREATE SEQUENCE Statement produces an automatic ascending sequence of numeric values, which can be used by multiple users as primary key values. For example, to generate only odd numbers in a sequence, you can create a sequence defined with START WITH=1, INCREMENT BY=2.
  
  Multiple options can be concurrently specified and separated by a space. 
  
  There are two expressions can be used with sequence:
  
  * `seqnum(SEQUENCE, current)`: get the current value which is returned from the sequence on the current session rather than the current value of the sequence. 
  
  +
  For example, a sequence object called `employee_seq` which starts with 1 and caches up to 25 with only three users.
  
  +
  If User A calls `seqnum(SEQUENCE, current)`, it will return 1 and reserve from 1 to 25, and User B immediately calls `seqnum(SEQUENCE, current)` and it will return 26 and reserve from 26 to 51, then User C immediately calls `seqnum(SEQUENCE, current)` and it will return 51 and reserve from 51 to 75. 
  
  +
  Now, if User A immediately calls `seqnum(SEQUENCE, next)`, it will return 2 rather than 76. 76 will be returned if User A immediately calls `seqnum(SEQUENCE, next)` after achieving 25 where the cache for User A is exhausted.
  
  * `seqnum(SEQUENCE, next)`: advance the sequence and retrieve the next value. For an ascending sequence, this value is increasing.
  
  +
  NOTE: 
  
  ** It always returns the initial value of the sequence by calling `seqnum(SEQUENCE, current)` or `seqnum(SEQUENCE, next)` for the first time.
  
  ** It returns a new incremented value of the sequence with each subsequent reference to `seqnum(SEQUENCE, next)`.
  
  CREATE SEQUENCE is a Trafodion SQL extension.
  
  For more inforamation, see <<drop_sequence_statement,DROP SEQUENCE Statement>> or <<alter_sequence_statement,ALTER SEQUENCE Statement>>.
  
  ```
  CREATE SEQUENCE [[catalog-name.]schema-name.]sequence
  [START WITH integer]
  [INCREMENT BY integer]
  [MAXVALUE integer | NOMAXVALUE]
  [MINVALUE integer]
  [CACHE integer | NO CACHE]
  [CYCLE | NO CYCLE]
  [DATA TYPE]
  ```
  By default, it is an ascending sequence that starts with 1, increments by 1, has cache value of 25 and the
  maximum value of 2^63^-2, does not cycle and belongs to LARGEINT data type.
  
  [[create_sequence_syntax]]
  === Syntax Description of CREATE SEQUENCE
  
  * `[[catalog-name.]schema-name.]sequence`
  
  +
  Specifies the name of the sequence to be created, with optional catalog and schema name, where each part of the name is a valid sql identifier with a maximum of 128 characters.
  
  +
  The name should be unique and does not exist for any session in the same schema. Trafodion does not support the overloading of session names. That is, you cannot register the same session name more than once.
  
  +
  If you do not fully qualify the session name, Trafodion qualifies it according to the schema of the current session. For more information, see <<identifiers,Identifiers>> and <<database_object_names,Database Object Names>>.
  
  * `START WITH`
  
  +
  Specifies the initial value. This value can only be positive, and must be greater than or equal to MINVALUE (if NO CACHE is specified) and less than MAXVALUE.  
  
  +
  NOTE: If the initial value is beyond the range specified by MINVALUE or MAXVALUE, an error will be raised.
  
  +
  If not specified, the START WITH defaults to 1. For an ascending sequence, this value is MINVALUE.
  
  * `INCREMENT BY`
  +
  Specifies the increment value between consecutive sequence values. 
  
  +
  NOTE: This value can only be positive, so that Trafodion only supports ascending sequence. The value must be smaller than or equal to the difference between MAXVALUE and MINVALUE. 
  
  +
  If not specified, the INCREMENT BY defaults to 1.
  
  * `MAXVALUE`
  +
  Specifies the maximum value where an ascending sequence stops generating values or cycles. The default is 2^^63^-2.
  
  +
  The MAXVALUE of a sequence depends on the maximum value supported by the data type, and you can also specify a MAXVALUE within the range.
  
  +
  NOTE:
  
  ** An error is returned if MAXVALUE is beyond supported range, or if subsequent value is generated for an ascending sequence when the MAXVALUE is exceeded with NO CYCLE specified.
  
  ** MAXVALUE might not be same as the actual maximum value that the sequence generated if the INCREAMENT BY is a value other than 1. For example, when a sequence is specified with START WITH 3, INCREMENT 4 and MAXVALUE 12 will return a maximum value of 11.
  
  * `NONMAXVALUE`
  +
  If NOMAXVALUE is specified, for an ascending sequence, the MAXVALUE is the value you specified or the maximum value supported by the data type.
  
  * `MINVALUE`
  +
  Specifies the minimum value where an ascending sequence cycles after hitting the maximum limit. The default is 1.
  
  +
  The MINVALUE of a sequence depends on the minimum value supported by the data type, and you can also specify a MINVALUE within the range.
  
  +
  If MINVALUE and START WITH are not specified, for an ascending sequence, the MINVALUE defaults to 1.
  
  * `CYCLE`
  +
  Specifies that the sequence exhausts its range and wraps around after reaching its MAXVALUE.
  
  +
  If specified, for an ascending sequence, it restarts from MINVALUE after reaching MAXVALUE. 
  
  * `NOCYCLE`
  +
  Specifies that the sequence cannot cycle once the MAXVALUE is reached, and throws an exception when generating subsequent value if the limit is exceeded. 
  
  +
  NOCYCLE is the default. 
  
  * `CACHE`
  +
  Specifies the range of upcoming successive values preallocated and stored in memory for speeding up future request. 
  
  +
  The default CACHE value is 25. 
  
  +
  The minimum CACHE value is 2.
  
  +
  The CACHE value must be less than or equal to the value determined by following formula: 
  
  +
  `(MAXVALUE – START WITH + 1) / INCREMENT BY`
  
  +
  The sequence cache will be repopulated when the cache is exhausted.
  
  +
  NOTE: The unused preallocated values will be lost and leave unintended gaps if unexpected shutdown occurs or the sequence object is manually restarted, Trafodion will continue to cache new values from where it left off, so that the same value will never appear twice unless CYCLE is specified.
  
  * `NOCACHE`
  +
  Specifies the values of the sequence are not preallocated, which lowers the risk of losing values even if it might cause performance degradation. In this case, every request for a new value will be synchronously updated in the system table.
  
  +
  If both CACHE and NOCACHE are not specified, it will cache 25 values by default.
  
  * `DATA TYPE`
  +
  A sequence can be specified as following data types:
  
  +
  [cols="1,1,1,options="header"]
  |===
  | Type   | Minimum value | Maximum value 
  | UNSIGNED SMALLINT   | 1                | 2^16^-1
  | UNSIGHED INTEGER    | 1                | 2^32^-1
  | LARGEINT            | 1                | 2^63^-2
  |===
                  
  +
  If not specified, the default data type is LARGEINT.
  
  <<<
  [[create_sequence_considerations]]
  === Considerations for CREATE SEQUENCE
  
  To issue a CREATE SEQUENCE statement, one of the following must be true:
  
  * You are DB ROOT.
  
  * You are creating the sequence in a shared schema.
  
  * You are the private schema owner.
  
  * You have the CREATE or CREATE_SEQUENCE component privilege for the SQL_OPERATIONS component.
  
  +
  NOTE: In this case, if you create a sequence in a private schema, it will be owned by the schema owner.
  
  <<<
  [[create_sequence_examples]]
  === Examples of CREATE SEQUENCE
  
  The following statement creates a sequence named `employee_seq`, that starts with 1, increments by 1, has maximum value of 10000, does not cycle, caches 20 at a time and belongs to UNSIGNED SAMLLINT.
  
  ```
  CREATE SEQUENCE   employee_seq
  START WITH        1
  INCREMENT BY      1
  MAXVALUE          10000   
  NOCYCLE
  CACHE             20  
  UNSIGNED SMALLINT
  ```
  
  The first reference to `seqnum(empolyee_seq, next)` will return 10000, and the second reference will return 10001. Each subsequent reference will return a value 1 greater than the previous value.
  
  <<<
  [[create_table_statement]]
  