simple-sql 0.2.0 → 0.2.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 35cf2798d086495d8716eb22b6ce08bea72a5ab1
-  data.tar.gz: 6e332f0a12d3442ee7a28e319cff5b8759a8affb
+  metadata.gz: 671eec226ce28823bcb0d2e749c3e11d7990ffca
+  data.tar.gz: f3447b03aa97ee19fd1e3fefd566ed24b77f2a85
 SHA512:
-  metadata.gz: 45f2f76f763f1587b4e1d330e00f3d24e87c8f7dca32a08abc9fed7f1076f5d87d42cc1dc06eeb20a2ac2a5c92d3a8312a31642edcb80f7940bfb46cc02d5bb9
-  data.tar.gz: d5efb732d0ebf9f8be40cf1dae1c3ba33782b4df0c92be284608fc74818b78b920177186da5fb5ef9ae6f704f11a49d2ae33cf8bd423df834b4a905bab694061
+  metadata.gz: 1cf66f360cb3d5cd721d6f978dcdc385e6fbfac3cf3aecd40083d8d5f9a9a1b849cf52f7884a29ece948ff4ca1164bf1ccabab97076ecbc789b6e45888bbefc4
+  data.tar.gz: d2dd45b2e4822fa591286030fd9bb874fd1a23fdc5ee93946c6859e64e4cf8413f4f880801baefdf86db96cf6b0a179221e1adb6b08f2f1be9d21f3afc8b6079

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    simple-sql (0.2.0)
+    simple-sql (0.2.1)
       pg (~> 0.20)
       pg_array_parser (~> 0)
 

data/lib/simple/sql.rb

@@ -1,17 +1,29 @@
 require_relative "sql/version.rb"
 require_relative "sql/decoder.rb"
 require_relative "sql/encoder.rb"
+require_relative "sql/config.rb"
+require_relative "sql/transactions.rb"
+require_relative "sql/logging.rb"
+
+require "logger"
 
 module Simple
   # The Simple::SQL module
   module SQL
     extend self
+    extend Transactions
+
+    attr_accessor :logger
+    self.logger = Logger.new(STDERR)
 
     # execute one or more sql statements. This method does not allow to pass in
     # arguments - since the pg client does not support this - but it allows to
     # run multiple sql statements separated by ";"
-    extend Forwardable
-    delegate exec: :pg
+    def exec(sql)
+      Logging.yield_logged sql do
+        connection.exec sql
+      end
+    end
 
     # Runs a query, with optional arguments, and returns the result. If the SQL
     # query returns rows with one column, this method returns an array of these
@@ -28,7 +40,7 @@ module Simple
     # end
 
     def all(sql, *args, &block)
-      result  = connection.exec_params(sql, Encoder.encode_args(args))
+      result  = exec_logged(sql, *args)
       decoder = Decoder.new(result)
 
       enumerate(result, decoder, block)
@@ -62,7 +74,7 @@ module Simple
     # end
 
     def records(sql, *args, into: Hash, &block)
-      result  = connection.exec_params(sql, Encoder.encode_args(args))
+      result  = exec_logged(sql, *args)
       decoder = Decoder.new(result, :record, into: into)
 
       enumerate(result, decoder, block)
@@ -78,6 +90,12 @@ module Simple
 
     private
 
+    def exec_logged(sql, *args)
+      Logging.yield_logged sql, *args do
+        connection.exec_params(sql, Encoder.encode_args(args))
+      end
+    end
+
     def enumerate(result, decoder, block)
       if block
         result.each_row do |row|
@@ -112,11 +130,8 @@ module Simple
       return ActiveRecord::Base.connection.raw_connection if defined?(ActiveRecord)
 
       STDERR.puts <<-SQL
-simple-sql works out of the box with ActiveRecord-based postgres connections.
-
-To use it without ActiveRecord you must connect to a database via
-
-    Simple::SQL.connect!("postgresql://username:password@dbhost:port/dbname").
+Simple::SQL works out of the box with ActiveRecord-based postgres connections, reusing the current connection.
+To use without ActiveRecord you must connect to a database via Simple::SQL.connect!.
 SQL
 
       raise ArgumentError, "simple-sql: missing connection"
@@ -124,32 +139,19 @@ SQL
 
     public
 
-    def connect!(url)
-      require "pg"
+    # connects to the database specified via the url parameter. If called
+    # without argument it tries to determine a DATABASE_URL from either the
+    # environment setting (DATABASE_URL) or from a config/database.yml file,
+    # taking into account the RAILS_ENV and RACK_ENV settings.
+    def connect!(database_url = :auto)
+      database_url = Config.determine_url if database_url == :auto
+
+      logger.info "Connecting to #{database_url}"
+      config = Config.parse_url(database_url)
 
-      config = db_config_from_url(url)
+      require "pg"
       connection = PG::Connection.new(config)
       self.connector = lambda { connection }
     end
-
-    def db_config_from_url(url)
-      require "uri"
-
-      raise ArgumentError, "Invalid URL #{url.inspect}" unless url.is_a?(String)
-      raise ArgumentError, "Invalid URL #{url.inspect}" unless url =~ /^postgres(ql)?s?:\/\//
-
-      uri = URI.parse(url)
-      raise ArgumentError, "Invalid URL #{url}" unless uri.hostname && uri.path
-
-      config = {
-        dbname: uri.path.sub(%r{^/}, ""),
-        host:   uri.hostname
-      }
-      config[:port] = uri.port if uri.port
-      config[:user] = uri.user if uri.user
-      config[:password] = uri.password if uri.password
-      config[:sslmode] = uri.scheme == "postgress" || uri.scheme == "postgresqls" ? "require" : "prefer"
-      config
-    end
   end
 end

data/lib/simple/sql/config.rb

@@ -0,0 +1,52 @@
+# private
+module Simple::SQL::Config
+  extend self
+
+  # parse a DATABASE_URL, return PG::Connection settings.
+  def parse_url(url)
+    require "uri"
+
+    raise ArgumentError, "Invalid URL #{url.inspect}" unless url.is_a?(String)
+    raise ArgumentError, "Invalid URL #{url.inspect}" unless url =~ /^postgres(ql)?s?:\/\//
+
+    uri = URI.parse(url)
+    raise ArgumentError, "Invalid URL #{url}" unless uri.hostname && uri.path
+
+    config = {
+      dbname: uri.path.sub(%r{^/}, ""),
+      host:   uri.hostname
+    }
+    config[:port] = uri.port if uri.port
+    config[:user] = uri.user if uri.user
+    config[:password] = uri.password if uri.password
+    config[:sslmode] = uri.scheme == "postgress" || uri.scheme == "postgresqls" ? "require" : "prefer"
+    config
+  end
+
+  # determines the database_url from either the DATABASE_URL environment setting
+  # or a config/database.yml file.
+  def determine_url
+    ENV["DATABASE_URL"] || database_url_from_database_yml
+  end
+
+  private
+
+  def database_url_from_database_yml
+    abc = read_database_yml
+    username, password, host, port, database, password = abc.values_at "username", "password", "host", "port", "database", "password"
+
+    username_and_password = [ username, password ].compact.join(":")
+    host_and_port = [ host, port ].compact.join(":")
+    "postgres://#{username_and_password}@#{host_and_port}/#{database}"
+  end
+
+  def read_database_yml
+    require "yaml"
+    database_config = YAML.load_file "config/database.yml"
+    env = ENV["RAILS_ENV"] || ENV["RACK_ENV"] || "development"
+
+    database_config[env] ||
+    database_config["defaults"] ||
+    raise("Invalid or missing database configuration in config/database.yml for #{env.inspect} environment")
+  end
+end

data/lib/simple/sql/logging.rb

@@ -0,0 +1,29 @@
+module Simple
+  module SQL
+    module Logging
+      extend self
+
+      def yield_logged(sql, *args, &block)
+        r0 = Time.now
+        rv = yield
+        realtime = Time.now - r0
+        ::Simple::SQL.logger.debug "[sql] %.3f secs: %s" % [ realtime, format_query(sql, *args) ]
+        rv
+      rescue => e
+        realtime = Time.now - r0
+        ::Simple::SQL.logger.warn "[sql] %.3f secs: %s:\n\tfailed with error %s" % [ realtime, format_query(sql, *args), e.message ]
+        raise
+      end
+
+      private
+
+      def format_query(sql, *args)
+        sql = sql.gsub(/\s*\n\s*/, " ").gsub(/(\A\s+)|(\s+\z)/, "")
+        return sql if args.empty?
+        args = args.map(&:inspect).join(", ")
+        sql + " w/args: #{args}"
+      end
+    end
+  end
+end
+

data/lib/simple/sql/transactions.rb

@@ -0,0 +1,44 @@
+# private
+module Simple::SQL::Transactions
+  SELF = self
+
+  def self.nesting_level
+    Thread.current[:nesting_level] ||= 0
+  end
+
+  def self.nesting_level=(nesting_level)
+    Thread.current[:nesting_level] = nesting_level
+  end
+
+  def transaction(&block)
+    # Notes: by using "ensure" (as opposed to rescue) we are rolling back 
+    # both when an exception was raised and when a value was thrown. This 
+    # also means we have to track whether or not to rollback. i.e. do roll
+    # back when we yielded to &block but not otherwise.
+    #
+    # Also the transaction support is a bit limited: you cannot rollback.
+    # Rolling back from inside a nested transaction would require SAVEPOINT
+    # support; without the code is simpler at least :)
+    if SELF.nesting_level == 0
+      transaction_started = true
+      ask "BEGIN"
+    end
+
+    SELF.nesting_level += 1
+
+    return_value = yield
+
+    # Only commit if we started a transaction here.
+    if transaction_started
+      ask "COMMIT"
+      transaction_committed = true
+    end
+
+    return_value
+  ensure
+    SELF.nesting_level -= 1
+    if transaction_started && !transaction_committed
+      ask "ROLLBACK"
+    end
+  end
+end

data/lib/simple/sql/version.rb

@@ -1,5 +1,5 @@
 module Simple
   module SQL
-    VERSION = "0.2.0"
+    VERSION = "0.2.1"
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: simple-sql
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.2.1
 platform: ruby
 authors:
 - radiospiel
@@ -166,8 +166,11 @@ files:
 - bin/rake
 - config/database.yml
 - lib/simple/sql.rb
+- lib/simple/sql/config.rb
 - lib/simple/sql/decoder.rb
 - lib/simple/sql/encoder.rb
+- lib/simple/sql/logging.rb
+- lib/simple/sql/transactions.rb
 - lib/simple/sql/version.rb
 - log/.gitkeep
 - simple-sql.gemspec