babik 0.1.0

data/lib/babik/queryset/mixins/updatable.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module Babik
+  module QuerySet
+    # Functionality related to the UPDATE operation
+    module Updatable
+      # Runs the update
+      # @param update_command [Hash{field: value}] Runs the update query.
+      def update(update_command)
+        self.model.connection.execute(sql.update(update_command))
+      end
+    end
+  end
+end

data/lib/babik/queryset/templates/default/delete/main.sql.erb

@@ -0,0 +1,14 @@
+<%#
+  SQL default delete.
+  Most DBMS engines optimize IN if there is a simple subquery inside pulling up the conditions as joins.
+%>
+
+<% model = queryset.model %>
+
+DELETE
+FROM <%= model.table_name %>
+WHERE id IN (
+    SELECT id FROM (
+        <%= queryset.sql.select %>
+    ) AS subquery
+)

data/lib/babik/queryset/templates/default/select/components/aggregation.sql.erb

@@ -0,0 +1,5 @@
+<% if queryset.aggregation? %>
+
+  <%= queryset._aggregation.sql %>
+
+<% end %>

data/lib/babik/queryset/templates/default/select/components/from.sql.erb

@@ -0,0 +1,16 @@
+
+<% if queryset.class == Babik::QuerySet::Base %>
+
+  FROM
+  <%= render.('select/components/from_table.sql.erb', {queryset: queryset}) %>
+
+<% elsif queryset.is_a?(Babik::QuerySet::SetOperation) %>
+
+  FROM
+  <%= render.('select/components/from_set.sql.erb', {queryset: queryset}) %>
+
+<% else %>
+
+  Operation NOT recognized
+
+<% end %>

data/lib/babik/queryset/templates/default/select/components/from_set.sql.erb

@@ -0,0 +1,3 @@
+(
+  (<%= queryset.left_operand.sql.select %>) <%= queryset.operation %> ( <%= queryset.right_operand.sql.select %>)
+) AS <%= queryset.model.table_name %>

data/lib/babik/queryset/templates/default/select/components/from_table.sql.erb

@@ -0,0 +1,2 @@
+
+<%= queryset.model.table_name %>

data/lib/babik/queryset/templates/default/select/components/limit.sql.erb

@@ -0,0 +1,10 @@
+<% limit = queryset._limit %>
+
+<% if limit %>
+
+  LIMIT <%= limit.size %>
+  <% if limit.offset %>
+    OFFSET <%= limit.offset %>
+  <% end %>
+
+<% end %>

data/lib/babik/queryset/templates/default/select/components/order_by.sql.erb

@@ -0,0 +1,9 @@
+<% order = queryset._order %>
+
+<%# Order the results %>
+<% if order %>
+
+  ORDER BY
+  <%= order.sql %>
+
+<% end %>

data/lib/babik/queryset/templates/default/select/components/projection.sql.erb

@@ -0,0 +1,7 @@
+<% if queryset.projection? %>
+
+  <% projection = queryset._projection %>
+
+  <%= projection.sql %>
+
+<% end %>

data/lib/babik/queryset/templates/default/select/components/select_related.sql.erb

@@ -0,0 +1,26 @@
+<% select_related = queryset._select_related %>
+<% associations = select_related.associations %>
+
+<%# Include each association target model in the select_related call in the SQL SELECT %>
+<% associations.each_with_index do |association, association_index| %>
+
+  <% last_one_association = association_index == associations.length - 1 %>
+
+  <% target_alias = association.target_alias %>
+  <% target_model = association.target_model %>
+
+  <%# Include each column of the target model in the SQL SELECT %>
+  <% target_model.column_names.each_with_index do |target_field, target_field_index| %>
+
+    <% last_one_target_field = target_field_index == target_model.column_names.length - 1 %>
+
+    <%# Each column is included with an alias. That alias is the association path replacing :: with __ %>
+    <%= target_alias %>.<%= target_field %>
+    AS
+    <%= association.id %>__<%= target_field %>
+
+    <% unless last_one_target_field %>,<% end %>
+  <% end %>
+
+  <% unless last_one_association %>,<% end %>
+<% end %>

data/lib/babik/queryset/templates/default/select/components/where.sql.erb

@@ -0,0 +1,39 @@
+<% where = queryset._where %>
+
+<% if where.inclusion_filters? || where.exclusion_filters?  %>
+
+  WHERE (
+    <% if where.inclusion_filters? %>
+      (
+        <% inclusion_filters = where.inclusion_filters %>
+        <% inclusion_filters.each_with_index do |condition, condition_index| %>
+          <% last_one = condition_index == inclusion_filters.length - 1 %>
+          (
+            <%= condition.sql %>
+          )
+          <% unless last_one %>AND<% end %>
+        <% end %>
+      )
+    <% end %>
+
+    <% if where.inclusion_filters? && where.exclusion_filters? %>
+    AND
+    <% end %>
+
+    <% if where.exclusion_filters? %>
+    ( NOT
+      (
+        <% exclusion_filters = where.exclusion_filters %>
+        <% exclusion_filters.each_with_index do |condition, condition_index| %>
+          <% last_one = condition_index == exclusion_filters.length - 1 %>
+          (
+            <%= condition.sql %>
+          )
+          <% unless last_one %>AND<% end %>
+        <% end %>
+      )
+    )
+    <% end %>
+  )
+
+<% end %>

data/lib/babik/queryset/templates/default/select/main.sql.erb

@@ -0,0 +1,42 @@
+<% model = queryset.model %>
+
+SELECT
+
+  <% if queryset.lock? %>
+    <%= queryset._lock_type %>
+  <% end %>
+
+  <% if queryset.distinct? %>
+    DISTINCT
+  <% end %>
+
+  <% if queryset.aggregation? %>
+    <%= render.('select/components/aggregation.sql.erb', {queryset: queryset}) %>
+  <% else %>
+    <% if queryset.projection? %>
+      <%# Projection of the results %>
+      <%= render.('select/components/projection.sql.erb', {queryset: queryset}) %>
+    <% else %>
+      <%= model.table_name %>.*
+      <% if queryset.select_related? %>
+        ,
+        <%= render.('select/components/select_related.sql.erb', {queryset: queryset}) %>
+      <% end %>
+    <% end %>
+
+  <% end %>
+
+<%# From %>
+<%= render.('select/components/from.sql.erb', {queryset: queryset}) %>
+
+<%# Left joins %>
+<%= queryset.sql.left_joins %>
+
+<%# Where conditions %>
+<%= render.('select/components/where.sql.erb', {queryset: queryset}) %>
+
+<%# Order the results %>
+<%= render.('select/components/order_by.sql.erb', {queryset: queryset}) %>
+
+<%# Limit the results (only MySQL, MariaDB and PostgreSQL) %>
+<%= render.('select/components/limit.sql.erb', {queryset: queryset}) %>

data/lib/babik/queryset/templates/default/update/main.sql.erb

@@ -0,0 +1,15 @@
+<%#
+  SQL default update.
+  Most DBMS engines optimize IN if there is a simple subquery inside pulling up the conditions as joins
+%>
+
+<% model = queryset.model %>
+
+UPDATE <%= model.table_name %>
+SET
+  <% update_command.each do |field, value| %>
+    <%= Babik::QuerySet::Update::Assignment.sql_field(model, field) %> = <%= Babik::QuerySet::Update::Assignment.sql_value(value) %>
+  <% end %>
+WHERE id IN (
+  <%= queryset.sql.select %>
+)

data/lib/babik/queryset/templates/mssql/select/components/limit.sql.erb

@@ -0,0 +1,8 @@
+<% limit = queryset._limit %>
+
+<% if limit %>
+
+  OFFSET  <%= limit.offset ? limit.offset : 0 %> ROWS
+  FETCH NEXT <%= limit.size %> ROWS ONLY
+
+<% end %>

data/lib/babik/queryset/templates/mssql/select/components/order_by.sql.erb

@@ -0,0 +1,21 @@
+<% order = queryset._order %>
+
+
+<%# Order the results %>
+<% if order %>
+
+  ORDER BY
+  <%= order.sql %>
+
+<% else %>
+
+  <% limit = queryset._limit %>
+
+  <%# MSSQL server requires always an ORDER BY if a OFFSET - FETCH NEXT clause is present %>
+  <% if limit %>
+
+    ORDER BY <%= queryset.model.table_name %>.id ASC
+
+  <% end %>
+
+<% end %>

data/lib/babik/queryset/templates/mysql2/delete/main.sql.erb

@@ -0,0 +1,15 @@
+<%#
+  SQL default delete.
+  Most DBMS engines optimize IN if there is a simple subquery inside pulling up the conditions as joins.
+%>
+
+<% model = queryset.model %>
+
+
+DELETE <%= model.table_name %>.*
+FROM <%= model.table_name %> <%= model.table_name %>
+
+<%= queryset.sql.left_joins %>
+
+<%# Where conditions %>
+<%= render.('select/components/where.sql.erb', {queryset: queryset}) %>

data/lib/babik/queryset/templates/mysql2/update/main.sql.erb

@@ -0,0 +1,18 @@
+<%#
+  SQL default update.
+  Most DBMS engines optimize IN if there is a simple subquery inside pulling up the conditions as joins
+%>
+
+<% model = queryset.model %>
+
+UPDATE <%= model.table_name %> AS <%= model.table_name %>
+
+<%= queryset.sql.left_joins %>
+
+SET
+  <% update_command.each do |field, value| %>
+    <%= model.table_name %>.<%= Babik::QuerySet::Update::Assignment.sql_field(model, field) %> = <%= Babik::QuerySet::Update::Assignment.sql_value(value) %>
+  <% end %>
+
+<%# Where conditions %>
+<%= render.('select/components/where.sql.erb', {queryset: queryset}) %>

data/lib/babik/queryset/templates/sqlite3/select/components/from_set.sql.erb

@@ -0,0 +1,5 @@
+(
+  <%= queryset.left_operand.sql.select %>
+  <%= queryset.operation %>
+  <%= queryset.right_operand.sql.select %>
+) AS <%= queryset.model.table_name %>

data/test/config/db/schema.rb

@@ -0,0 +1,83 @@
+ActiveRecord::Schema.define do
+  self.verbose = false
+
+  create_table :geo_zones, force: true do |t|
+    t.string :name
+    t.text :description
+    t.integer :parent_zone_id
+    t.timestamps
+  end
+
+  create_table :group, force: true do |t|
+    t.string :name
+    t.string :description
+    t.timestamps
+  end
+
+  create_table :group_users, force: true do |t|
+    t.integer :group_id
+    t.integer :user_id
+    t.timestamps
+  end
+
+  create_table :users, force: true do |t|
+    t.integer :zone_id
+    t.string :first_name
+    t.string :last_name
+    t.text :biography
+    t.integer :age
+    t.string :email
+    t.timestamps
+  end
+
+  create_table :posts, force: true do |t|
+    t.string :title
+    t.text :content
+    t.integer :stars
+    t.integer :author_id
+    t.integer :category_id
+    t.timestamps
+  end
+
+  create_table :post_tags, force: true do |t|
+    t.integer :post_id
+    t.integer :tag_id
+    t.timestamps
+  end
+
+  create_table :tags, force: true do |t|
+    t.string :name
+    t.timestamps
+  end
+
+  create_table :categories, force: true do |t|
+    t.string :name
+    t.timestamps
+  end
+
+  # Post class only used to show what happens if a model
+  # has no inverse_of in one of its associations
+  create_table :bad_posts, force: true do |t|
+    t.string :title
+    t.text :content
+    t.integer :stars
+    t.integer :category_id
+    t.timestamps
+  end
+
+  # Tag class that will make use of a has_and_belongs_to_many relationship
+  # Used only for test the detection of has_and_belongs_to_many and the raise
+  # of an exception happens
+  create_table :bad_tags, force: true do |t|
+    t.string :name
+    t.integer :bad_post_id
+    t.timestamps
+  end
+
+  add_index :users, :email, unique: true
+  add_index :group_users, [:group_id, :user_id], unique: true
+  add_index :categories, :name, unique: true
+  add_index :post_tags, [:post_id, :tag_id], unique: true
+  add_index :posts, [:title, :author_id], unique: true
+  add_index :tags, :name, unique: true
+end

data/test/config/models/bad_post.rb

@@ -0,0 +1,5 @@
+
+class BadPost < ActiveRecord::Base
+  belongs_to :category
+  has_many :bad_tags
+end

data/test/config/models/bad_tag.rb

@@ -0,0 +1,5 @@
+
+class BadTag < ActiveRecord::Base
+  has_and_belongs_to_many :posts
+  belongs_to :bad_post
+end

data/test/config/models/category.rb

@@ -0,0 +1,4 @@
+
+class Category < ActiveRecord::Base
+  has_many :posts, inverse_of: :category
+end

data/test/config/models/geozone.rb

@@ -0,0 +1,6 @@
+
+class GeoZone < ActiveRecord::Base
+  has_many :users, foreign_key: 'zone_id', inverse_of: :zone
+  has_many :subzones, class_name: 'GeoZone', foreign_key: 'parent_zone_id', dependent: :destroy
+  belongs_to :parent_zone, class_name: 'GeoZone'
+end

data/test/config/models/group.rb

@@ -0,0 +1,5 @@
+
+class Group < ActiveRecord::Base
+  has_many :group_users, inverse_of: :group
+  has_many :users, through: :group_users, inverse_of: :groups
+end

data/test/config/models/group_user.rb

@@ -0,0 +1,5 @@
+
+class GroupUser < ActiveRecord::Base
+  belongs_to :group, inverse_of: :group_users
+  belongs_to :user, inverse_of: :group_users
+end

data/test/config/models/post.rb

@@ -0,0 +1,24 @@
+
+class Post < ActiveRecord::Base
+  belongs_to :author, foreign_key: 'author_id', class_name: 'User', inverse_of: :posts
+  belongs_to :category, inverse_of: :posts
+  has_many :post_tags
+  has_many :tags, through: :post_tags, inverse_of: :posts
+
+  def add_tag(tag)
+    begin
+      PostTag.create!(post: self, tag: tag)
+    rescue ActiveRecord::RecordNotUnique
+    end
+  end
+
+  def add_tag_by_name(tag_name)
+    begin
+      new_tag = Tag.create!(name: tag_name)
+    rescue ActiveRecord::RecordNotUnique
+      new_tag = Tag.find_by(name: tag_name)
+    end
+    add_tag(new_tag)
+  end
+
+end