sqlite3_extend_function 0.2.0 → 0.3.0

data/lib/sqlite3_extend_function/functions/exp.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module SQLite3ExtendFunction
+  module Functions
+    # SQLite3ExtendFunction::Functions::Exp
+    module Exp
+      class << self
+        # @param [Integer, Float] dp
+        # @return [Integer, Float]
+        # @raise [SQLite3::SQLException]
+        def call(dp)
+          return if dp.nil?
+
+          result = Math.exp(Float(dp))
+          result.to_i == result ? result.to_i : result
+        rescue ArgumentError
+          raise SQLite3::SQLException, "invalid input syntax for type double precision: \"#{dp}\""
+        end
+      end
+    end
+  end
+end

data/lib/sqlite3_extend_function/functions/floor.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module SQLite3ExtendFunction
+  module Functions
+    # SQLite3ExtendFunction::Functions::Floor
+    module Floor
+      class << self
+        # @param [Integer, Float] dp
+        # @return [Integer]
+        # @raise [SQLite3::SQLException]
+        def call(dp)
+          Float(dp).floor.to_i unless dp.nil?
+        rescue ArgumentError
+          raise SQLite3::SQLException, "invalid input syntax for type double precision: \"#{dp}\""
+        end
+      end
+    end
+  end
+end

data/lib/sqlite3_extend_function/functions/format.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module SQLite3ExtendFunction
+  module Functions
+    # SQLite3ExtendFunction::Functions::Format
+    module Format
+      class << self
+        # @param [String] formartstr
+        # @param [Array<Object>] args
+        # @return [String]
+        def call(formartstr, *args)
+          formartstr % args
+        end
+      end
+    end
+  end
+end

data/lib/sqlite3_extend_function/functions/initcap.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module SQLite3ExtendFunction
+  module Functions
+    # SQLite3ExtendFunction::Functions::Initcap
+    module Initcap
+      class << self
+        # @param [String] str
+        # @return [String]
+        # @raise [SQLite3::SQLException]
+        def call(str)
+          return if str.nil?
+
+          str.split(/([a-zA-Z0-9]*|[^a-zA-Z0-9]*)/).map.with_index do |s, i|
+            i.odd? ? s.downcase.capitalize : s
+          end.join
+        rescue StandardError
+          raise SQLite3::SQLException, 'No function matches the given name and argument types. ' \
+            'You might need to add explicit type casts.'
+        end
+      end
+    end
+  end
+end

data/lib/sqlite3_extend_function/functions/ln.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module SQLite3ExtendFunction
+  module Functions
+    # SQLite3ExtendFunction::Functions::Ln
+    module Ln
+      class << self
+        # @param [Integer, Float] dp
+        # @return [Integer, Float]
+        # @raise [SQLite3::SQLException]
+        def call(dp)
+          return if dp.nil?
+
+          result = Math.log(Float(dp))
+          result.to_i == result ? result.to_i : result
+        rescue ArgumentError
+          raise SQLite3::SQLException, 'cannot take logarithm of a negative number'
+        end
+      end
+    end
+  end
+end

data/lib/sqlite3_extend_function/functions/log.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module SQLite3ExtendFunction
+  module Functions
+    # SQLite3ExtendFunction::Functions::Log
+    module Log
+      class << self
+        # @param [Integer, Float] y
+        # @param [Integer, Float, NilClass] x
+        # @return [Integer, Float]
+        # @raise [SQLite3::SQLException]
+        def call(y, x = nil)
+          return if y.nil?
+          return Math.log(x, y) unless x.nil?
+
+          result = Math.log10(Float(y))
+          result.to_i == result ? result.to_i : result
+        rescue ArgumentError
+          raise SQLite3::SQLException, 'invalid input syntax for type numeric'
+        end
+      end
+    end
+  end
+end

data/lib/sqlite3_extend_function/functions/md5.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module SQLite3ExtendFunction
+  module Functions
+    # SQLite3ExtendFunction::Functions::Md5
+    module Md5
+      class << self
+        # @param [String] str
+        # @return [String]
+        # @raise [SQLite3::SQLException]
+        def call(str)
+          Digest::MD5.hexdigest(str) unless str.nil?
+        rescue StandardError
+          raise SQLite3::SQLException, 'No function matches the given name and argument types. ' \
+            'You might need to add explicit type casts.'
+        end
+      end
+    end
+  end
+end

data/lib/sqlite3_extend_function/functions/mod.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module SQLite3ExtendFunction
+  module Functions
+    # SQLite3ExtendFunction::Functions::Mod
+    module Mod
+      class << self
+        # @param [Integer, Float] y
+        # @param [Integer, Float] x
+        # @return [Integer]
+        # @raise [SQLite3::SQLException]
+        def call(y, x = nil)
+          Float(y).modulo(Float(x)).to_i
+        rescue ArgumentError
+          raise SQLite3::SQLException,
+                'Could not choose a best candidate function. You might need to add explicit type casts.'
+        end
+      end
+    end
+  end
+end

data/lib/sqlite3_extend_function/functions/now.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module SQLite3ExtendFunction
+  module Functions
+    # SQLite3ExtendFunction::Functions::Now
+    module Now
+      class << self
+        # @return [String]
+        def call
+          Time.now.strftime('%Y-%m-%d %H:%M:%S.%6N%:z')
+        end
+      end
+    end
+  end
+end

data/lib/sqlite3_extend_function/functions/octet_length.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module SQLite3ExtendFunction
+  module Functions
+    # SQLite3ExtendFunction::Functions::OctetLength
+    module OctetLength
+      class << self
+        # @param [String] str
+        # @return [Integer]
+        # @raise [SQLite3::SQLException]
+        def call(str)
+          str.bytesize
+        rescue ArgumentError
+          raise SQLite3::SQLException, 'No function matches the given name and argument types. ' \
+            'You might need to add explicit type casts.'
+        end
+      end
+    end
+  end
+end

data/lib/sqlite3_extend_function/functions/pi.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module SQLite3ExtendFunction
+  module Functions
+    # SQLite3ExtendFunction::Functions::Pi
+    module Pi
+      class << self
+        # @return [Float]
+        def call
+          Math::PI
+        end
+      end
+    end
+  end
+end

data/lib/sqlite3_extend_function/functions/power.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module SQLite3ExtendFunction
+  module Functions
+    # SQLite3ExtendFunction::Functions::Power
+    module Power
+      class << self
+        # @param [Integer, Float] a
+        # @param [Integer, Float] b
+        # @return [Integer, Float]
+        # @raise [SQLite3::SQLException]
+        def call(a, b)
+          return if a.nil? || b.nil?
+
+          result = Float(a)**Float(b)
+          result.to_i == result ? result.to_i : result
+        rescue ArgumentError
+          raise SQLite3::SQLException, 'invalid input syntax for type double precision'
+        end
+      end
+    end
+  end
+end

data/lib/sqlite3_extend_function/functions/radians.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module SQLite3ExtendFunction
+  module Functions
+    # SQLite3ExtendFunction::Functions::Radians
+    module Radians
+      class << self
+        # @param [Integer, Float] dp
+        # @return [Integer, Float]
+        # @raise [SQLite3::SQLException]
+        def call(dp)
+          return if dp.nil?
+
+          result = Float(dp) * Math::PI / 180
+          result.to_i == result ? result.to_i : result
+        rescue ArgumentError
+          raise SQLite3::SQLException, "invalid input syntax for type double precision: \"#{dp}\""
+        end
+      end
+    end
+  end
+end

data/lib/sqlite3_extend_function/functions/sign.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module SQLite3ExtendFunction
+  module Functions
+    # SQLite3ExtendFunction::Functions::Sign
+    module Sign
+      class << self
+        # @param [Integer, Float] dp
+        # @return [Integer]
+        # @raise [SQLite3::SQLException]
+        def call(dp)
+          return if dp.nil?
+
+          value = Float(dp)
+          (value.zero? && 0) || (value.positive? && 1) || -1
+        rescue ArgumentError
+          raise SQLite3::SQLException, "invalid input syntax for type double precision: \"#{dp}\""
+        end
+      end
+    end
+  end
+end

data/lib/sqlite3_extend_function/functions/sin.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module SQLite3ExtendFunction
+  module Functions
+    # SQLite3ExtendFunction::Functions::Sin
+    module Sin
+      class << self
+        # @param [Integer, Float] x
+        # @return [Float]
+        # @raise [SQLite3::SQLException]
+        def call(x)
+          Math.sin(Float(x))
+        rescue ArgumentError
+          raise SQLite3::SQLException, "invalid input syntax for type double precision: #{x}"
+        end
+      end
+    end
+  end
+end

data/lib/sqlite3_extend_function/functions/sqrt.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module SQLite3ExtendFunction
+  module Functions
+    # SQLite3ExtendFunction::Functions::Sqrt
+    module Sqrt
+      class << self
+        # @param [Integer, Float] dp
+        # @return [Integer, Float]
+        # @raise [SQLite3::SQLException]
+        def call(dp)
+          return if dp.nil?
+
+          result = Math.sqrt(Float(dp))
+          result.to_i == result ? result.to_i : result
+        rescue ArgumentError
+          raise SQLite3::SQLException, "invalid input syntax for type double precision: \"#{dp}\""
+        end
+      end
+    end
+  end
+end

data/lib/sqlite3_extend_function/functions/tan.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module SQLite3ExtendFunction
+  module Functions
+    # SQLite3ExtendFunction::Functions::Tan
+    module Tan
+      class << self
+        # @param [Float, Integer] x
+        # @return [Float]
+        # @raise [SQLite3::SQLException]
+        def call(x)
+          Math.tan(Float(x))
+        rescue ArgumentError
+          raise SQLite3::SQLException, "invalid input syntax for type double precision: #{x}"
+        end
+      end
+    end
+  end
+end

data/lib/sqlite3_extend_function/functions/trunc.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module SQLite3ExtendFunction
+  module Functions
+    # SQLite3ExtendFunction::Functions::Trunc
+    module Trunc
+      class << self
+        # @param [Integer, Float] v
+        # @param [Integer] s
+        # @return [Integer, Float]
+        # @raise [SQLite3::SQLException]
+        def call(v, s = 0)
+          return if v.nil?
+          raise ArgumentError if s.is_a?(Integer)
+
+          dec = BigDecimal(s.zero? ? '1.0' : (1.0 / (10**s)).to_s)
+          result = (v / dec).to_i * dec
+          result.to_i == result ? result.to_i : result.to_f
+        rescue ArgumentError
+          raise SQLite3::SQLException, 'invalid input syntax for type double precision'
+        end
+      end
+    end
+  end
+end

data/lib/sqlite3_extend_function/functions/width_bucket.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module SQLite3ExtendFunction
+  module Functions
+    # SQLite3ExtendFunction::Functions::WidthBucket
+    module WidthBucket
+      class << self
+        # @param [Float, Integer] operand
+        # @param [Integer, Float] b1
+        # @param [Integer, Float] b2
+        # @param [Integer] count
+        # @return [Integer]
+        # @raise [SQLite3::SQLException]
+        def call(operand, b1, b2, count)
+          raise ArgumentError unless count.positive?
+
+          result = (Float(operand) / ((Float(b2) - Float(b1)) / Float(count))).ceil
+          result = count + 1 if result > count
+          result = 0 if result.negative?
+          result.to_i
+        rescue ArgumentError
+          raise SQLite3::SQLException, 'ArgumentError'
+        end
+      end
+    end
+  end
+end

data/lib/sqlite3_extend_function/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module SQLite3ExtendFunction
-  VERSION = '0.2.0'
+  VERSION = '0.3.0'
 end

data/sqlite3_extend_function.gemspec

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+require_relative 'lib/sqlite3_extend_function/version'
+
+Gem::Specification.new do |spec|
+  spec.name        = 'sqlite3_extend_function'
+  spec.version     = SQLite3ExtendFunction::VERSION
+  spec.authors     = %w[shoma07]
+  spec.email       = %w[23730734+shoma07@users.noreply.github.com]
+  spec.homepage    = 'https://github.com/shoma07/sqlite3_extend_function'
+  spec.required_ruby_version = Gem::Requirement.new('>= 2.4.0')
+  spec.summary     = 'Add some user-defined functions to SQL when using SQLie3.'
+  spec.description = 'Add some user-defined functions to SQL when using SQLie3.'
+  spec.license     = 'MIT'
+
+  spec.metadata['homepage_uri'] = spec.homepage
+  spec.metadata['source_code_uri'] = spec.homepage
+  spec.metadata['changelog_uri'] = "#{spec.homepage}/blob/v#{spec.version}/CHANGELOG.md"
+
+  # Specify which files should be added to the gem when it is released.
+  # The `git ls-files -z` loads the files in the RubyGem that have been added into git.
+  spec.files = Dir.chdir(File.expand_path(__dir__)) do
+    `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  end
+end