sql_wrangler 0.0.3 → 1.0.0

data/lib/sql_wrangler.rb

@@ -1,70 +1,72 @@
 require 'sqlite3'
 
 module SqlWrangler
-  
+
   class SqlConnection
-    
-    def query(sql_string)
-      Query.new self, sql_string
+
+    def query(sql_string, params={})
+      Query.new(self, sql_string, params)
     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)
+
+    def execute_sql(sql_string, params={})
+      @db.execute2(sql_string, params)
     end
 
     def command(sql_string)
-      @db.execute(sql_string)
+      @db.execute_batch(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)
+    attr_accessor :params
+
+    def initialize(conn, sql_string, params={})
       @conn = conn
       @sql_string = sql_string
       @groupings = []
+      @params = params
     end
-    
+
     def execute
-      raw_result = @conn.execute_sql(@sql_string)
+      raw_result = @conn.execute_sql(@sql_string, @params)
       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|
@@ -80,9 +82,9 @@ module SqlWrangler
         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] }
@@ -112,7 +114,7 @@ module SqlWrangler
       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] }
@@ -121,29 +123,29 @@ module SqlWrangler
       end
       return nil
     end
-    
+
     def group_by columns, options = {}
       new_grouping = QueryGrouping.new(options[:into], 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
+
+end

data/test/sql_wrangler_tests.rb

@@ -2,15 +2,15 @@ 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))")
@@ -21,26 +21,26 @@ class SqLiteConnectionTests < FasTest::TestClass
       @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');")
@@ -49,7 +49,7 @@ class QueryTests < FasTest::TestClass
     @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)")
@@ -62,11 +62,11 @@ class QueryTests < FasTest::TestClass
     @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)
@@ -75,16 +75,39 @@ class QueryTests < FasTest::TestClass
     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_param_setter
+    query = @conn.query("select password from users where username=:username")
+    query.params = {:username => 'username1'}
+    result = query.execute
+    assert_equal(1, result.length)
+    assert_equal('password1', result[0]['password'])
+  end
+
+  def test__execute__works_with_params_in_ctor
+    query = @conn.query("select password from users where username=:username", :username => 'username1')
+    result = query.execute
+    assert_equal(1, result.length)
+    assert_equal('password1', result[0]['password'])
+  end
+
+  def test__execute__works_with_param_modification
+    query = @conn.query("select password from users where username=:username")
+    query.params[:username] = 'username1'
+    result = query.execute
+    assert_equal(1, result.length)
+    assert_equal('password1', result[0]['password'])
+  end
+
   def test__execute__works_with_a_more_complex_query
     result = @conn.query("
-      select u.username, g.group_name 
+      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
@@ -97,10 +120,10 @@ class QueryTests < FasTest::TestClass
     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 
+      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
@@ -114,10 +137,10 @@ class QueryTests < FasTest::TestClass
     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 
+      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
@@ -127,7 +150,7 @@ class QueryTests < FasTest::TestClass
     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
@@ -141,16 +164,16 @@ class QueryTests < FasTest::TestClass
       .group_by(["username"], :into => "articles") \
       .group_by(["article_content", "title"], :into => "comments") \
       .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"])
@@ -158,11 +181,11 @@ class QueryTests < FasTest::TestClass
     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
+
+end

metadata

@@ -1,8 +1,12 @@
 --- !ruby/object:Gem::Specification 
 name: sql_wrangler
 version: !ruby/object:Gem::Version 
-  prerelease: 
-  version: 0.0.3
+  prerelease: false
+  segments: 
+  - 1
+  - 0
+  - 0
+  version: 1.0.0
 platform: ruby
 authors: 
 - Graeme Hill
@@ -10,7 +14,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-03-01 00:00:00 -08:00
+date: 2011-10-15 00:00:00 -07:00
 default_executable: 
 dependencies: []
 
@@ -38,21 +42,23 @@ rdoc_options: []
 require_paths: 
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement 
-  none: false
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
+      segments: 
+      - 0
       version: "0"
 required_rubygems_version: !ruby/object:Gem::Requirement 
-  none: false
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
+      segments: 
+      - 0
       version: "0"
 requirements: []
 
 rubyforge_project: 
-rubygems_version: 1.5.2
+rubygems_version: 1.3.6
 signing_key: 
 specification_version: 3
 summary: A simple ORM alternative that makes it easier to deal with SQL queries in ruby.