sql_wrangler 0.0.1

data/README

@@ -0,0 +1 @@
+Makes it easier to deal with SQL queries and handle their results.

data/lib/sql_wrangler.rb

@@ -0,0 +1,149 @@
+require 'sqlite3'
+
+module SqlWrangler
+  
+  class SqlConnection
+    
+    def query(sql_string)
+      Query.new self, sql_string
+    end
+    
+  end
+  
+  class SqLiteConnection < SqlConnection
+    
+    def initialize(db_path)
+      @db = SQLite3::Database.new db_path
+    end
+    
+    def execute_sql(sql_string)
+      @db.execute2(sql_string)
+    end
+
+    def command(sql_string)
+      @db.execute(sql_string)
+    end
+
+    def close
+      @db.close
+    end
+    
+  end
+  
+  class Query
+    
+    attr_reader :sql_string
+    attr_reader :groupings
+    attr_reader :conn
+    
+    def initialize(conn, sql_string)
+      @conn = conn
+      @sql_string = sql_string
+      @groupings = []
+    end
+    
+    def execute
+      raw_result = @conn.execute_sql(@sql_string)
+      init_groups_for_execution raw_result[0]
+      return format_query_result(raw_result)
+    end
+    
+    def format_query_result(raw_result)
+      formatted_result = []
+      columns_by_index = get_columns_by_index raw_result[0]
+      
+      raw_result[1,raw_result.length-1].each do |raw_row|
+        merge_row raw_row, @groupings, formatted_result, columns_by_index
+      end
+      
+      return formatted_result
+    end
+    
+    def get_columns_by_index columns
+      columns_by_index = {}
+      (0..columns.length-1).each { |i| columns_by_index[i] = columns[i] }
+      return columns_by_index
+    end
+    
+    def init_groups_for_execution columns
+      used_indexes = []
+      @groupings.each do |group|
+        group.group_indexes = []
+        group.content_indexes = []
+        (0..(columns.length-1)).each do |i|
+          if group.columns.any? { |c| c == columns[i] }
+            used_indexes << i
+            group.group_indexes << i
+          elsif not used_indexes.any? { |used_index| used_index == i }
+            group.content_indexes << i
+          end
+        end
+      end
+    end
+    
+    def merge_row(row, groups, grouped_data, columns_by_index)
+      
+      if not @groupings.any?
+        flat_row = {}
+        columns_by_index.each { |index, column| flat_row[column] = row[index] }
+        grouped_data << flat_row
+      elsif groups.any?
+        this_group = groups[0]
+        remaining_groups = groups[1, groups.length-1]
+        grouped_vals = {}
+        this_group.group_indexes.each { |index| grouped_vals[columns_by_index[index]] = row[index] }
+
+        if grouped_vals.values.any? { |value| value != nil }
+          grouped_row = get_existing_grouped_row grouped_vals, grouped_data
+
+          if grouped_row == nil
+            grouped_row = grouped_vals
+            grouped_row[this_group.name] = [] if this_group != nil
+            grouped_data << grouped_row
+          end
+
+          merge_row(row, remaining_groups, grouped_row[this_group.name], columns_by_index)
+        end
+
+      else
+        leaf_data = {}
+        @groupings.last.content_indexes.each { |i| leaf_data[columns_by_index[i]] = row[i] }
+        grouped_data << leaf_data if leaf_data.values.any? { |value| value != nil }
+      end
+
+    end
+    
+    def get_existing_grouped_row grouped_vals, grouped_data
+      grouped_data.each do |grouped_row|
+        if not grouped_vals.keys.any? { |key| grouped_vals[key] != grouped_row[key] }
+          return grouped_row
+        end
+      end
+      return nil
+    end
+    
+    def group(name, columns)
+      new_grouping = QueryGrouping.new(name, columns)
+      new_grouping.level = @groupings.length
+      @groupings << new_grouping
+      return self
+    end
+    
+  end
+  
+  class QueryGrouping
+    
+    attr_reader :name
+    attr_reader :columns
+    attr_accessor :content_indexes
+    attr_accessor :group_indexes
+    attr_accessor :level
+    
+    def initialize(name, columns)
+      @name = name
+      @columns = columns
+    end
+    
+  end
+  
+end

data/test/sql_wrangler_tests.rb

@@ -0,0 +1,168 @@
+require 'fas_test'
+require './lib/sql_wrangler'
+
+class SqLiteConnectionTests < FasTest::TestClass
+  
+  def class_setup
+    @conn = SqlWrangler::SqLiteConnection.new ":memory:"
+  end
+  
+  def class_teardown
+    @conn.close
+  end
+  
+  def test__command
+    begin
+      @conn.command("CREATE TABLE users (id int PRIMARY KEY, username VARCHAR(100), password VARCHAR(100))")
+      @conn.command("INSERT INTO users VALUES (1, 'username1', 'password1')")
+      result = @conn.execute_sql("SELECT * FROM users")
+      assert_equal(2, result.length)
+    ensure
+      @conn.command("DROP TABLE users")
+    end
+  end
+  
+  def test__query__without_executing_it
+    query = @conn.query("SELECT * FROM users")
+    assert_equal("SELECT * FROM users", query.sql_string)
+  end
+  
+end
+
+class QueryTests < FasTest::TestClass
+  
+  def class_setup
+    @conn = SqlWrangler::SqLiteConnection.new ":memory:"
+    @conn.execute_sql("CREATE TABLE users (username VARCHAR(100), password VARCHAR(100))")
+    @conn.execute_sql("CREATE TABLE groups (group_name VARCHAR(100))")
+    @conn.execute_sql("CREATE TABLE users_groups (username VARCHAR(100), group_name VARCHAR(100))")
+    
+    @conn.execute_sql("create table articles (id int primary key, title varchar(100), content varchar(100), author varchar(100))")
+    @conn.execute_sql("create table comments (id int primary key, content text, article_id int)")
+  end
+  
+  def test_setup
+    @conn.execute_sql("INSERT INTO users VALUES ('username1', 'password1');")
+    @conn.execute_sql("INSERT INTO users VALUES ('username2', 'password2');")
+    @conn.execute_sql("INSERT INTO groups VALUES ('group one')")
+    @conn.execute_sql("INSERT INTO groups VALUES ('group two')")
+    @conn.execute_sql("INSERT INTO users_groups VALUES ('username1', 'group one')")
+    @conn.execute_sql("INSERT INTO users_groups VALUES ('username1', 'group two')")
+    @conn.execute_sql("INSERT INTO users_groups VALUES ('username2', 'group one')")
+    
+    @conn.execute_sql("insert into articles values (1, 'article1', 'content1', 'username1')")
+    @conn.execute_sql("insert into comments values (1, 'comment on article1 #1', 1)")
+    @conn.execute_sql("insert into comments values (2, 'comment on article1 #2', 1)")
+  end
+
+  def test_teardown
+    @conn.execute_sql("delete from users")
+    @conn.execute_sql("delete from groups")
+    @conn.execute_sql("delete from users_groups")
+    @conn.execute_sql("delete from articles")
+    @conn.execute_sql("delete from comments")
+  end
+  
+  def class_teardown
+    @conn.close
+  end
+  
+  def test__execute__has_correct_values_on_simple_query
+    result = @conn.query("SELECT * FROM users").execute
+    assert_equal(2, result.length)
+    assert_equal("username1", result[0]['username'])
+    assert_equal("password1", result[0]['password'])
+    assert_equal("username2", result[1]['username'])
+    assert_equal("password2", result[1]['password'])
+  end
+  
+  def test__execute__has_correct_columns_on_simple_query
+    first = @conn.query("SELECT * FROM users").execute[0]
+    assert_true(first.keys.any? { |m| m == 'username' })
+    assert_true(first.keys.any? { |m| m == 'password' })
+  end
+  
+  def test__execute__works_with_a_more_complex_query
+    result = @conn.query("
+      select u.username, g.group_name 
+      from groups g
+      inner join users_groups ug on ug.group_name = g.group_name
+      inner join users u on u.username = ug.username
+      order by u.username, g.group_name").execute
+    assert_equal(3, result.length)
+    assert_equal("username1", result[0]["username"])
+    assert_equal("group one", result[0]["group_name"])
+    assert_equal("username1", result[1]["username"])
+    assert_equal("group two", result[1]["group_name"])
+    assert_equal("username2", result[2]["username"])
+    assert_equal("group one", result[2]["group_name"])
+  end
+  
+  def test__execute__works_with_a_simple_grouping
+    result = @conn.query("
+      select u.username, g.group_name 
+      from groups g
+      inner join users_groups ug on ug.group_name = g.group_name
+      inner join users u on u.username = ug.username
+      order by u.username, g.group_name").group("users", ["group_name"]).execute
+    assert_equal(2, result.length)
+    assert_equal("group one", result[0]["group_name"])
+    assert_equal(2, result[0]["users"].length)
+    assert_equal("username1", result[0]["users"][0]["username"])
+    assert_equal("username2", result[0]["users"][1]["username"])
+    assert_equal("group two", result[1]["group_name"])
+    assert_equal(1, result[1]["users"].length)
+    assert_equal("username1", result[1]["users"][0]["username"])
+  end
+  
+  def test__group__modifies_query_object_correctly_with_single_grouping
+    query = @conn.query("
+      select u.username, g.group_name 
+      from groups g
+      inner join users_groups ug on ug.group_name = g.group_name
+      inner join users u on u.username = ug.username
+      order by u.username, g.group_name").group("users", ["group_name"])
+    assert_equal(1, query.groupings.count)
+    assert_equal("users", query.groupings[0].name)
+    assert_equal(1, query.groupings[0].columns.length)
+    assert_equal("group_name", query.groupings[0].columns[0])
+  end
+  
+  def test__execute__works_with_multi_level_grouping
+    result = @conn.query("
+      select u.username, g.group_name, a.title, a.content article_content, c.id comment_id, c.content comment_content
+      from groups g
+      join users_groups ug on ug.group_name = g.group_name
+      join users u on u.username = ug.username
+      left join articles a on a.author = u.username
+      left join comments c on c.article_id = a.id
+      order by g.group_name, u.username, a.title, c.content") \
+      .group("users", ["group_name"]) \
+      .group("articles", ["username"]) \
+      .group("comments", ["article_content", "title"]) \
+      .execute
+      
+    assert_equal(2, result.length)
+    assert_equal("group one", result[0]["group_name"])
+    assert_equal(2, result[0]["users"].length)
+    assert_equal("username1", result[0]["users"][0]["username"])
+    
+    assert_equal(1, result[0]["users"][0]["articles"].length)
+    assert_equal("article1", result[0]["users"][0]["articles"][0]["title"])
+    assert_equal("content1", result[0]["users"][0]["articles"][0]["article_content"])
+    
+    assert_equal(2, result[0]["users"][0]["articles"][0]["comments"].length)
+    assert_equal(1, result[0]["users"][0]["articles"][0]["comments"][0]["comment_id"])
+    assert_equal("comment on article1 #1", result[0]["users"][0]["articles"][0]["comments"][0]["comment_content"])
+    assert_equal(2, result[0]["users"][0]["articles"][0]["comments"][1]["comment_id"])
+    assert_equal("comment on article1 #2", result[0]["users"][0]["articles"][0]["comments"][1]["comment_content"])
+    assert_equal("username2", result[0]["users"][1]["username"])
+    assert_equal(0, result[0]["users"][1]["articles"].length)
+    
+    assert_equal("group two", result[1]["group_name"])
+    assert_equal(1, result[1]["users"].length)
+    assert_equal("username1", result[1]["users"][0]["username"])
+    assert_equal(1, result[1]["users"][0]["articles"].length)
+  end
+  
+end

metadata

@@ -0,0 +1,58 @@
+--- !ruby/object:Gem::Specification 
+name: sql_wrangler
+version: !ruby/object:Gem::Version 
+  prerelease: 
+  version: 0.0.1
+platform: ruby
+authors: 
+- Graeme Hill
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-02-28 00:00:00 -08:00
+default_executable: 
+dependencies: []
+
+description: Makes it easier to deal with SQL queries and handle their results.
+email: graemekh@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- README
+files: 
+- README
+- lib/sql_wrangler.rb
+- test/sql_wrangler_tests.rb
+has_rdoc: true
+homepage: https://github.com/graeme-hill/sql_wrangler
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.5.2
+signing_key: 
+specification_version: 3
+summary: A simple ORM alternative that makes it easier to deal with SQL queries in ruby.
+test_files: 
+- test/sql_wrangler_tests.rb