sqlite3_extend_function 0.2.0 → 0.3.0

data/lib/sqlite3_extend_function/functions.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+Dir["#{__dir__}/functions/**/*.rb"].sort.each { |f| require f }
+
+module SQLite3ExtendFunction
+  # SQLite3ExtendFunction::Functions
+  module Functions
+    class << self
+      # @return [void]
+      def each
+        constants.each do |const|
+          yield SQLite3ExtendFunction::Function.new(const_get(const))
+        end
+      end
+    end
+  end
+end

data/lib/sqlite3_extend_function/functions/acos.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module SQLite3ExtendFunction
+  module Functions
+    # SQLite3ExtendFunction::Functions::Acos
+    module Acos
+      class << self
+        # @param [Integer, Float] x
+        # @return [Float]
+        # @raise [SQLite3::SQLException]
+        def call(x)
+          Math.acos(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/ascii.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module SQLite3ExtendFunction
+  module Functions
+    # SQLite3ExtendFunction::Functions::Ascii
+    module Ascii
+      class << self
+        # @param [String] str
+        # @return [Integer]
+        # @raise [SQLite3::SQLException]
+        def call(str)
+          str.is_a?(String) ? str.ord : (raise ArgumentError)
+        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/asin.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module SQLite3ExtendFunction
+  module Functions
+    # SQLite3ExtendFunction::Functions::Asin
+    module Asin
+      class << self
+        # @param [Integer, Float] x
+        # @return [Float]
+        # @raise [SQLite3::SQLException]
+        def call(x)
+          Math.asin(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/atan.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module SQLite3ExtendFunction
+  module Functions
+    # SQLite3ExtendFunction::Functions::Atan
+    module Atan
+      class << self
+        # @param [Integer, Float] x
+        # @return [Float]
+        # @raise [SQLite3::SQLException]
+        def call(x)
+          Math.atan(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/atan2.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module SQLite3ExtendFunction
+  module Functions
+    # SQLite3ExtendFunction::Functions::Atan2
+    module Atan2
+      class << self
+        # @param [Integer, Float] y
+        # @param [Integer, Float] x
+        # @return [Float]
+        # @raise [SQLite3::SQLException]
+        def call(y, x)
+          Math.atan2(Float(y), Float(x))
+        rescue ArgumentError
+          raise SQLite3::SQLException, 'invalid input syntax for type double precision'
+        end
+      end
+    end
+  end
+end

data/lib/sqlite3_extend_function/functions/bit_length.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module SQLite3ExtendFunction
+  module Functions
+    # SQLite3ExtendFunction::Functions::BitLength
+    module BitLength
+      class << self
+        # @param [String] str
+        # @return [Integer]
+        # @raise [SQLite3::SQLException]
+        def call(str)
+          str.bytesize * 8
+        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/btrim.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module SQLite3ExtendFunction
+  module Functions
+    # SQLite3ExtendFunction::Functions::Btrim
+    module Btrim
+      class << self
+        # @param [String] text
+        # @param [String] chars
+        # @return [String]
+        # @raise [SQLite3::SQLException]
+        def call(text, chrs = '')
+          text.sub(/\A[#{chrs}]*/, '').sub(/[#{chrs}]*\z/, '')
+        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/cbrt.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module SQLite3ExtendFunction
+  module Functions
+    # SQLite3ExtendFunction::Functions::Cbrt
+    module Cbrt
+      class << self
+        # @param [Integer, Float] dp
+        # @return [Integer, Float]
+        # @raise [SQLite3::SQLException]
+        def call(dp)
+          return if dp.nil?
+
+          result = Math.cbrt(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/ceil.rb

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

data/lib/sqlite3_extend_function/functions/char_length.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module SQLite3ExtendFunction
+  module Functions
+    # SQLite3ExtendFunction::Functions::CharLength
+    module CharLength
+      class << self
+        # @param [String] str
+        # @return [Integer]
+        # @raise [SQLite3::SQLException]
+        def call(str)
+          str.length
+        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/chr.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module SQLite3ExtendFunction
+  module Functions
+    # SQLite3ExtendFunction::Functions::Chr
+    module Chr
+      class << self
+        # @param [Integer] int
+        # @return [String]
+        # @raise [SQLite3::SQLException]
+        def call(int)
+          int.chr
+        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/concat.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module SQLite3ExtendFunction
+  module Functions
+    # SQLite3ExtendFunction::Functions::Concat
+    module Concat
+      class << self
+        # @param [Array<String>] args
+        # @return [String]
+        # @raise [SQLite3::SQLException]
+        def call(*args)
+          args.compact.join
+        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/concat_ws.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module SQLite3ExtendFunction
+  module Functions
+    # SQLite3ExtendFunction::Functions::ConcatWs
+    module ConcatWs
+      class << self
+        # @param [String] sep
+        # @param [Array<String>] args
+        # @return [String]
+        # @raise [SQLite3::SQLException]
+        def call(sep, *args)
+          args.compact.join(sep)
+        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/cos.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module SQLite3ExtendFunction
+  module Functions
+    # SQLite3ExtendFunction::Functions::Cos
+    module Cos
+      class << self
+        # @param [Integer, Float] x
+        # @return [Float]
+        # @raise [SQLite3::SQLException]
+        def call(x)
+          Math.cos(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/cot.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module SQLite3ExtendFunction
+  module Functions
+    # SQLite3ExtendFunction::Functions::Cot
+    module Cot
+      class << self
+        # @param [Integer, Float] x
+        # @return [Integer]
+        # @raise [SQLite3::SQLException]
+        def call(x)
+          1 / 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/decode.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module SQLite3ExtendFunction
+  module Functions
+    # SQLite3ExtendFunction::Functions::Decode
+    module Decode
+      class << self
+        # @todo implement escape
+        #
+        # @param [String] str
+        # @param [String] format
+        # @return [String]
+        # @raise [SQLite3::SQLException]
+        def call(str, format)
+          return if str.nil?
+          raise ArgumentError unless str.is_a?(String)
+
+          return Base64.decode64(str) if format == 'base64'
+          return str.scan(/.{2}/).map { |s| s.hex.chr }.join if format == 'hex'
+
+          raise  ArgumentError
+        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/degrees.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module SQLite3ExtendFunction
+  module Functions
+    # SQLite3ExtendFunction::Functions::Degrees
+    module Degrees
+      class << self
+        # @param [Integer, Float] dp
+        # @return [Float]
+        # @raise [SQLite3::SQLException]
+        def call(dp)
+          Float(dp) * 180 / Math::PI 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/div.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module SQLite3ExtendFunction
+  module Functions
+    # SQLite3ExtendFunction::Functions::Div
+    module Div
+      class << self
+        # @param [Integer, Float] y
+        # @param [Integer, Float] x
+        # @return [Integer, Float]
+        # @raise [SQLite3::SQLException]
+        def call(y, x)
+          Float(y).div(Float(x)) unless y.nil? || x.nil?
+        rescue ArgumentError
+          raise SQLite3::SQLException, 'invalid input syntax for type numeric'
+        end
+      end
+    end
+  end
+end

data/lib/sqlite3_extend_function/functions/encode.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module SQLite3ExtendFunction
+  module Functions
+    # SQLite3ExtendFunction::Functions::Encode
+    module Encode
+      class << self
+        # @todo implement escape
+        #
+        # @param [String] data
+        # @param [String] format
+        # @return [String, NilClass]
+        # @raise [SQLite3::SQLException]
+        def call(data, format)
+          return if data.nil?
+          raise ArgumentError unless data.is_a?(String)
+
+          return Base64.encode64(data) if format == 'base64'
+          return data.unpack('C*').map { |c| c.to_s(16) }.join if format == 'hex'
+
+          raise ArgumentError
+        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