anchor.diff:  cqlStatement returns [shared_ptr<parsed_statement> stmt]
   #if 0
       @after{ if (stmt != null) stmt.setBoundVariables(bindVariables); }
  +#endif
       : st1= selectStatement             { $stmt = st1; }
  +#if 0
       | st2= insertStatement             { $stmt = st2; }
       | st3= updateStatement             { $stmt = st3; }
       | st4= batchStatement              { $stmt = st4; }
       | st5= deleteStatement             { $stmt = st5; }
   #endif
  -    : st6= useStatement                { $stmt = st6; }
  +    | st6= useStatement                { $stmt = st6; }
   #if 0
       | st7= truncateStatement           { $stmt = st7; }
       | st8= createKeyspaceStatement     { $stmt = st8; }
  
positive.code:     : K_USE ks=keyspaceName { $stmt = ::make_shared<use_statement>(ks); }
      ;
  
  #if 0
  /**
   * SELECT <expression>
   * FROM <CF>
   * WHERE KEY = "key1" AND COL > 1 AND COL < 100
   * LIMIT <NUMBER>;
   */
  selectStatement returns [SelectStatement.RawStatement expr]
      @init {
          boolean isDistinct = false;
          Term.Raw limit = null;
          Map<ColumnIdentifier.Raw, Boolean> orderings = new LinkedHashMap<ColumnIdentifier.Raw, Boolean>();
          boolean allowFiltering = false;
      }
      : K_SELECT ( ( K_DISTINCT { isDistinct = true; } )? sclause=selectClause
                 | sclause=selectCountClause )
        K_FROM cf=columnFamilyName
        ( K_WHERE wclause=whereClause )?
        ( K_ORDER K_BY orderByClause[orderings] ( ',' orderByClause[orderings] )* )?
        ( K_LIMIT rows=intValue { limit = rows; } )?
        ( K_ALLOW K_FILTERING  { allowFiltering = true; } )?
        {
            SelectStatement.Parameters params = new SelectStatement.Parameters(orderings,
                                                                               isDistinct,
                                                                               allowFiltering);
            $expr = new SelectStatement.RawStatement(cf, params, sclause, wclause, limit);
        }
      ;
  
  selectClause returns [List<RawSelector> expr]
      : t1=selector { $expr = new ArrayList<RawSelector>(); $expr.add(t1); } (',' tN=selector { $expr.add(tN); })*
      | '\*' { $expr = Collections.<RawSelector>emptyList();}
      ;
  
  selector returns [RawSelector s]
      @init{ ColumnIdentifier alias = null; }
      : us=unaliasedSelector (K_AS c=ident { alias = c; })? { $s = new RawSelector(us, alias); }
      ;
  
  unaliasedSelector returns [Selectable.Raw s]
      @init { Selectable.Raw tmp = null; }
      :  ( c=cident                                  { tmp = c; }
         | K_WRITETIME '(' c=cident ')'              { tmp = new Selectable.WritetimeOrTTL.Raw(c, true); }
         | K_TTL       '(' c=cident ')'              { tmp = new Selectable.WritetimeOrTTL.Raw(c, false); }
         | f=functionName args=selectionFunctionArgs { tmp = new Selectable.WithFunction.Raw(f, args); }
         ) ( '.' fi=cident { tmp = new Selectable.WithFieldSelection.Raw(tmp, fi); } )* { $s = tmp; }
      ;
  
  selectionFunctionArgs returns [List<Selectable.Raw> a]
      : '(' ')' { $a = Collections.emptyList(); }
      | '(' s1=unaliasedSelector { List<Selectable.Raw> args = new ArrayList<Selectable.Raw>(); args.add(s1); }
  
negative.code: @parser::namespace{cql3}
  
  @parser::includes {
  #include "cql3/statements/select_statement.hh"
  #include "cql3/statements/use_statement.hh"
  #include "cql3/selection/raw_selector.hh"
  #include "cql3/constants.hh"
  #include "cql3/cql3_type.hh"
  #include "cql3/cf_name.hh"
  #include "core/sstring.hh"
  #include "CqlLexer.hpp"
  
  #include <unordered_map>
  }
  
  @parser::traits {
  using namespace cql3;
  using namespace cql3::statements;
  using namespace cql3::selection;
  }
  
  @header {
  