Use Arel helper methods to generate arel

app/models/disk.rb

@@ -11,7 +11,7 @@ class Disk < ApplicationRecord
   virtual_column :used_percent_of_provisioned, :type => :float
   virtual_column :partitions_aligned,          :type => :string,  :uses => {:partitions => :aligned}
   virtual_column :used_disk_storage, :type => :integer, :arel => (lambda do |t|
-    t.grouping(Arel::Nodes::NamedFunction.new('COALESCE', [t[:size_on_disk], t[:size], 0]))
+    t.grouping(t.coalesce([t[:size_on_disk], t[:size], 0]))
   end)
 
   # A performance improvement was introduced in Rails 6:

app/models/hardware.rb

@@ -147,8 +147,8 @@ def provisioned_storage
 
   virtual_attribute :provisioned_storage, :integer, :arel => (lambda do |t|
     t.grouping(
-      t.grouping(Arel::Nodes::NamedFunction.new('COALESCE', [arel_table[:allocated_disk_storage], 0])) +
-      t.grouping(Arel::Nodes::NamedFunction.new('COALESCE', [t[:memory_mb], 0])) * 1.megabyte
+      t.grouping(t.coalesce([t[:allocated_disk_storage], 0])) +
+      (t.grouping(t.coalesce([t[:memory_mb], 0])) * 1.megabyte)
     )
   end)
 

app/models/miq_group.rb

@@ -255,7 +255,7 @@ def regional_groups
   end
 
   def self.regional_groups(group)
-    where(arel_table.grouping(Arel::Nodes::NamedFunction.new("LOWER", [arel_table[:description]]).eq(group.description.downcase)))
+    where(arel_table.grouping(arel_table.lower(arel_table[:description]).eq(group.description.downcase)))
   end
 
   def self.create_tenant_group(tenant)

app/models/mixins/ownership_mixin.rb

@@ -24,7 +24,7 @@ module OwnershipMixin
     # all the same user.
     virtual_attribute :owned_by_current_user, :boolean, :uses => :evm_owner, :arel => (lambda do |t|
       userid = User.current_userid.to_s.downcase
-      t.grouping(Arel::Nodes::NamedFunction.new("LOWER", [arel_table[:evm_owner_userid]]).eq(userid))
+      t.grouping(t.lower(t[:evm_owner_userid]).eq(userid))
     end)
 
     virtual_delegate :owning_ldap_group, :to => "miq_group.description", :allow_nil => true, :type => :string
@@ -46,7 +46,7 @@ module OwnershipMixin
     virtual_attribute :owned_by_current_ldap_group, :boolean, :arel => (lambda do |t|
       ldap_group = User.current_user.try(:ldap_group).to_s.downcase
 
-      t.grouping(Arel::Nodes::NamedFunction.new("LOWER", [arel_table[:owning_ldap_group]]).eq(ldap_group))
+      t.grouping(t.lower(t[:owning_ldap_group]).eq(ldap_group))
     end)
   end
 
@@ -92,11 +92,11 @@ def user_or_group_owned(user, miq_group)
     private
 
     def user_owned(user)
-      where(arel_table.grouping(Arel::Nodes::NamedFunction.new("LOWER", [arel_table[:evm_owner_userid]]).eq(user.userid.downcase)))
+      where(arel_table.grouping(arel_table.lower(arel_table[:evm_owner_userid]).eq(user.userid.downcase)))
     end
 
     def group_owned(miq_group)
-      where(arel_table.grouping(Arel::Nodes::NamedFunction.new("LOWER", [arel_table[:owning_ldap_group]]).eq(miq_group.description.downcase)))
+      where(arel_table.grouping(arel_table.lower(arel_table[:owning_ldap_group]).eq(miq_group.description.downcase)))
     end
   end
 

app/models/service/aggregation.rb

@@ -65,9 +65,8 @@ def aggregate_all_vms_disk_count_arel
     # @return (see #aggregate_hardware_arel)
     def aggregate_all_vms_disk_space_allocated_arel
       column_name     = "aggregate_all_vm_disk_space_allocated"
-      coalesce_values = [disks_tbl[:size], zero]
-      aggregation_sql = Arel::Nodes::NamedFunction.new('SUM',
-                                                       [Arel::Nodes::NamedFunction.new('COALESCE', coalesce_values)])
+      coalesce_values = [disks_tbl[:size], Arel.sql("0")]
+      aggregation_sql = Arel::Nodes::NamedFunction.new('SUM', [disks_tbl.coalesce(coalesce_values)])
       aggregate_hardware_arel(column_name, aggregation_sql, :include_disks => true)
     end
 
@@ -78,9 +77,8 @@ def aggregate_all_vms_disk_space_allocated_arel
     # @return (see #aggregate_hardware_arel)
     def aggregate_all_vms_disk_space_used_arel
       column_name     = "aggregate_all_vm_disk_space_used"
-      coalesce_values = [disks_tbl[:size_on_disk], disks_tbl[:size], zero]
-      aggregation_sql = Arel::Nodes::NamedFunction.new('SUM',
-                                                       [Arel::Nodes::NamedFunction.new('COALESCE', coalesce_values)])
+      coalesce_values = [disks_tbl[:size_on_disk], disks_tbl[:size], Arel.sql("0")]
+      aggregation_sql = Arel::Nodes::NamedFunction.new('SUM', [disks_tbl.coalesce(coalesce_values)])
       aggregate_hardware_arel(column_name, aggregation_sql, :include_disks => true)
     end
 
@@ -167,7 +165,7 @@ def aggregation_where_clause(arel, subtree_services)
     #   service_resources, vms, and hardwares
     def base_service_aggregation_join(arel, services_tbl, options = {})
       arel.join(service_resources_tbl).on(service_resources_tbl[:service_id].eq(services_tbl[:id])
-                                  .and(service_resources_tbl[:resource_type].eq(vm_or_template_type)))
+                                  .and(service_resources_tbl[:resource_type].eq(Arel.sql("'VmOrTemplate'"))))
           .join(vms_tbl).on(vm_join_clause(options)).tap do |arel_query|
             unless options[:skip_hardware]
               arel_query.join(hardwares_tbl).on(hardwares_tbl[:vm_or_template_id].eq(vms_tbl[:id]))
@@ -230,20 +228,8 @@ def partitions_tbl
       @partitions_tbl ||= Partition.arel_table
     end
 
-    def zero
-      @zero ||= Arel::Nodes::SqlLiteral.new("0")
-    end
-
-    def vm_or_template_type
-      @vm_or_template_type ||= Arel::Nodes::SqlLiteral.new("'VmOrTemplate'")
-    end
-
-    def ancestry_match
-      @ancestry_match ||= Arel::Nodes::SqlLiteral.new("'/%'")
-    end
-
     def ancestry_ilike
-      @ancestry_ilike ||= Arel::Nodes::NamedFunction.new("CONCAT", [Service.arel_table[:id], ancestry_match])
+      @ancestry_ilike ||= Arel::Nodes::NamedFunction.new("CONCAT", [Service.arel_table[:id], Arel.sql("'/%'")])
     end
 
     def service_id_cast

app/models/tenant.rb

@@ -111,7 +111,7 @@ def nested_ae_namespaces
   end
 
   def self.regional_tenants(tenant)
-    where(arel_table.grouping(Arel::Nodes::NamedFunction.new("LOWER", [arel_table[:name]]).eq(tenant.name.downcase)))
+    where(arel_table.grouping(arel_table.lower(arel_table[:name]).eq(tenant.name.downcase)))
   end
 
   def accessible_tenant_ids(strategy = nil)

app/models/vm_or_template.rb

@@ -1232,13 +1232,13 @@ def normalized_state
   virtual_attribute :normalized_state, :string, :arel => (lambda do |t|
     t.grouping(
       Arel::Nodes::Case.new
-      .when(arel_table[:archived]).then(Arel::Nodes::SqlLiteral.new("\'archived\'"))
-      .when(arel_table[:orphaned]).then(Arel::Nodes::SqlLiteral.new("\'orphaned\'"))
-      .when(t[:template].eq(t.create_true)).then(Arel::Nodes::SqlLiteral.new("\'template\'"))
-      .when(t[:retired].eq(t.create_true)).then(Arel::Nodes::SqlLiteral.new("\'retired\'"))
-      .when(arel_table[:disconnected]).then(Arel::Nodes::SqlLiteral.new("\'disconnected\'"))
+      .when(arel_table[:archived]).then(Arel.sql("\'archived\'"))
+      .when(arel_table[:orphaned]).then(Arel.sql("\'orphaned\'"))
+      .when(t[:template].eq(t.create_true)).then(Arel.sql("\'template\'"))
+      .when(t[:retired].eq(t.create_true)).then(Arel.sql("\'retired\'"))
+      .when(arel_table[:disconnected]).then(Arel.sql("\'disconnected\'"))
       .else(t.lower(
-              Arel::Nodes::NamedFunction.new('COALESCE', [t[:power_state], Arel::Nodes::SqlLiteral.new("\'unknown\'")])
+              t.coalesce([t[:power_state], Arel.sql("\'unknown\'")])
       ))
     )
   end)
@@ -1336,7 +1336,7 @@ def v_is_a_template
   # technically it is capitalized, but for sorting, not a concern
   # but we do need nil to become false
   virtual_attribute :v_is_a_template, :string, :arel => (lambda do |t|
-    t.grouping(arel_coalesce([t[:template], t.create_false]))
+    t.grouping(t.coalesce([t[:template], t.create_false]))
   end)
 
   def v_datastore_path
@@ -1550,7 +1550,7 @@ def self.miq_expression_includes_any_ipaddresses_arel(ipaddress)
                      .join(networks).on(networks[:hardware_id].eq(hardwares[:id]))
                      .where(hardwares[:vm_or_template_id].eq(vms[:id]).and(match_grouping))
                      .take(1)
-    Arel::Nodes::SqlLiteral.new("1").eq(query)
+    Arel.sql("1").eq(query)
   end
 
   def self.scan_by_property(property, value, _options = {})
@@ -1720,11 +1720,4 @@ def command_queue_options(queue_options)
       :zone        => my_zone,
     }.merge(queue_options)
   end
-
-  # this is verbose, helper for generating arel
-  def self.arel_coalesce(values)
-    Arel::Nodes::NamedFunction.new('COALESCE', values)
-  end
-
-  private_class_method :arel_coalesce
 end

lib/miq_expression.rb

@@ -1536,7 +1536,7 @@ def subquery_for_contains(field, limiter_query)
 
     conn = main_model.connection
     sql  = conn.unprepared_statement { conn.to_sql(relation_query.arel) }
-    Arel::Nodes::In.new(primary_attribute, Arel::Nodes::SqlLiteral.new(sql))
+    Arel::Nodes::In.new(primary_attribute, Arel.sql(sql))
   end
 
   def self.determine_relat_path(ref)