diff --git a/auth/common.cc b/auth/common.cc
index f6bc6e0d58..06c692f633 100644
--- a/auth/common.cc
+++ b/auth/common.cc
@@ -68,13 +68,13 @@ static future<> create_metadata_table_if_missing_impl(
         return futurize_apply(std::move(func)).handle_exception_type([] (exceptions::already_exists_exception& ignored) { });
     };
     auto& db = qp.db();
-    auto parsed_statement = static_pointer_cast<cql3::statements::raw::cf_statement>(
-            cql3::query_processor::parse_statement(cql));
+    auto parsed_statement = cql3::query_processor::parse_statement(cql);
+    auto& parsed_cf_statement = static_cast<cql3::statements::raw::cf_statement&>(*parsed_statement);
 
-    parsed_statement->prepare_keyspace(meta::AUTH_KS);
+    parsed_cf_statement.prepare_keyspace(meta::AUTH_KS);
 
     auto statement = static_pointer_cast<cql3::statements::create_table_statement>(
-            parsed_statement->prepare(db, qp.get_cql_stats())->statement);
+            parsed_cf_statement.prepare(db, qp.get_cql_stats())->statement);
 
     const auto schema = statement->get_cf_meta_data(qp.db());
     const auto uuid = generate_legacy_id(schema->ks_name(), schema->cf_name());
diff --git a/cql3/Cql.g b/cql3/Cql.g
index 8a919c3ad7..918f16251c 100644
--- a/cql3/Cql.g
+++ b/cql3/Cql.g
@@ -319,63 +319,63 @@ struct uninitialized {
 
 /** STATEMENTS **/
 
-query returns [shared_ptr<raw::parsed_statement> stmnt]
-    : st=cqlStatement (';')* EOF { $stmnt = st; }
+query returns [std::unique_ptr<raw::parsed_statement> stmnt]
+    : st=cqlStatement (';')* EOF { $stmnt = std::move(st); }
     ;
 
-cqlStatement returns [shared_ptr<raw::parsed_statement> stmt]
+cqlStatement returns [std::unique_ptr<raw::parsed_statement> stmt]
     @after{ if (stmt) { stmt->set_bound_variables(_bind_variables); } }
-    : st1= selectStatement             { $stmt = st1; }
-    | st2= insertStatement             { $stmt = st2; }
-    | st3= updateStatement             { $stmt = st3; }
-    | st4= batchStatement              { $stmt = st4; }
-    | st5= deleteStatement             { $stmt = st5; }
-    | st6= useStatement                { $stmt = st6; }
-    | st7= truncateStatement           { $stmt = st7; }
-    | st8= createKeyspaceStatement     { $stmt = st8; }
-    | st9= createTableStatement        { $stmt = st9; }
-    | st10=createIndexStatement        { $stmt = st10; }
-    | st11=dropKeyspaceStatement       { $stmt = st11; }
-    | st12=dropTableStatement          { $stmt = st12; }
-    | st13=dropIndexStatement          { $stmt = st13; }
-    | st14=alterTableStatement         { $stmt = st14; }
-    | st15=alterKeyspaceStatement      { $stmt = st15; }
-    | st16=grantStatement              { $stmt = st16; }
-    | st17=revokeStatement             { $stmt = st17; }
-    | st18=listPermissionsStatement    { $stmt = st18; }
-    | st19=createUserStatement         { $stmt = st19; }
-    | st20=alterUserStatement          { $stmt = st20; }
-    | st21=dropUserStatement           { $stmt = st21; }
-    | st22=listUsersStatement          { $stmt = st22; }
+    : st1= selectStatement             { $stmt = std::move(st1); }
+    | st2= insertStatement             { $stmt = std::move(st2); }
+    | st3= updateStatement             { $stmt = std::move(st3); }
+    | st4= batchStatement              { $stmt = std::move(st4); }
+    | st5= deleteStatement             { $stmt = std::move(st5); }
+    | st6= useStatement                { $stmt = std::move(st6); }
+    | st7= truncateStatement           { $stmt = std::move(st7); }
+    | st8= createKeyspaceStatement     { $stmt = std::move(st8); }
+    | st9= createTableStatement        { $stmt = std::move(st9); }
+    | st10=createIndexStatement        { $stmt = std::move(st10); }
+    | st11=dropKeyspaceStatement       { $stmt = std::move(st11); }
+    | st12=dropTableStatement          { $stmt = std::move(st12); }
+    | st13=dropIndexStatement          { $stmt = std::move(st13); }
+    | st14=alterTableStatement         { $stmt = std::move(st14); }
+    | st15=alterKeyspaceStatement      { $stmt = std::move(st15); }
+    | st16=grantStatement              { $stmt = std::move(st16); }
+    | st17=revokeStatement             { $stmt = std::move(st17); }
+    | st18=listPermissionsStatement    { $stmt = std::move(st18); }
+    | st19=createUserStatement         { $stmt = std::move(st19); }
+    | st20=alterUserStatement          { $stmt = std::move(st20); }
+    | st21=dropUserStatement           { $stmt = std::move(st21); }
+    | st22=listUsersStatement          { $stmt = std::move(st22); }
 #if 0
     | st23=createTriggerStatement      { $stmt = st23; }
     | st24=dropTriggerStatement        { $stmt = st24; }
 #endif
-    | st25=createTypeStatement         { $stmt = st25; }
-    | st26=alterTypeStatement          { $stmt = st26; }
-    | st27=dropTypeStatement           { $stmt = st27; }
-    | st28=createFunctionStatement     { $stmt = st28; }
-    | st29=dropFunctionStatement       { $stmt = st29; }
+    | st25=createTypeStatement         { $stmt = std::move(st25); }
+    | st26=alterTypeStatement          { $stmt = std::move(st26); }
+    | st27=dropTypeStatement           { $stmt = std::move(st27); }
+    | st28=createFunctionStatement     { $stmt = std::move(st28); }
+    | st29=dropFunctionStatement       { $stmt = std::move(st29); }
 #if 0
     | st30=createAggregateStatement    { $stmt = st30; }
     | st31=dropAggregateStatement      { $stmt = st31; }
 #endif
-    | st32=createViewStatement         { $stmt = st32; }
-    | st33=alterViewStatement          { $stmt = st33; }
-    | st34=dropViewStatement           { $stmt = st34; }
-    | st35=listRolesStatement          { $stmt = st35; }
-    | st36=grantRoleStatement          { $stmt = st36; }
-    | st37=revokeRoleStatement         { $stmt = st37; }
-    | st38=dropRoleStatement           { $stmt = st38; }
-    | st39=createRoleStatement         { $stmt = st39; }
-    | st40=alterRoleStatement          { $stmt = st40; }
+    | st32=createViewStatement         { $stmt = std::move(st32); }
+    | st33=alterViewStatement          { $stmt = std::move(st33); }
+    | st34=dropViewStatement           { $stmt = std::move(st34); }
+    | st35=listRolesStatement          { $stmt = std::move(st35); }
+    | st36=grantRoleStatement          { $stmt = std::move(st36); }
+    | st37=revokeRoleStatement         { $stmt = std::move(st37); }
+    | st38=dropRoleStatement           { $stmt = std::move(st38); }
+    | st39=createRoleStatement         { $stmt = std::move(st39); }
+    | st40=alterRoleStatement          { $stmt = std::move(st40); }
     ;
 
 /*
  * USE <KEYSPACE>;
  */
-useStatement returns [::shared_ptr<raw::use_statement> stmt]
-    : K_USE ks=keyspaceName { $stmt = ::make_shared<raw::use_statement>(ks); }
+useStatement returns [std::unique_ptr<raw::use_statement> stmt]
+    : K_USE ks=keyspaceName { $stmt = std::make_unique<raw::use_statement>(ks); }
     ;
 
 /**
@@ -384,7 +384,7 @@ useStatement returns [::shared_ptr<raw::use_statement> stmt]
  * WHERE KEY = "key1" AND COL > 1 AND COL < 100
  * LIMIT <NUMBER>;
  */
-selectStatement returns [shared_ptr<raw::select_statement> expr]
+selectStatement returns [std::unique_ptr<raw::select_statement> expr]
     @init {
         bool is_distinct = false;
         ::shared_ptr<cql3::term::raw> limit;
@@ -409,7 +409,7 @@ selectStatement returns [shared_ptr<raw::select_statement> expr]
       ( K_BYPASS K_CACHE { bypass_cache = true; })?
       {
           auto params = make_lw_shared<raw::select_statement::parameters>(std::move(orderings), is_distinct, allow_filtering, is_json, bypass_cache);
-          $expr = ::make_shared<raw::select_statement>(std::move(cf), std::move(params),
+          $expr = std::make_unique<raw::select_statement>(std::move(cf), std::move(params),
             std::move(sclause), std::move(wclause), std::move(limit), std::move(per_partition_limit),
             std::move(gbcolumns));
       }
@@ -476,7 +476,7 @@ jsonValue returns [::shared_ptr<cql3::term::raw> value]
  * USING TIMESTAMP <long>;
  *
  */
-insertStatement returns [::shared_ptr<raw::modification_statement> expr]
+insertStatement returns [std::unique_ptr<raw::modification_statement> expr]
     @init {
         auto attrs = std::make_unique<cql3::attributes::raw>();
         std::vector<::shared_ptr<cql3::column_identifier::raw>> column_names;
@@ -492,7 +492,7 @@ insertStatement returns [::shared_ptr<raw::modification_statement> expr]
             ( K_IF K_NOT K_EXISTS { if_not_exists = true; } )?
             ( usingClause[attrs] )?
               {
-              $expr = ::make_shared<raw::insert_statement>(std::move(cf),
+              $expr = std::make_unique<raw::insert_statement>(std::move(cf),
                                                        std::move(attrs),
                                                        std::move(column_names),
                                                        std::move(values),
@@ -504,7 +504,7 @@ insertStatement returns [::shared_ptr<raw::modification_statement> expr]
             ( K_IF K_NOT K_EXISTS { if_not_exists = true; } )?
             ( usingClause[attrs] )?
               {
-              $expr = ::make_shared<raw::insert_json_statement>(std::move(cf),
+              $expr = std::make_unique<raw::insert_json_statement>(std::move(cf),
                                                        std::move(attrs),
                                                        std::move(json_value),
                                                        if_not_exists,
@@ -528,7 +528,7 @@ usingClauseObjective[std::unique_ptr<cql3::attributes::raw>& attrs]
  * SET name1 = value1, name2 = value2
  * WHERE key = value;
  */
-updateStatement returns [::shared_ptr<raw::update_statement> expr]
+updateStatement returns [std::unique_ptr<raw::update_statement> expr]
     @init {
         bool if_exists = false;
         auto attrs = std::make_unique<cql3::attributes::raw>();
@@ -540,7 +540,7 @@ updateStatement returns [::shared_ptr<raw::update_statement> expr]
       K_WHERE wclause=whereClause
       ( K_IF (K_EXISTS{ if_exists = true; } | conditions=updateConditions) )?
       {
-          return ::make_shared<raw::update_statement>(std::move(cf),
+          return std::make_unique<raw::update_statement>(std::move(cf),
                                                   std::move(attrs),
                                                   std::move(operations),
                                                   std::move(wclause),
@@ -560,7 +560,7 @@ updateConditions returns [conditions_type conditions]
  * WHERE KEY = keyname
    [IF (EXISTS | name = value, ...)];
  */
-deleteStatement returns [::shared_ptr<raw::delete_statement> expr]
+deleteStatement returns [std::unique_ptr<raw::delete_statement> expr]
     @init {
         auto attrs = std::make_unique<cql3::attributes::raw>();
         std::vector<::shared_ptr<cql3::operation::raw_deletion>> column_deletions;
@@ -572,7 +572,7 @@ deleteStatement returns [::shared_ptr<raw::delete_statement> expr]
       K_WHERE wclause=whereClause
       ( K_IF ( K_EXISTS { if_exists = true; } | conditions=updateConditions ))?
       {
-          return ::make_shared<raw::delete_statement>(cf,
+          return std::make_unique<raw::delete_statement>(cf,
                                             std::move(attrs),
                                             std::move(column_deletions),
                                             std::move(wclause),
@@ -620,11 +620,11 @@ usingClauseDelete[std::unique_ptr<cql3::attributes::raw>& attrs]
  *   ...
  * APPLY BATCH
  */
-batchStatement returns [shared_ptr<cql3::statements::raw::batch_statement> expr]
+batchStatement returns [std::unique_ptr<cql3::statements::raw::batch_statement> expr]
     @init {
         using btype = cql3::statements::raw::batch_statement::type; 
         btype type = btype::LOGGED;
-        std::vector<shared_ptr<cql3::statements::raw::modification_statement>> statements;
+        std::vector<std::unique_ptr<cql3::statements::raw::modification_statement>> statements;
         auto attrs = std::make_unique<cql3::attributes::raw>();
     }
     : K_BEGIN
@@ -633,14 +633,14 @@ batchStatement returns [shared_ptr<cql3::statements::raw::batch_statement> expr]
           ( s=batchStatementObjective ';'? { statements.push_back(std::move(s)); } )*
       K_APPLY K_BATCH
       {
-          $expr = ::make_shared<cql3::statements::raw::batch_statement>(type, std::move(attrs), std::move(statements));
+          $expr = std::make_unique<cql3::statements::raw::batch_statement>(type, std::move(attrs), std::move(statements));
       }
     ;
 
-batchStatementObjective returns [shared_ptr<cql3::statements::raw::modification_statement> statement]
-    : i=insertStatement  { $statement = i; }
-    | u=updateStatement  { $statement = u; }
-    | d=deleteStatement  { $statement = d; }
+batchStatementObjective returns [std::unique_ptr<cql3::statements::raw::modification_statement> statement]
+    : i=insertStatement  { $statement = std::move(i); }
+    | u=updateStatement  { $statement = std::move(u); }
+    | d=deleteStatement  { $statement = std::move(d); }
     ;
 
 #if 0
@@ -694,7 +694,7 @@ dropAggregateStatement returns [DropAggregateStatement expr]
     ;
 #endif
 
-createFunctionStatement returns [shared_ptr<cql3::statements::create_function_statement> expr]
+createFunctionStatement returns [std::unique_ptr<cql3::statements::create_function_statement> expr]
     @init {
         bool or_replace = false;
         bool if_not_exists = false;
@@ -719,10 +719,10 @@ createFunctionStatement returns [shared_ptr<cql3::statements::create_function_st
       K_RETURNS rt = comparatorType
       K_LANGUAGE language = IDENT
       K_AS body = STRING_LITERAL
-      { $expr = ::make_shared<cql3::statements::create_function_statement>(std::move(fn), to_lower($language.text), $body.text, std::move(arg_names), std::move(arg_types), std::move(rt), called_on_null_input, or_replace, if_not_exists); }
+      { $expr = std::make_unique<cql3::statements::create_function_statement>(std::move(fn), to_lower($language.text), $body.text, std::move(arg_names), std::move(arg_types), std::move(rt), called_on_null_input, or_replace, if_not_exists); }
     ;
 
-dropFunctionStatement returns [shared_ptr<cql3::statements::drop_function_statement> expr]
+dropFunctionStatement returns [std::unique_ptr<cql3::statements::drop_function_statement> expr]
     @init {
         bool if_exists = false;
         std::vector<shared_ptr<cql3_type::raw>> arg_types;
@@ -740,19 +740,19 @@ dropFunctionStatement returns [shared_ptr<cql3::statements::drop_function_statem
         ')'
         { args_present = true; }
       )?
-      { $expr = ::make_shared<cql3::statements::drop_function_statement>(std::move(fn), std::move(arg_types), args_present, if_exists); }
+      { $expr = std::make_unique<cql3::statements::drop_function_statement>(std::move(fn), std::move(arg_types), args_present, if_exists); }
     ;
 
 /**
  * CREATE KEYSPACE [IF NOT EXISTS] <KEYSPACE> WITH attr1 = value1 AND attr2 = value2;
  */
-createKeyspaceStatement returns [shared_ptr<cql3::statements::create_keyspace_statement> expr]
+createKeyspaceStatement returns [std::unique_ptr<cql3::statements::create_keyspace_statement> expr]
     @init {
         auto attrs = make_shared<cql3::statements::ks_prop_defs>();
         bool if_not_exists = false;
     }
     : K_CREATE K_KEYSPACE (K_IF K_NOT K_EXISTS { if_not_exists = true; } )? ks=keyspaceName
-      K_WITH properties[*attrs] { $expr = ::make_shared<cql3::statements::create_keyspace_statement>(ks, attrs, if_not_exists); }
+      K_WITH properties[*attrs] { $expr = std::make_unique<cql3::statements::create_keyspace_statement>(ks, attrs, if_not_exists); }
     ;
 
 /**
@@ -762,10 +762,10 @@ createKeyspaceStatement returns [shared_ptr<cql3::statements::create_keyspace_st
  *     <name3> <type>
  * ) WITH <property> = <value> AND ...;
  */
-createTableStatement returns [shared_ptr<cql3::statements::create_table_statement::raw_statement> expr]
+createTableStatement returns [std::unique_ptr<cql3::statements::create_table_statement::raw_statement> expr]
     @init { bool if_not_exists = false; }
     : K_CREATE K_COLUMNFAMILY (K_IF K_NOT K_EXISTS { if_not_exists = true; } )?
-      cf=columnFamilyName { $expr = make_shared<cql3::statements::create_table_statement::raw_statement>(cf, if_not_exists); }
+      cf=columnFamilyName { $expr = std::make_unique<cql3::statements::create_table_statement::raw_statement>(cf, if_not_exists); }
       cfamDefinition[*expr]
     ;
 
@@ -806,10 +806,10 @@ cfamOrdering[cql3::statements::cf_properties& expr]
  *    ....
  * )
  */
-createTypeStatement returns [::shared_ptr<create_type_statement> expr]
+createTypeStatement returns [std::unique_ptr<create_type_statement> expr]
     @init { bool if_not_exists = false; }
     : K_CREATE K_TYPE (K_IF K_NOT K_EXISTS { if_not_exists = true; } )?
-         tn=userTypeName { $expr = ::make_shared<create_type_statement>(tn, if_not_exists); }
+         tn=userTypeName { $expr = std::make_unique<create_type_statement>(tn, if_not_exists); }
          '(' typeColumns[*expr] ( ',' typeColumns[*expr]? )* ')'
     ;
 
@@ -822,7 +822,7 @@ typeColumns[create_type_statement& expr]
  * CREATE INDEX [IF NOT EXISTS] [indexName] ON <columnFamily> (<columnName>);
  * CREATE CUSTOM INDEX [IF NOT EXISTS] [indexName] ON <columnFamily> (<columnName>) USING <indexClass>;
  */
-createIndexStatement returns [::shared_ptr<create_index_statement> expr]
+createIndexStatement returns [std::unique_ptr<create_index_statement> expr]
     @init {
         auto props = make_shared<index_prop_defs>();
         bool if_not_exists = false;
@@ -833,7 +833,7 @@ createIndexStatement returns [::shared_ptr<create_index_statement> expr]
         (idxName[*name])? K_ON cf=columnFamilyName '(' (target1=indexIdent { targets.emplace_back(target1); } (',' target2=indexIdent { targets.emplace_back(target2); } )*)? ')'
         (K_USING cls=STRING_LITERAL { props->custom_class = sstring{$cls.text}; })?
         (K_WITH properties[*props])?
-      { $expr = ::make_shared<create_index_statement>(cf, name, targets, props, if_not_exists); }
+      { $expr = std::make_unique<create_index_statement>(cf, name, targets, props, if_not_exists); }
     ;
 
 indexIdent returns [::shared_ptr<index_target::raw> id]
@@ -856,7 +856,7 @@ indexIdent returns [::shared_ptr<index_target::raw> id]
  *  PRIMARY KEY (<pkColumns>)
  *  WITH <property> = <value> AND ...;
  */
-createViewStatement returns [::shared_ptr<create_view_statement> expr]
+createViewStatement returns [std::unique_ptr<create_view_statement> expr]
     @init {
         bool if_not_exists = false;
         std::vector<::shared_ptr<cql3::column_identifier::raw>> partition_keys;
@@ -870,7 +870,7 @@ createViewStatement returns [::shared_ptr<create_view_statement> expr]
     |   '(' k1=cident { partition_keys.push_back(k1); } ( ',' cn=cident { composite_keys.push_back(cn); } )* ')'
         )
         {
-             $expr = ::make_shared<create_view_statement>(
+             $expr = std::make_unique<create_view_statement>(
                 std::move(cf),
                 std::move(basecf),
                 std::move(sclause),
@@ -909,12 +909,12 @@ dropTriggerStatement returns [DropTriggerStatement expr]
 /**
  * ALTER KEYSPACE <KS> WITH <property> = <value>;
  */
-alterKeyspaceStatement returns [shared_ptr<cql3::statements::alter_keyspace_statement> expr]
+alterKeyspaceStatement returns [std::unique_ptr<cql3::statements::alter_keyspace_statement> expr]
     @init {
         auto attrs = make_shared<cql3::statements::ks_prop_defs>();
     }
     : K_ALTER K_KEYSPACE ks=keyspaceName
-        K_WITH properties[*attrs] { $expr = ::make_shared<cql3::statements::alter_keyspace_statement>(ks, attrs); }
+        K_WITH properties[*attrs] { $expr = std::make_unique<cql3::statements::alter_keyspace_statement>(ks, attrs); }
     ;
 
 /**
@@ -924,7 +924,7 @@ alterKeyspaceStatement returns [shared_ptr<cql3::statements::alter_keyspace_stat
  * ALTER COLUMN FAMILY <CF> WITH <property> = <value>;
  * ALTER COLUMN FAMILY <CF> RENAME <column> TO <column>;
  */
-alterTableStatement returns [shared_ptr<alter_table_statement> expr]
+alterTableStatement returns [std::unique_ptr<alter_table_statement> expr]
     @init {
         alter_table_statement::type type;
         auto props = make_shared<cql3::statements::cf_prop_defs>();
@@ -949,7 +949,7 @@ alterTableStatement returns [shared_ptr<alter_table_statement> expr]
                ( K_AND idn=cident K_TO toIdn=cident { renames.emplace_back(idn, toIdn); } )*
           )
     {
-        $expr = ::make_shared<alter_table_statement>(std::move(cf), type, std::move(column_changes), std::move(props), std::move(renames));
+        $expr = std::make_unique<alter_table_statement>(std::move(cf), type, std::move(column_changes), std::move(props), std::move(renames));
     }
     ;
 
@@ -968,126 +968,126 @@ cfisStatic returns [bool isStaticColumn]
  * ALTER TYPE <name> ADD <field> <newtype>;
  * ALTER TYPE <name> RENAME <field> TO <newtype> AND ...;
  */
-alterTypeStatement returns [::shared_ptr<alter_type_statement> expr]
+alterTypeStatement returns [std::unique_ptr<alter_type_statement> expr]
     : K_ALTER K_TYPE name=userTypeName
-          ( K_ALTER f=ident K_TYPE v=comparatorType { $expr = ::make_shared<alter_type_statement::add_or_alter>(name, false, f, v); }
-          | K_ADD   f=ident v=comparatorType        { $expr = ::make_shared<alter_type_statement::add_or_alter>(name, true, f, v); }
+          ( K_ALTER f=ident K_TYPE v=comparatorType { $expr = std::make_unique<alter_type_statement::add_or_alter>(name, false, f, v); }
+          | K_ADD   f=ident v=comparatorType        { $expr = std::make_unique<alter_type_statement::add_or_alter>(name, true, f, v); }
           | K_RENAME
-               { $expr = ::make_shared<alter_type_statement::renames>(name); }
-               renames[{ static_pointer_cast<alter_type_statement::renames>($expr) }]
+               { $expr = std::make_unique<alter_type_statement::renames>(name); }
+               renames[{ static_cast<alter_type_statement::renames&>(*$expr) }]
           )
     ;
 
 /**
  * ALTER MATERIALIZED VIEW <CF> WITH <property> = <value>;
  */
-alterViewStatement returns [::shared_ptr<alter_view_statement> expr]
+alterViewStatement returns [std::unique_ptr<alter_view_statement> expr]
     @init {
         auto props = make_shared<cql3::statements::cf_prop_defs>();
     }
     : K_ALTER K_MATERIALIZED K_VIEW cf=columnFamilyName K_WITH properties[*props]
     {
-        $expr = ::make_shared<alter_view_statement>(std::move(cf), std::move(props));
+        $expr = std::make_unique<alter_view_statement>(std::move(cf), std::move(props));
     }
     ;
 
-renames[::shared_ptr<alter_type_statement::renames> expr]
-    : fromId=ident K_TO toId=ident { $expr->add_rename(fromId, toId); }
+renames[alter_type_statement::renames& expr]
+    : fromId=ident K_TO toId=ident { $expr.add_rename(fromId, toId); }
       ( K_AND renames[$expr] )?
     ;
 
 /**
  * DROP KEYSPACE [IF EXISTS] <KSP>;
  */
-dropKeyspaceStatement returns [::shared_ptr<drop_keyspace_statement> ksp]
+dropKeyspaceStatement returns [std::unique_ptr<drop_keyspace_statement> ksp]
     @init { bool if_exists = false; }
-    : K_DROP K_KEYSPACE (K_IF K_EXISTS { if_exists = true; } )? ks=keyspaceName { $ksp = ::make_shared<drop_keyspace_statement>(ks, if_exists); }
+    : K_DROP K_KEYSPACE (K_IF K_EXISTS { if_exists = true; } )? ks=keyspaceName { $ksp = std::make_unique<drop_keyspace_statement>(ks, if_exists); }
     ;
 
 /**
  * DROP COLUMNFAMILY [IF EXISTS] <CF>;
  */
-dropTableStatement returns [::shared_ptr<drop_table_statement> stmt]
+dropTableStatement returns [std::unique_ptr<drop_table_statement> stmt]
     @init { bool if_exists = false; }
-    : K_DROP K_COLUMNFAMILY (K_IF K_EXISTS { if_exists = true; } )? cf=columnFamilyName { $stmt = ::make_shared<drop_table_statement>(cf, if_exists); }
+    : K_DROP K_COLUMNFAMILY (K_IF K_EXISTS { if_exists = true; } )? cf=columnFamilyName { $stmt = std::make_unique<drop_table_statement>(cf, if_exists); }
     ;
 
 /**
  * DROP TYPE <name>;
  */
-dropTypeStatement returns [::shared_ptr<drop_type_statement> stmt]
+dropTypeStatement returns [std::unique_ptr<drop_type_statement> stmt]
     @init { bool if_exists = false; }
-    : K_DROP K_TYPE (K_IF K_EXISTS { if_exists = true; } )? name=userTypeName { $stmt = ::make_shared<drop_type_statement>(name, if_exists); }
+    : K_DROP K_TYPE (K_IF K_EXISTS { if_exists = true; } )? name=userTypeName { $stmt = std::make_unique<drop_type_statement>(name, if_exists); }
     ;
 
 /**
  * DROP MATERIALIZED VIEW [IF EXISTS] <view_name>
  */
-dropViewStatement returns [::shared_ptr<drop_view_statement> stmt]
+dropViewStatement returns [std::unique_ptr<drop_view_statement> stmt]
     @init { bool if_exists = false; }
     : K_DROP K_MATERIALIZED K_VIEW (K_IF K_EXISTS { if_exists = true; } )? cf=columnFamilyName
-      { $stmt = ::make_shared<drop_view_statement>(cf, if_exists); }
+      { $stmt = std::make_unique<drop_view_statement>(cf, if_exists); }
     ;
 
 /**
  * DROP INDEX [IF EXISTS] <INDEX_NAME>
  */
-dropIndexStatement returns [::shared_ptr<drop_index_statement> expr]
+dropIndexStatement returns [std::unique_ptr<drop_index_statement> expr]
     @init { bool if_exists = false; }
     : K_DROP K_INDEX (K_IF K_EXISTS { if_exists = true; } )? index=indexName
-      { $expr = ::make_shared<drop_index_statement>(index, if_exists); }
+      { $expr = std::make_unique<drop_index_statement>(index, if_exists); }
     ;
 
 /**
   * TRUNCATE <CF>;
   */
-truncateStatement returns [::shared_ptr<truncate_statement> stmt]
-    : K_TRUNCATE (K_COLUMNFAMILY)? cf=columnFamilyName { $stmt = ::make_shared<truncate_statement>(cf); }
+truncateStatement returns [std::unique_ptr<truncate_statement> stmt]
+    : K_TRUNCATE (K_COLUMNFAMILY)? cf=columnFamilyName { $stmt = std::make_unique<truncate_statement>(cf); }
     ;
 
 /**
  * GRANT <permission> ON <resource> TO <grantee>
  */
-grantStatement returns [::shared_ptr<grant_statement> stmt]
+grantStatement returns [std::unique_ptr<grant_statement> stmt]
     : K_GRANT
           permissionOrAll
       K_ON
           resource
       K_TO
           grantee=userOrRoleName
-      { $stmt = ::make_shared<grant_statement>($permissionOrAll.perms, $resource.res, std::move(grantee)); } 
+      { $stmt = std::make_unique<grant_statement>($permissionOrAll.perms, $resource.res, std::move(grantee)); }
     ;
 
 /**
  * REVOKE <permission> ON <resource> FROM <revokee>
  */
-revokeStatement returns [::shared_ptr<revoke_statement> stmt]
+revokeStatement returns [std::unique_ptr<revoke_statement> stmt]
     : K_REVOKE
           permissionOrAll
       K_ON
           resource
       K_FROM
           revokee=userOrRoleName
-      { $stmt = ::make_shared<revoke_statement>($permissionOrAll.perms, $resource.res, std::move(revokee)); } 
+      { $stmt = std::make_unique<revoke_statement>($permissionOrAll.perms, $resource.res, std::move(revokee)); }
     ;
 
 /**
  * GRANT <rolename> to <grantee>
  */
-grantRoleStatement returns [::shared_ptr<grant_role_statement> stmt]
+grantRoleStatement returns [std::unique_ptr<grant_role_statement> stmt]
     : K_GRANT role=userOrRoleName K_TO grantee=userOrRoleName
-      { $stmt = ::make_shared<grant_role_statement>(std::move(role), std::move(grantee));  }
+      { $stmt = std::make_unique<grant_role_statement>(std::move(role), std::move(grantee));  }
     ;
 
 /**
  * REVOKE <rolename> FROM <revokee>
  */
-revokeRoleStatement returns [::shared_ptr<revoke_role_statement> stmt]
+revokeRoleStatement returns [std::unique_ptr<revoke_role_statement> stmt]
     : K_REVOKE role=userOrRoleName K_FROM revokee=userOrRoleName
-      { $stmt = ::make_shared<revoke_role_statement>(std::move(role), std::move(revokee)); }
+      { $stmt = std::make_unique<revoke_role_statement>(std::move(role), std::move(revokee)); }
     ;
 
-listPermissionsStatement returns [::shared_ptr<list_permissions_statement> stmt]
+listPermissionsStatement returns [std::unique_ptr<list_permissions_statement> stmt]
     @init {
 		std::optional<auth::resource> r;
 		std::optional<sstring> role;
@@ -1098,7 +1098,7 @@ listPermissionsStatement returns [::shared_ptr<list_permissions_statement> stmt]
       ( K_ON resource { r = $resource.res; } )?
       ( K_OF rn=userOrRoleName { role = sstring(static_cast<cql3::role_name>(rn).to_string()); } )?
       ( K_NORECURSIVE { recursive = false; } )?
-      { $stmt = ::make_shared<list_permissions_statement>($permissionOrAll.perms, std::move(r), std::move(role), recursive); } 
+      { $stmt = std::make_unique<list_permissions_statement>($permissionOrAll.perms, std::move(r), std::move(role), recursive); }
     ;
 
 permission returns [auth::permission perm]
@@ -1131,7 +1131,7 @@ roleResource returns [uninitialized<auth::resource> res]
 /**
  * CREATE USER [IF NOT EXISTS] <username> [WITH PASSWORD <password>] [SUPERUSER|NOSUPERUSER]
  */
-createUserStatement returns [::shared_ptr<create_role_statement> stmt]
+createUserStatement returns [std::unique_ptr<create_role_statement> stmt]
     @init {
         cql3::role_options opts;
         opts.is_superuser = false;
@@ -1142,42 +1142,42 @@ createUserStatement returns [::shared_ptr<create_role_statement> stmt]
     : K_CREATE K_USER (K_IF K_NOT K_EXISTS { ifNotExists = true; })? u=username
       ( K_WITH K_PASSWORD v=STRING_LITERAL { opts.password = $v.text; })?
       ( K_SUPERUSER { opts.is_superuser = true; } | K_NOSUPERUSER { opts.is_superuser = false; } )?
-      { $stmt = ::make_shared<create_role_statement>(cql3::role_name(u, cql3::preserve_role_case::yes), std::move(opts), ifNotExists); }
+      { $stmt = std::make_unique<create_role_statement>(cql3::role_name(u, cql3::preserve_role_case::yes), std::move(opts), ifNotExists); }
     ;
 
 /**
  * ALTER USER <username> [WITH PASSWORD <password>] [SUPERUSER|NOSUPERUSER]
  */
-alterUserStatement returns [::shared_ptr<alter_role_statement> stmt]
+alterUserStatement returns [std::unique_ptr<alter_role_statement> stmt]
     @init {
         cql3::role_options opts;
     }
     : K_ALTER K_USER u=username
       ( K_WITH K_PASSWORD v=STRING_LITERAL { opts.password = $v.text; })?
       ( K_SUPERUSER { opts.is_superuser = true; } | K_NOSUPERUSER { opts.is_superuser = false; } )?
-      { $stmt = ::make_shared<alter_role_statement>(cql3::role_name(u, cql3::preserve_role_case::yes), std::move(opts)); }
+      { $stmt = std::make_unique<alter_role_statement>(cql3::role_name(u, cql3::preserve_role_case::yes), std::move(opts)); }
     ;
 
 /**
  * DROP USER [IF EXISTS] <username>
  */
-dropUserStatement returns [::shared_ptr<drop_role_statement> stmt]
+dropUserStatement returns [std::unique_ptr<drop_role_statement> stmt]
     @init { bool ifExists = false; }
     : K_DROP K_USER (K_IF K_EXISTS { ifExists = true; })? u=username
-      { $stmt = ::make_shared<drop_role_statement>(cql3::role_name(u, cql3::preserve_role_case::yes), ifExists); }
+      { $stmt = std::make_unique<drop_role_statement>(cql3::role_name(u, cql3::preserve_role_case::yes), ifExists); }
     ;
 
 /**
  * LIST USERS
  */
-listUsersStatement returns [::shared_ptr<list_users_statement> stmt]
-    : K_LIST K_USERS { $stmt = ::make_shared<list_users_statement>(); }
+listUsersStatement returns [std::unique_ptr<list_users_statement> stmt]
+    : K_LIST K_USERS { $stmt = std::make_unique<list_users_statement>(); }
     ;
 
 /**
  * CREATE ROLE [IF NOT EXISTS] <role_name> [WITH <roleOption> [AND <roleOption>]*]
  */
-createRoleStatement returns [::shared_ptr<create_role_statement> stmt]
+createRoleStatement returns [std::unique_ptr<create_role_statement> stmt]
     @init {
         cql3::role_options opts;
         opts.is_superuser = false;
@@ -1186,36 +1186,36 @@ createRoleStatement returns [::shared_ptr<create_role_statement> stmt]
     }
     : K_CREATE K_ROLE (K_IF K_NOT K_EXISTS { if_not_exists = true; })? name=userOrRoleName
       (K_WITH roleOptions[opts])?
-      { $stmt = ::make_shared<create_role_statement>(name, std::move(opts), if_not_exists); }
+      { $stmt = std::make_unique<create_role_statement>(name, std::move(opts), if_not_exists); }
     ;
 
 /**
  * ALTER ROLE <rolename> [WITH <roleOption> [AND <roleOption>]*]
  */
-alterRoleStatement returns [::shared_ptr<alter_role_statement> stmt]
+alterRoleStatement returns [std::unique_ptr<alter_role_statement> stmt]
     @init {
         cql3::role_options opts;
     }
     : K_ALTER K_ROLE name=userOrRoleName
       (K_WITH roleOptions[opts])?
-      { $stmt = ::make_shared<alter_role_statement>(name, std::move(opts)); }
+      { $stmt = std::make_unique<alter_role_statement>(name, std::move(opts)); }
     ;
 
 /**
  * DROP ROLE [IF EXISTS] <rolename>
  */
-dropRoleStatement returns [::shared_ptr<drop_role_statement> stmt]
+dropRoleStatement returns [std::unique_ptr<drop_role_statement> stmt]
     @init {
         bool if_exists = false;
     }
     : K_DROP K_ROLE (K_IF K_EXISTS { if_exists = true; })? name=userOrRoleName
-      { $stmt = ::make_shared<drop_role_statement>(name, if_exists); }
+      { $stmt = std::make_unique<drop_role_statement>(name, if_exists); }
     ;
 
 /**
  * LIST ROLES [OF <rolename>] [NORECURSIVE]
  */
-listRolesStatement returns [::shared_ptr<list_roles_statement> stmt]
+listRolesStatement returns [std::unique_ptr<list_roles_statement> stmt]
     @init {
         bool recursive = true;
         std::optional<cql3::role_name> grantee;
@@ -1223,7 +1223,7 @@ listRolesStatement returns [::shared_ptr<list_roles_statement> stmt]
     : K_LIST K_ROLES
         (K_OF g=userOrRoleName { grantee = std::move(g); })?
         (K_NORECURSIVE { recursive = false; })?
-        { $stmt = ::make_shared<list_roles_statement>(grantee, recursive); }
+        { $stmt = std::make_unique<list_roles_statement>(grantee, recursive); }
     ;
 
 roleOptions[cql3::role_options& opts]
diff --git a/cql3/query_processor.cc b/cql3/query_processor.cc
index 99166baa8c..b7f4670602 100644
--- a/cql3/query_processor.cc
+++ b/cql3/query_processor.cc
@@ -607,10 +607,10 @@ prepared_cache_key_type query_processor::compute_thrift_id(
 
 std::unique_ptr<prepared_statement>
 query_processor::get_statement(const sstring_view& query, const service::client_state& client_state) {
-    ::shared_ptr<raw::parsed_statement> statement = parse_statement(query);
+    std::unique_ptr<raw::parsed_statement> statement = parse_statement(query);
 
     // Set keyspace for statement that require login
-    auto cf_stmt = dynamic_pointer_cast<raw::cf_statement>(statement);
+    auto cf_stmt = dynamic_cast<raw::cf_statement*>(statement.get());
     if (cf_stmt) {
         cf_stmt->prepare_keyspace(client_state);
     }
@@ -620,7 +620,7 @@ query_processor::get_statement(const sstring_view& query, const service::client_
     return p;
 }
 
-::shared_ptr<raw::parsed_statement>
+std::unique_ptr<raw::parsed_statement>
 query_processor::parse_statement(const sstring_view& query) {
     try {
         auto statement = util::do_with_parser(query,  std::mem_fn(&cql3_parser::CqlParser::query));
diff --git a/cql3/query_processor.hh b/cql3/query_processor.hh
index e55f2f0e8f..9a3ffbc3e2 100644
--- a/cql3/query_processor.hh
+++ b/cql3/query_processor.hh
@@ -147,7 +147,7 @@ public:
             const std::string_view& query_string,
             const sstring& keyspace);
 
-    static ::shared_ptr<statements::raw::parsed_statement> parse_statement(const std::string_view& query);
+    static std::unique_ptr<statements::raw::parsed_statement> parse_statement(const std::string_view& query);
 
     query_processor(service::storage_proxy& proxy, database& db, service::migration_notifier& mn, memory_config mcfg, cql_config& cql_cfg);
 
diff --git a/cql3/statements/alter_role_statement.hh b/cql3/statements/alter_role_statement.hh
index 8c47a835e7..eaeded9b90 100644
--- a/cql3/statements/alter_role_statement.hh
+++ b/cql3/statements/alter_role_statement.hh
@@ -62,6 +62,8 @@ public:
                 , _options(std::move(options)) {
     }
 
+    std::unique_ptr<prepared_statement> prepare(database& db, cql_stats& stats) override;
+
     void validate(service::storage_proxy&, const service::client_state&) const override;
 
     virtual future<> check_access(service::storage_proxy& proxy, const service::client_state&) const override;
diff --git a/cql3/statements/authentication_statement.cc b/cql3/statements/authentication_statement.cc
index e365cd1957..7e850164e1 100644
--- a/cql3/statements/authentication_statement.cc
+++ b/cql3/statements/authentication_statement.cc
@@ -46,11 +46,6 @@ uint32_t cql3::statements::authentication_statement::get_bound_terms() const {
     return 0;
 }
 
-std::unique_ptr<cql3::statements::prepared_statement> cql3::statements::authentication_statement::prepare(
-                database& db, cql_stats& stats) {
-    return std::make_unique<prepared_statement>(this->shared_from_this());
-}
-
 bool cql3::statements::authentication_statement::uses_function(
                 const sstring& ks_name, const sstring& function_name) const {
     return parsed_statement::uses_function(ks_name, function_name);
diff --git a/cql3/statements/authentication_statement.hh b/cql3/statements/authentication_statement.hh
index 8dba708705..6cd40d3fe9 100644
--- a/cql3/statements/authentication_statement.hh
+++ b/cql3/statements/authentication_statement.hh
@@ -50,14 +50,12 @@ namespace cql3 {
 
 namespace statements {
 
-class authentication_statement : public raw::parsed_statement, public cql_statement_no_metadata, public ::enable_shared_from_this<authentication_statement> {
+class authentication_statement : public raw::parsed_statement, public cql_statement_no_metadata {
 public:
     authentication_statement() : cql_statement_no_metadata(&timeout_config::other_timeout) {}
 
     uint32_t get_bound_terms() const override;
 
-    std::unique_ptr<prepared_statement> prepare(database& db, cql_stats& stats) override;
-
     bool uses_function(const sstring& ks_name, const sstring& function_name) const override;
 
     bool depends_on_keyspace(const sstring& ks_name) const override;
diff --git a/cql3/statements/authorization_statement.cc b/cql3/statements/authorization_statement.cc
index a9dcc35dae..7c281216b1 100644
--- a/cql3/statements/authorization_statement.cc
+++ b/cql3/statements/authorization_statement.cc
@@ -46,11 +46,6 @@ uint32_t cql3::statements::authorization_statement::get_bound_terms() const {
     return 0;
 }
 
-std::unique_ptr<cql3::statements::prepared_statement> cql3::statements::authorization_statement::prepare(
-                database& db, cql_stats& stats) {
-    return std::make_unique<prepared_statement>(this->shared_from_this());
-}
-
 bool cql3::statements::authorization_statement::uses_function(
                 const sstring& ks_name, const sstring& function_name) const {
     return parsed_statement::uses_function(ks_name, function_name);
diff --git a/cql3/statements/authorization_statement.hh b/cql3/statements/authorization_statement.hh
index faf81cc82b..7bfe736b49 100644
--- a/cql3/statements/authorization_statement.hh
+++ b/cql3/statements/authorization_statement.hh
@@ -54,14 +54,12 @@ namespace cql3 {
 
 namespace statements {
 
-class authorization_statement : public raw::parsed_statement, public cql_statement_no_metadata, public ::enable_shared_from_this<authorization_statement> {
+class authorization_statement : public raw::parsed_statement, public cql_statement_no_metadata {
 public:
     authorization_statement() : cql_statement_no_metadata(&timeout_config::other_timeout) {}
 
     uint32_t get_bound_terms() const override;
 
-    std::unique_ptr<prepared_statement> prepare(database& db, cql_stats& stats) override;
-
     bool uses_function(const sstring& ks_name, const sstring& function_name) const override;
 
     bool depends_on_keyspace(const sstring& ks_name) const override;
diff --git a/cql3/statements/create_role_statement.hh b/cql3/statements/create_role_statement.hh
index f2045f2b9b..76115320ac 100644
--- a/cql3/statements/create_role_statement.hh
+++ b/cql3/statements/create_role_statement.hh
@@ -54,10 +54,6 @@ namespace statements {
 class create_role_statement final : public authentication_statement {
     sstring _role;
 
-    bool _is_superuser;
-
-    bool _can_login;
-
     role_options _options;
 
     bool _if_not_exists;
@@ -70,6 +66,8 @@ public:
                 , _if_not_exists(if_not_exists) {
     }
 
+    std::unique_ptr<prepared_statement> prepare(database& db, cql_stats& stats) override;
+
     future<> grant_permissions_to_creator(const service::client_state&) const;
 
     void validate(service::storage_proxy&, const service::client_state&) const override;
diff --git a/cql3/statements/drop_role_statement.hh b/cql3/statements/drop_role_statement.hh
index f2b03cd478..7857e74d97 100644
--- a/cql3/statements/drop_role_statement.hh
+++ b/cql3/statements/drop_role_statement.hh
@@ -60,6 +60,8 @@ public:
     drop_role_statement(const cql3::role_name& name, bool if_exists) : _role(name.to_string()), _if_exists(if_exists) {
     }
 
+    std::unique_ptr<prepared_statement> prepare(database& db, cql_stats& stats) override;
+
     virtual void validate(service::storage_proxy&, const service::client_state&) const override;
 
     virtual future<> check_access(service::storage_proxy& proxy, const service::client_state&) const override;
diff --git a/cql3/statements/grant_role_statement.hh b/cql3/statements/grant_role_statement.hh
index c6b71095df..51bb62903e 100644
--- a/cql3/statements/grant_role_statement.hh
+++ b/cql3/statements/grant_role_statement.hh
@@ -61,6 +61,8 @@ public:
         : _role(name.to_string()), _grantee(grantee.to_string()) {
     }
 
+    std::unique_ptr<prepared_statement> prepare(database& db, cql_stats& stats) override;
+
     virtual future<> check_access(service::storage_proxy& proxy, const service::client_state&) const override;
 
     virtual future<::shared_ptr<cql_transport::messages::result_message>>
diff --git a/cql3/statements/grant_statement.cc b/cql3/statements/grant_statement.cc
index 70b119a501..64ffabadc0 100644
--- a/cql3/statements/grant_statement.cc
+++ b/cql3/statements/grant_statement.cc
@@ -42,6 +42,11 @@
 #include "grant_statement.hh"
 #include "auth/authorizer.hh"
 
+std::unique_ptr<cql3::statements::prepared_statement> cql3::statements::grant_statement::prepare(
+                database& db, cql_stats& stats) {
+    return std::make_unique<prepared_statement>(::make_shared<grant_statement>(*this));
+}
+
 future<::shared_ptr<cql_transport::messages::result_message>>
 cql3::statements::grant_statement::execute(service::storage_proxy& proxy, service::query_state& state, const query_options& options) const {
     auto& auth_service = *state.get_client_state().get_auth_service();
diff --git a/cql3/statements/grant_statement.hh b/cql3/statements/grant_statement.hh
index 11e0eb3b7d..92a5a0e229 100644
--- a/cql3/statements/grant_statement.hh
+++ b/cql3/statements/grant_statement.hh
@@ -51,6 +51,8 @@ class grant_statement : public permission_altering_statement {
 public:
     using permission_altering_statement::permission_altering_statement;
 
+    std::unique_ptr<prepared_statement> prepare(database& db, cql_stats& stats) override;
+
     future<::shared_ptr<cql_transport::messages::result_message>> execute(service::storage_proxy&
                     , service::query_state&
                     , const query_options&) const override;
diff --git a/cql3/statements/list_permissions_statement.cc b/cql3/statements/list_permissions_statement.cc
index 28c979dfb9..fc447d6b01 100644
--- a/cql3/statements/list_permissions_statement.cc
+++ b/cql3/statements/list_permissions_statement.cc
@@ -58,6 +58,11 @@ cql3::statements::list_permissions_statement::list_permissions_statement(
             , _recursive(recursive) {
 }
 
+std::unique_ptr<cql3::statements::prepared_statement> cql3::statements::list_permissions_statement::prepare(
+                database& db, cql_stats& stats) {
+    return std::make_unique<prepared_statement>(::make_shared<list_permissions_statement>(*this));
+}
+
 void cql3::statements::list_permissions_statement::validate(
         service::storage_proxy& proxy,
         const service::client_state& state) const {
diff --git a/cql3/statements/list_permissions_statement.hh b/cql3/statements/list_permissions_statement.hh
index 48711d1766..8e24e49ff2 100644
--- a/cql3/statements/list_permissions_statement.hh
+++ b/cql3/statements/list_permissions_statement.hh
@@ -61,6 +61,8 @@ private:
 public:
     list_permissions_statement(auth::permission_set, std::optional<auth::resource>, std::optional<sstring>, bool);
 
+    std::unique_ptr<prepared_statement> prepare(database& db, cql_stats& stats) override;
+
     void validate(service::storage_proxy&, const service::client_state&) const override;
 
     future<> check_access(service::storage_proxy& proxy, const service::client_state&) const override;
diff --git a/cql3/statements/list_roles_statement.hh b/cql3/statements/list_roles_statement.hh
index ba89bf848a..9e193ddefa 100644
--- a/cql3/statements/list_roles_statement.hh
+++ b/cql3/statements/list_roles_statement.hh
@@ -62,6 +62,8 @@ public:
     list_roles_statement(const std::optional<role_name>& grantee, bool recursive)
         : _grantee(grantee ? sstring(grantee->to_string()) : std::optional<sstring>()), _recursive(recursive) {}
 
+    std::unique_ptr<prepared_statement> prepare(database& db, cql_stats& stats) override;
+
     virtual future<> check_access(service::storage_proxy& proxy, const service::client_state&) const override;
 
     virtual future<::shared_ptr<cql_transport::messages::result_message>>
diff --git a/cql3/statements/list_users_statement.cc b/cql3/statements/list_users_statement.cc
index 7b9a7d97cc..9f6cba6d69 100644
--- a/cql3/statements/list_users_statement.cc
+++ b/cql3/statements/list_users_statement.cc
@@ -45,6 +45,11 @@
 #include "auth/common.hh"
 #include "transport/messages/result_message.hh"
 
+std::unique_ptr<cql3::statements::prepared_statement> cql3::statements::list_users_statement::prepare(
+                database& db, cql_stats& stats) {
+    return std::make_unique<prepared_statement>(::make_shared<list_users_statement>(*this));
+}
+
 void cql3::statements::list_users_statement::validate(service::storage_proxy& proxy, const service::client_state& state) const {
 }
 
diff --git a/cql3/statements/list_users_statement.hh b/cql3/statements/list_users_statement.hh
index 5118b57bef..0a1cb82617 100644
--- a/cql3/statements/list_users_statement.hh
+++ b/cql3/statements/list_users_statement.hh
@@ -49,6 +49,9 @@ namespace statements {
 
 class list_users_statement : public authentication_statement {
 public:
+
+    std::unique_ptr<prepared_statement> prepare(database& db, cql_stats& stats) override;
+
     void validate(service::storage_proxy&, const service::client_state&) const override;
     future<> check_access(service::storage_proxy& proxy, const service::client_state&) const override;
     future<::shared_ptr<cql_transport::messages::result_message>> execute(service::storage_proxy&
diff --git a/cql3/statements/raw/batch_statement.hh b/cql3/statements/raw/batch_statement.hh
index 320e712bf4..82cd60fe23 100644
--- a/cql3/statements/raw/batch_statement.hh
+++ b/cql3/statements/raw/batch_statement.hh
@@ -66,12 +66,12 @@ public:
 private:
     type _type;
     std::unique_ptr<attributes::raw> _attrs;
-    std::vector<shared_ptr<raw::modification_statement>> _parsed_statements;
+    std::vector<std::unique_ptr<raw::modification_statement>> _parsed_statements;
 public:
     batch_statement(
         type type_,
         std::unique_ptr<attributes::raw> attrs,
-        std::vector<shared_ptr<raw::modification_statement>> parsed_statements)
+        std::vector<std::unique_ptr<raw::modification_statement>> parsed_statements)
             : cf_statement(nullptr)
             , _type(type_)
             , _attrs(std::move(attrs))
diff --git a/cql3/statements/revoke_role_statement.hh b/cql3/statements/revoke_role_statement.hh
index d180e5806c..9601edf09c 100644
--- a/cql3/statements/revoke_role_statement.hh
+++ b/cql3/statements/revoke_role_statement.hh
@@ -61,6 +61,8 @@ public:
             : _role(name.to_string()), _revokee(revokee.to_string()) {
     }
 
+    std::unique_ptr<prepared_statement> prepare(database& db, cql_stats& stats) override;
+
     virtual future<> check_access(service::storage_proxy& proxy, const service::client_state&) const override;
 
     virtual future<::shared_ptr<cql_transport::messages::result_message>>
diff --git a/cql3/statements/revoke_statement.cc b/cql3/statements/revoke_statement.cc
index 7151dd9527..6765313f93 100644
--- a/cql3/statements/revoke_statement.cc
+++ b/cql3/statements/revoke_statement.cc
@@ -42,6 +42,11 @@
 #include "revoke_statement.hh"
 #include "auth/authorizer.hh"
 
+std::unique_ptr<cql3::statements::prepared_statement> cql3::statements::revoke_statement::prepare(
+                database& db, cql_stats& stats) {
+    return std::make_unique<prepared_statement>(::make_shared<revoke_statement>(*this));
+}
+
 future<::shared_ptr<cql_transport::messages::result_message>>
 cql3::statements::revoke_statement::execute(service::storage_proxy& proxy, service::query_state& state, const query_options& options) const {
     auto& auth_service = *state.get_client_state().get_auth_service();
diff --git a/cql3/statements/revoke_statement.hh b/cql3/statements/revoke_statement.hh
index 981e28fb03..c539bf6521 100644
--- a/cql3/statements/revoke_statement.hh
+++ b/cql3/statements/revoke_statement.hh
@@ -51,6 +51,8 @@ class revoke_statement : public permission_altering_statement {
 public:
     using permission_altering_statement::permission_altering_statement;
 
+    std::unique_ptr<prepared_statement> prepare(database& db, cql_stats& stats) override;
+
     future<::shared_ptr<cql_transport::messages::result_message>> execute(service::storage_proxy&
                     , service::query_state&
                     , const query_options&) const override;
diff --git a/cql3/statements/role-management-statements.cc b/cql3/statements/role-management-statements.cc
index f2f00e7038..6d8d0d311f 100644
--- a/cql3/statements/role-management-statements.cc
+++ b/cql3/statements/role-management-statements.cc
@@ -93,6 +93,11 @@ void validate_cluster_support(service::storage_proxy& proxy) {
 // `create_role_statement`
 //
 
+std::unique_ptr<prepared_statement> create_role_statement::prepare(
+                database& db, cql_stats& stats) {
+    return std::make_unique<prepared_statement>(::make_shared<create_role_statement>(*this));
+}
+
 future<> create_role_statement::grant_permissions_to_creator(const service::client_state& cs) const {
     return do_with(auth::make_role_resource(_role), [&cs](const auth::resource& r) {
         return auth::grant_applicable_permissions(
@@ -157,6 +162,11 @@ create_role_statement::execute(service::storage_proxy&,
 // `alter_role_statement`
 //
 
+std::unique_ptr<prepared_statement> alter_role_statement::prepare(
+                database& db, cql_stats& stats) {
+    return std::make_unique<prepared_statement>(::make_shared<alter_role_statement>(*this));
+}
+
 void alter_role_statement::validate(service::storage_proxy& p, const service::client_state&) const {
     validate_cluster_support(p);
 }
@@ -233,6 +243,11 @@ alter_role_statement::execute(service::storage_proxy&, service::query_state& sta
 // `drop_role_statement`
 //
 
+std::unique_ptr<prepared_statement> drop_role_statement::prepare(
+                database& db, cql_stats& stats) {
+    return std::make_unique<prepared_statement>(::make_shared<drop_role_statement>(*this));
+}
+
 void drop_role_statement::validate(service::storage_proxy& p, const service::client_state& state) const {
     validate_cluster_support(p);
 
@@ -285,6 +300,11 @@ drop_role_statement::execute(service::storage_proxy&, service::query_state& stat
 // `list_roles_statement`
 //
 
+std::unique_ptr<prepared_statement> list_roles_statement::prepare(
+                database& db, cql_stats& stats) {
+    return std::make_unique<prepared_statement>(::make_shared<list_roles_statement>(*this));
+}
+
 future<> list_roles_statement::check_access(service::storage_proxy& proxy, const service::client_state& state) const {
     state.ensure_not_anonymous();
 
@@ -415,6 +435,11 @@ list_roles_statement::execute(service::storage_proxy&, service::query_state& sta
 // `grant_role_statement`
 //
 
+std::unique_ptr<prepared_statement> grant_role_statement::prepare(
+                database& db, cql_stats& stats) {
+    return std::make_unique<prepared_statement>(::make_shared<grant_role_statement>(*this));
+}
+
 future<> grant_role_statement::check_access(service::storage_proxy& proxy, const service::client_state& state) const {
     state.ensure_not_anonymous();
 
@@ -438,6 +463,11 @@ grant_role_statement::execute(service::storage_proxy&, service::query_state& sta
 // `revoke_role_statement`
 //
 
+std::unique_ptr<prepared_statement> revoke_role_statement::prepare(
+                database& db, cql_stats& stats) {
+    return std::make_unique<prepared_statement>(::make_shared<revoke_role_statement>(*this));
+}
+
 future<> revoke_role_statement::check_access(service::storage_proxy& proxy, const service::client_state& state) const {
     state.ensure_not_anonymous();
 
diff --git a/cql3/statements/select_statement.cc b/cql3/statements/select_statement.cc
index 91434359b6..1cea966710 100644
--- a/cql3/statements/select_statement.cc
+++ b/cql3/statements/select_statement.cc
@@ -1643,7 +1643,7 @@ std::vector<size_t> select_statement::prepare_group_by(const schema& schema, sel
 
 namespace util {
 
-shared_ptr<cql3::statements::raw::select_statement> build_select_statement(
+std::unique_ptr<cql3::statements::raw::select_statement> build_select_statement(
             const sstring_view& cf_name,
             const sstring_view& where_clause,
             bool select_all_columns,
diff --git a/cql3/statements/truncate_statement.cc b/cql3/statements/truncate_statement.cc
index c3212afa7e..63a0e88599 100644
--- a/cql3/statements/truncate_statement.cc
+++ b/cql3/statements/truncate_statement.cc
@@ -63,7 +63,7 @@ uint32_t truncate_statement::get_bound_terms() const
 
 std::unique_ptr<prepared_statement> truncate_statement::prepare(database& db,cql_stats& stats)
 {
-    return std::make_unique<prepared_statement>(this->shared_from_this());
+    return std::make_unique<prepared_statement>(::make_shared<truncate_statement>(*this));
 }
 
 bool truncate_statement::uses_function(const sstring& ks_name, const sstring& function_name) const
diff --git a/cql3/statements/truncate_statement.hh b/cql3/statements/truncate_statement.hh
index ffd4c214b8..4059c43f2f 100644
--- a/cql3/statements/truncate_statement.hh
+++ b/cql3/statements/truncate_statement.hh
@@ -50,7 +50,7 @@ namespace cql3 {
 
 namespace statements {
 
-class truncate_statement : public raw::cf_statement, public cql_statement_no_metadata, public ::enable_shared_from_this<truncate_statement> {
+class truncate_statement : public raw::cf_statement, public cql_statement_no_metadata {
 public:
     truncate_statement(::shared_ptr<cf_name> name);
 
diff --git a/cql3/util.hh b/cql3/util.hh
index 621226f46f..b4c925bf62 100644
--- a/cql3/util.hh
+++ b/cql3/util.hh
@@ -75,7 +75,7 @@ inline sstring rename_column_in_where_clause(const sstring_view& where_clause, c
 /// build a CQL "select" statement with the desired parameters.
 /// If select_all_columns==true, all columns are selected and the value of
 /// selected_columns is ignored.
-shared_ptr<cql3::statements::raw::select_statement> build_select_statement(
+std::unique_ptr<cql3::statements::raw::select_statement> build_select_statement(
         const sstring_view& cf_name,
         const sstring_view& where_clause,
         bool select_all_columns,
diff --git a/db/view/view.cc b/db/view/view.cc
index 9227967653..839a244d17 100644
--- a/db/view/view.cc
+++ b/db/view/view.cc
@@ -84,7 +84,7 @@ view_info::view_info(const schema& schema, const raw_view_info& raw_view_info)
 
 cql3::statements::select_statement& view_info::select_statement() const {
     if (!_select_statement) {
-        shared_ptr<cql3::statements::raw::select_statement> raw;
+        std::unique_ptr<cql3::statements::raw::select_statement> raw;
         // FIXME(sarna): legacy code, should be removed after "computed_columns" feature is guaranteed
         // to be available on every node. Then, we won't need to check if this view is backing a secondary index.
         const column_definition* legacy_token_column = nullptr;
diff --git a/table_helper.cc b/table_helper.cc
index 70e77f22cc..a34c67fb22 100644
--- a/table_helper.cc
+++ b/table_helper.cc
@@ -34,12 +34,13 @@ future<> table_helper::setup_table() const {
         return make_ready_future<>();
     }
 
-    ::shared_ptr<cql3::statements::raw::cf_statement> parsed = static_pointer_cast<
-                    cql3::statements::raw::cf_statement>(cql3::query_processor::parse_statement(_create_cql));
-    parsed->prepare_keyspace(_keyspace);
+    auto parsed = cql3::query_processor::parse_statement(_create_cql);
+
+    cql3::statements::raw::cf_statement* parsed_cf_stmt = static_cast<cql3::statements::raw::cf_statement*>(parsed.get());
+    parsed_cf_stmt->prepare_keyspace(_keyspace);
     ::shared_ptr<cql3::statements::create_table_statement> statement =
                     static_pointer_cast<cql3::statements::create_table_statement>(
-                                    parsed->prepare(db, qp.get_cql_stats())->statement);
+                                    parsed_cf_stmt->prepare(db, qp.get_cql_stats())->statement);
     auto schema = statement->get_cf_meta_data(db);
 
     // Generate the CF UUID based on its KF names. This is needed to ensure that
diff --git a/test/boost/cql_auth_syntax_test.cc b/test/boost/cql_auth_syntax_test.cc
index 17631bd38b..05409d9b6f 100644
--- a/test/boost/cql_auth_syntax_test.cc
+++ b/test/boost/cql_auth_syntax_test.cc
@@ -127,7 +127,7 @@ static auto make_tester(modifier_rule_ptr<T> rule) {
 ///
 /// Assert that the semicolon-terminated CQL query is valid syntax, and return the parsed statement.
 ///
-static ::shared_ptr<cql3::statements::raw::parsed_statement>
+static std::unique_ptr<cql3::statements::raw::parsed_statement>
 test_valid(std::string_view cql_query) {
     return test_valid(cql_query, &cql3_parser::CqlParser::query);
 }