anchor.diff:  "
   
   "Other Grammar","Factor","
  -term [ { * | / } term [...] ]
  -","
  -A multiplication or division.
  +term [ { * | / | % } term [...] ]
  +","
  +A multiplication, division, or modulus of numeric type values.
   ","
   c * d
   e / 5
  +f % 10
   "
   
   "Other Grammar","Term","
  -value
  +{ value
  +    | ( expression )
       | bindParameter
       | function
       | case
       | caseWhen
  -    | ( operand )
       | [ tableAlias. ] columnRef
       | rowValueConstructor
  -","
  -A value.
  +    | cast
  +    | sequence
  +    | arrayConstructor } [ '[' expression ']' ]
  +","
  +A term which may use subscript notation if it's an array.
   ","
   'Hello'
  -"
  -
  +23
  +my_array[my_index]
  +array_col[1]
  +"
  +
  +"Other Grammar","Array Constructor","
  +ARRAY '[' expression [,...] ']'
  +","
  +Constructs an ARRAY out of the list of expressions.
  +","
  +ARRAY[1.0,2.2,3.3]
  +ARRAY['foo','bas']
  +ARRAY[col1,col2,col3+1,?]
  +"
  +
  +"Other Grammar","Sequence","
  +{NEXT | CURRENT} { VALUE | {number VALUES} } FOR sequenceRef
  +","
  +Gets the CURRENT or NEXT value for a sequence, a monotonically incrementing BIGINT
  +value. Each call to NEXT VALUE FOR increments the sequence value and returns the current value.
  +The NEXT <n> VALUES syntax may be used to reserve <n> consecutive sequence values.
  +A sequence is only increment once for a given statement, so multiple references to
  +the same sequence by NEXT VALUE FOR produce the same value. Use CURRENT VALUE FOR to
  +access the last sequence allocated with NEXT VALUE FOR for cluster connection of your
  +client. If no NEXT VALUE FOR had been previously called, an error will occur. These
  +calls are only allowed in the SELECT expressions or UPSERT VALUES expressions.
  +","
  +NEXT VALUE FOR my_table_id
  +NEXT 5 VALUES FOR my_table_id
  +CURRENT VALUE FOR my_schema.my_id_generator
  +"
  +"Other Grammar","Cast","
  +CAST ( expression AS dataType )
  +","
  +The CAST operator coerces the given expression to a different dataType. This
  +is useful, for example, to convert a BIGINT or INTEGER to a DECIMAL or DOUBLE
  +to prevent truncation to a whole number during arithmetic operations. It is
  +also useful to coerce from a more precise type to a less precise type since
  +this type of coercion will not automatically occur, for example from a TIMESTAMP
  +to a DATE. If the coercion is not possible, an error will occur.
  +","
  +CAST ( my_int AS DECIMAL )
  +CAST ( my_timestamp AS DATE )
  +"
   
   "Other Grammar","Row Value Constructor","
  -( term { ,term } [...] )
  +( expression { ,expression } [...] )
   ","
   A row value constructor is a list of other terms which are treated together as
   a kind of composite structure. They may be compared to each other or to other
  
positive.code: in the CREATE TABLE statement or afterwards in an ALTER TABLE statement). This reduces the overhead at write time to maintain the index.
  Otherwise, if this property is not set on the table, then incremental index maintenance will be performed on the server side when
  the data changes.
  ","
  CREATE INDEX my_idx ON sales.opportunity(last_updated_date DESC)
  CREATE INDEX my_idx ON log.event(created_date DESC) INCLUDE (name, payload) SALT_BUCKETS=10
  CREATE INDEX IF NOT EXISTS my_comp_idx ON server_metrics ( gc_time DESC, created_date DESC )
      DATA_BLOCK_ENCODING='NONE',VERSIONS=?,MAX_FILESIZE=2000000 split on (?, ?, ?)
  "
  
  "Commands","DROP INDEX","
  
negative.code: DELETE FROM TEST WHERE NAME LIKE 'foo%';
  "
  
  "Commands","DECLARE CURSOR","
  DECLARE CURSOR cursorName FOR selectStatement
  ","
  Creates a cursor for the select statement
  
  ","
  DECLARE CURSOR TEST_CURSOR FOR SELECT * FROM TEST_TABLE
  "
  
  "Commands","OPEN CURSOR","
  OPEN CURSOR cursorName
  ","
  Opens already declared cursor to perform FETCH operations
  
  ","
  OPEN CURSOR TEST_CURSOR
  "
  
  "Commands","FETCH NEXT","
  FETCH NEXT [n ROWS] FROM cursorName
  ","
  Retrieves next or next n rows from already opened cursor
  
  ","
  FETCH NEXT FROM TEST_CURSOR
  FETCH NEXT 10 ROWS FROM TEST_CURSOR
  "
  
  "Commands","CLOSE","
  CLOSE cursorName
  ","
  Closes an already open cursor
  
  ","
  CLOSE TEST_CURSOR
  "
  
  "Commands","CREATE TABLE","
  CREATE TABLE [IF NOT EXISTS] tableRef
  ( columnDef [,...] [constraint] )
  [tableOptions] [ SPLIT ON ( splitPoint [,...] ) ]
  ","
  Creates a new table. The HBase table and any column families referenced are created
  if they don't already exist. All table, column family and column names are uppercased unless they are double quoted in which case they are case sensitive.
  Column families that exist in the HBase table but are not listed are ignored.
  At create time, to improve query performance, an empty key value is added to the first column family of any existing rows or the default column family if no column families are explicitly defined. Upserts will also add this empty key value. This improves query performance by having a key value column we can guarantee always being there and thus minimizing the amount of data that must be projected and subsequently returned back to the client. HBase table and column configuration options may be passed through as key/value pairs to configure the HBase table as desired. Note that when using the IF NOT EXISTS clause, if a table already exists, then no change will be made to it. Additionally, no validation is done to check whether the existing table metadata matches the proposed table metadata. so it's better to use DROP TABLE followed by CREATE TABLE is the table metadata may be changing.
  
  ","
  CREATE TABLE my_schema.my_table ( id BIGINT not null primary key, date Date)
  CREATE TABLE my_table ( id INTEGER not null primary key desc, date DATE not null,
      m.db_utilization DECIMAL, i.db_utilization)
      m.DATA_BLOCK_ENCODING='DIFF'
  CREATE TABLE stats.prod_metrics ( host char(50) not null, created_date date not null,
      txn_count bigint CONSTRAINT pk PRIMARY KEY (host, created_date) )
  CREATE TABLE IF NOT EXISTS ""my_case_sensitive_table""
      ( ""id"" char(10) not null primary key, ""value"" integer)
      DATA_BLOCK_ENCODING='NONE',VERSIONS=5,MAX_FILESIZE=2000000 split on (?, ?, ?)
  CREATE TABLE IF NOT EXISTS my_schema.my_table (
      org_id CHAR(15), entity_id CHAR(15), payload binary(1000),
      CONSTRAINT pk PRIMARY KEY (org_id, entity_id) )
      TTL=86400
  "
  
  "Commands","DROP TABLE","
  DROP TABLE [IF EXISTS] tableRef [CASCADE]
  ","
  Drops a table. The optional CASCADE keyword causes any views on the table to be dropped as well. When dropping a table, by default the underlying HBase data and index tables are dropped. The phoenix.schema.dropMetaData
  may be used to override this and keep the HBase table for point-in-time queries.
  
  ","
  DROP TABLE my_schema.my_table;
  DROP TABLE IF EXISTS my_table;
  DROP TABLE my_schema.my_table CASCADE;
  "
  
  "Commands","CREATE FUNCTION","
  CREATE [TEMPORARY] FUNCTION funcName
  ([funcArgument[,...]])
  RETURNS dataType AS className [USING JAR jarPath]
  ","
  Creates a new function. The function name is uppercased unless they are double quoted in which case they are case sensitive. The function accepts zero or more arguments. The class name and jar path should be in single quotes. The jar path is optional and if not specified then the class name will be loaded from the jars present in directory configured for hbase.dynamic.jars.dir.
  
  ","
  
  CREATE FUNCTION my_reverse(varchar) returns varchar as 'com.mypackage.MyReverseFunction' using jar 'hdfs:/localhost:8080/hbase/lib/myjar.jar'
  CREATE FUNCTION my_reverse(varchar) returns varchar as 'com.mypackage.MyReverseFunction'
  CREATE FUNCTION my_increment(integer, integer constant defaultvalue='10') returns integer as 'com.mypackage.MyIncrementFunction' using jar '/hbase/lib/myincrement.jar'
  CREATE TEMPORARY FUNCTION my_reverse(varchar) returns varchar as 'com.mypackage.MyReverseFunction' using jar 'hdfs:/localhost:8080/hbase/lib/myjar.jar'
  "
  
  "Commands","DROP FUNCTION","
  DROP FUNCTION [IF EXISTS] funcName
  ","
  Drops a function.
  ","
  DROP FUNCTION IF EXISTS my_reverse
  DROP FUNCTION my_reverse
  "
  
  "Commands","CREATE VIEW","
  CREATE VIEW [IF NOT EXISTS] newTableRef
  [ ( columnDef [,...] ) ]
  [AS SELECT * FROM existingTableRef [WHERE expression] ]
  [tableOptions]
  ","
  Creates a new view over an existing HBase or Phoenix table. As expected, the WHERE expression is always automatically applied to any query run against the view. As with CREATE TABLE, the table, column family, and column names are uppercased unless they are double quoted. The newTableRef may refer directly to an HBase table, in which case, the table, column family, and column names must match the existing metadata exactly or an exception will occur. When a view is mapped directly to an HBase table, no empty key value will be added to rows and the view will be read-only.
  A view will be updatable (i.e. referenceable in a DML statement such as UPSERT or DELETE) if its WHERE clause expression contains only simple equality expressions separated by ANDs. Updatable views are not required to set the columns which appear in the equality expressions, as the equality expressions define the default values for those columns. If they are set, then they must match the value used in the WHERE clause, or an error will occur.
  All columns from the existingTableRef are included as columns in the new view as are columns defined in the columnDef list. An ALTER VIEW statement may be issued against a view to remove or add columns, however, no changes may be made to the primary key constraint. In addition, columns referenced in the WHERE clause are not allowed to be removed.
  Once a view is created for a table, that table may no longer altered or dropped until all of its views have been dropped.
  
  ","
  CREATE VIEW ""my_hbase_table""
      ( k VARCHAR primary key, ""v"" UNSIGNED_LONG) default_column_family='a';
  CREATE VIEW my_view ( new_col SMALLINT )
      AS SELECT * FROM my_table WHERE k = 100;
  CREATE VIEW my_view_on_view
      AS SELECT * FROM my_view WHERE new_col > 70;
  "
  
  "Commands","DROP VIEW","
  DROP VIEW [IF EXISTS] tableRef [CASCADE]
  ","
  Drops a view. The optional CASCADE keyword causes any views derived from the view to be dropped as well. When dropping a view, the actual table data is not affected. However, index data for the view will be deleted.
  
  ","
  DROP VIEW my_view
  DROP VIEW IF EXISTS my_schema.my_view
  DROP VIEW IF EXISTS my_schema.my_view CASCADE
  "
  
  "Commands","CREATE SEQUENCE","
  CREATE SEQUENCE [IF NOT EXISTS] sequenceRef
  [START [WITH] {number | bindParameter}] [INCREMENT [BY] {number | bindParameter}]
  [MINVALUE {number | bindParameter}] [MAXVALUE {number | bindParameter}] [CYCLE]
  [CACHE {number | bindParameter}]
  ","
  Creates a monotonically increasing sequence. START controls the initial sequence value while INCREMENT controls
  by how much the sequence is incremented after each call to NEXT VALUE FOR. By default, the sequence will start
  with 1 and be incremented by 1. Specify CYCLE to indicate that the sequence should continue to generate values
  after reaching either its MINVALUE or MAXVALUE. After an ascending sequence reaches its MAXVALUE, it generates
  its MINVALUE. After a descending sequence reaches its MINVALUE, it generates its MAXVALUE. CACHE controls how
  many sequence values will be reserved from the server, cached on the client, and doled out as need by subsequent
  NEXT VALUE FOR calls for that client connection to the cluster to save on RPC calls. If not specified, the
  phoenix.sequence.cacheSize config parameter defaulting to 100 will be used for the CACHE value.
  ","
  CREATE SEQUENCE my_sequence;
  CREATE SEQUENCE my_sequence START WITH -1000
  CREATE SEQUENCE my_sequence INCREMENT BY 10
  CREATE SEQUENCE my_schema.my_sequence START 0 CACHE 10
  "
  
  "Commands","DROP SEQUENCE","
  DROP SEQUENCE [IF EXISTS] sequenceRef
  ","
  Drops a sequence.
  
  ","
  DROP SEQUENCE my_sequence
  DROP SEQUENCE IF EXISTS my_schema.my_sequence
  "
  
  "Commands","ALTER","
  ALTER {TABLE | VIEW} tableRef { { ADD [IF NOT EXISTS] columnDef [,...] [options] } | { DROP COLUMN [IF EXISTS] columnRef [,...] } | { SET options } }
  ","
  Alters an existing table by adding or removing columns or updating table options. When a column is dropped from a table, the data in
  that column is deleted as well. PK columns may not be dropped, and only nullable PK columns may be added. For a view,
  the data is not affected when a column is dropped. Note that creating or dropping columns
  only affects subsequent queries and data modifications. Snapshot queries that are connected at an earlier timestamp
  