fluiddb 0.0.2 → 0.0.3

data/lib/FluidDb.rb

@@ -1,57 +1,61 @@
 require 'date'
 
-class FluidDb_ConnectionError<StandardError
-end
-class FluidDb_NoDataFoundError<StandardError
-end
-class FluidDb_TooManyRowsError<StandardError
-end
-class FluidDb_ParamTypeNotSupportedError<StandardError
-end
-
-class FluidDb
+module FluidDb
     
-    @connection;
+    class ConnectionError<StandardError
+    end
+    class NoDataFoundError<StandardError
+    end
+    class TooManyRowsError<StandardError
+    end
+    class ParamTypeNotSupportedError<StandardError
+    end
     
-    def format_to_sql( sql, params=nil )
-        if params.nil? then
+    class Base
+        
+        @connection;
+
+        def format_to_sql( sql, params=nil )
+            if params.nil? then
+                return sql
+            end
+            #timestamp.strftime( "%Y-%m-%d %H:%M:%S" )
+            params.each do |v|
+                if v.kind_of? String then
+                    v = "'" + v.sub( "'", "\'" ) + "'"
+                    sql = sql.sub( "?", v )
+                    elsif v.is_a? DateTime then
+                    s = "'" + v.strftime( "%Y-%m-%d %H:%M:%S" ) + "'"
+                    sql = sql.sub( "?", s )
+                    elsif v.kind_of? Date then
+                    v = "'" + v.to_s + "'"
+                    sql = sql.sub( "?", v.to_s )
+                    elsif v.is_a?(Numeric) then
+                    sql = sql.sub( "?", v.to_s )
+                    else
+                    raise FluidDb_ParamTypeNotSupportedError.new
+                end
+            end
+            
             return sql
         end
         
-        params.each do |v|
-            if v.kind_of? String then
-                v = "'" + v.sub( "'", "\'" ) + "'"
-                sql = sql.sub( "?", v )
-                elsif v.kind_of? Date then
-                v = "'" + v.to_s + "'"
-                sql = sql.sub( "?", v.to_s )
-                elsif v.kind_of? DateTime then
-                v = "'" + v.to_s + "'"
-                sql = sql.sub( "?", v.to_s )
-                elsif v.is_a?(Numeric) then
-                sql = sql.sub( "?", v.to_s )
-                else
-                raise FluidDb_ParamTypeNotSupportedError.new
-            end
+        def queryForArray( sql, params )
+            raise NotImplementedError.new("You must implement 'queryForArray'.")
+        end
+        
+        def queryForValue( sql, params )
+            raise NotImplementedError.new("You must implement 'queryForValue'.")
+        end
+        
+        def queryForResultset( sql, params )
+            raise NotImplementedError.new("You must implement 'queryForResultset'.")
+        end
+        
+        def execute( sql, params, expected_affected_rows )
+            raise NotImplementedError.new("You must implement 'execute'.")
         end
         
-        return sql
-    end
-    
-    def queryForArray( sql, params )
-        raise NotImplementedError.new("You must implement 'queryForArray'.")
-    end
-    
-    def queryForValue( sql, params )
-        raise NotImplementedError.new("You must implement 'queryForValue'.")
-    end
-    
-    def queryForResultset( sql, params )
-        raise NotImplementedError.new("You must implement 'queryForResultset'.")
-    end
-    
-    def execute( sql, params, expected_affected_rows )
-        raise NotImplementedError.new("You must implement 'execute'.")
     end
     
 end

data/lib/FluidDb/Mysql.rb

@@ -1,101 +1,104 @@
 require "FluidDb"
 require "mysql2"
 
-class FluidDb_Mysql<FluidDb
-    
-    def initialize(uri)
-        host = uri.host
-        database = uri.path.sub( "/", "" )
-        
-        @connection = Mysql2::Client.new(:host => uri.host,
-                                         :database => uri.path.sub( "/", "" ),
-                                         :username => uri.user )
-    end
+module FluidDb
 
-	def queryForArray( sql, params )
-        sql = self.format_to_sql( sql, params )
-        results = @connection.query(sql)
+    class Mysql<Base
         
-        #        if ( $result === false ) then
-        #    $message = pg_last_error( $this->connection );
-        #    throw new Fluid_ConnectionException( $message );
-        #end
+        def initialize(uri)
+            host = uri.host
+            database = uri.path.sub( "/", "" )
+            
+            @connection = Mysql2::Client.new(:host => uri.host,
+                                             :database => uri.path.sub( "/", "" ),
+                                             :username => uri.user )
+        end
         
-        results.count == 0
-        case results.count
-            when -1
-            raise FluidDb_ConnectionError.new
-            when 0
-            raise FluidDb_NoDataFoundError.new
-            when 1
-            r=nil;
-            results.each do |row|
-                r=row
+        def queryForArray( sql, params )
+            sql = self.format_to_sql( sql, params )
+            results = @connection.query(sql)
+            
+            #        if ( $result === false ) then
+            #    $message = pg_last_error( $this->connection );
+            #    throw new Fluid_ConnectionException( $message );
+            #end
+            
+            results.count == 0
+            case results.count
+                when -1
+                raise FluidDb::ConnectionError.new
+                when 0
+                raise FluidDb::NoDataFoundError.new
+                when 1
+                r=nil;
+                results.each do |row|
+                    r=row
+                end
+                return r
+                else
+                raise FluidDb::TooManyRowsError.new
             end
-            return r
-            else
-            raise FluidDb_TooManyRowsError.new
+            
         end
         
-    end
-    
-    def queryForValue( sql, params )
-        sql = self.format_to_sql( sql, params )
-        results = @connection.query(sql, :as => :array)
+        def queryForValue( sql, params )
+            sql = self.format_to_sql( sql, params )
+            results = @connection.query(sql, :as => :array)
+
+            #        if ( $result === false ) then
+            #    $message = pg_last_error( $this->connection );
+            #    throw new Fluid_ConnectionException( $message );
+            #end
+            
+            results.count == 0
+            case results.count
+                when -1
+                raise FluidDb::ConnectionError.new
+                when 0
+                raise FluidDb::NoDataFoundError.new
+                when 1
+                r=nil;
+                results.each do |row|
+                    r=row
+                end
+                return r[0]
+                else
+                raise FluidDb::TooManyRowsError.new
+            end
+            
+        end
         
-        #        if ( $result === false ) then
-        #    $message = pg_last_error( $this->connection );
-        #    throw new Fluid_ConnectionException( $message );
-        #end
         
-        results.count == 0
-        case results.count
-            when -1
-            raise FluidDb_ConnectionError.new
-            when 0
-            raise FluidDb_NoDataFoundError.new
-            when 1
-            r=nil;
-            results.each do |row|
-                r=row
+        def queryForResultset( sql, params )
+            sql = self.format_to_sql( sql, params )
+            results = @connection.query(sql)
+            
+            #        if ( $result === false ) then
+            #    $message = pg_last_error( $this->connection );
+            #    throw new Fluid_ConnectionException( $message );
+            #end
+            
+            results.count == 0
+            case results.count
+                when -1
+                raise FluidDb::ConnectionError.new
+                else
+                return results
             end
-            return r[0]
-            else
-            raise FluidDb_TooManyRowsError.new
         end
         
-    end
-    
-    
-    def queryForResultset( sql, params )
-        sql = self.format_to_sql( sql, params )
-        results = @connection.query(sql)
         
-        #        if ( $result === false ) then
-        #    $message = pg_last_error( $this->connection );
-        #    throw new Fluid_ConnectionException( $message );
-        #end
+        #    def execute( sql, params, expected_affected_rows )
+        def execute( sql, params )
+            sql = self.format_to_sql( sql, params )
+            @connection.query( sql );
+        end
         
-        results.count == 0
-        case results.count
-            when -1
-            raise FluidDb_ConnectionError.new
-            else
-            return results
+        def insert( sql, params )
+            self.execute( sql, params )
+            return @connection.last_id
         end
+        
     end
     
-    
-    #    def execute( sql, params, expected_affected_rows )
-    def execute( sql, params )
-        sql = self.format_to_sql( sql, params )
-        @connection.query( sql );
-    end
-
-    def insert( sql, params )
-        self.execute( sql, params )
-        return @connection.last_id
-    end
-
-    
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: fluiddb
 version: !ruby/object:Gem::Version
-  version: 0.0.2
+  version: 0.0.3
   prerelease: 
 platform: ruby
 authors: