rubydb 0.1.0

data/lib/rubydb/functions/aggregate.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+module RubyDB
+  module Functions
+    # AggregateFunction - Base class for aggregate functions
+    class AggregateFunction < Function
+      attr_reader :state_type
+
+      def initialize(name, options = {})
+        super(name, TYPE_AGGREGATE, options)
+        @state_type = options[:state_type] || :text
+        @initial_state = options[:initial_state] || nil
+        @is_distinct = false
+        @is_ordered = false
+      end
+
+      def execute(args)
+        validate_args(args)
+        # For aggregate functions, args is an array of values
+        args = args.flatten if args.is_a?(Array)
+        execute_aggregate(args)
+      end
+
+      def execute_aggregate(values)
+        raise NotImplementedError, "#{self.class} must implement #execute_aggregate"
+      end
+
+      def aggregate_batch(values)
+        # Default implementation: iterate through values
+        result = nil
+        values.each do |val|
+          result = combine(result, val)
+        end
+        result
+      end
+
+      def combine(state, value)
+        raise NotImplementedError, "#{self.class} must implement #combine"
+      end
+
+      def finalize(state)
+        state
+      end
+
+      def distinct?
+        @is_distinct
+      end
+
+      def ordered?
+        @is_ordered
+      end
+
+      def set_distinct(distinct)
+        @is_distinct = distinct
+      end
+
+      def set_ordered(ordered)
+        @is_ordered = ordered
+      end
+
+      def to_hash
+        super.merge({
+          state_type: @state_type,
+          distinct: @is_distinct,
+          ordered: @is_ordered
+        })
+      end
+    end
+  end
+end

data/lib/rubydb/functions/date_functions.rb

@@ -0,0 +1,278 @@
+# frozen_string_literal: true
+
+require "date"
+require "time"
+
+module RubyDB
+  module Functions
+    # DateFunctions - All date-related functions
+    class DateFunctions
+      # NOW - Current timestamp
+      class Now < ScalarFunction
+        def initialize
+          super(:now,
+            description: "Current timestamp",
+            category: :date,
+            min_args: 0,
+            max_args: 0,
+            return_type: :timestamp,
+            deterministic: false,
+            immutable: false
+          )
+        end
+
+        def execute_scalar(args)
+          Time.now
+        end
+      end
+
+      # CURRENT_DATE - Current date
+      class CurrentDate < ScalarFunction
+        def initialize
+          super(:current_date,
+            description: "Current date",
+            category: :date,
+            min_args: 0,
+            max_args: 0,
+            return_type: :date,
+            deterministic: false,
+            immutable: false
+          )
+        end
+
+        def execute_scalar(args)
+          Date.today
+        end
+      end
+
+      # CURRENT_TIME - Current time
+      class CurrentTime < ScalarFunction
+        def initialize
+          super(:current_time,
+            description: "Current time",
+            category: :date,
+            min_args: 0,
+            max_args: 0,
+            return_type: :time,
+            deterministic: false,
+            immutable: false
+          )
+        end
+
+        def execute_scalar(args)
+          Time.now
+        end
+      end
+
+      # DATE - Convert to date
+      class Date < ScalarFunction
+        def initialize
+          super(:date,
+            description: "Convert to date",
+            category: :date,
+            min_args: 1,
+            max_args: 1,
+            return_type: :date,
+            deterministic: true,
+            immutable: true
+          )
+        end
+
+        def execute_scalar(args)
+          return nil if args[0].nil?
+          arg = args[0]
+          if arg.is_a?(Time) || arg.is_a?(DateTime)
+            arg.to_date
+          elsif arg.is_a?(String)
+            ::Date.parse(arg) rescue nil
+          else
+            nil
+          end
+        end
+      end
+
+      # EXTRACT - Extract part of date
+      class Extract < ScalarFunction
+        def initialize
+          super(:extract,
+            description: "Extract part of date",
+            category: :date,
+            min_args: 2,
+            max_args: 2,
+            return_type: :integer,
+            deterministic: true,
+            immutable: true
+          )
+        end
+
+        def execute_scalar(args)
+          return nil if args[1].nil?
+
+          part = args[0].to_s.downcase
+          date = args[1]
+
+          case part
+          when "year", "y"
+            date.year
+          when "month", "mon"
+            date.month
+          when "day", "d"
+            date.day
+          when "hour", "h"
+            date.hour if date.respond_to?(:hour)
+          when "minute", "min"
+            date.min if date.respond_to?(:min)
+          when "second", "sec"
+            date.sec if date.respond_to?(:sec)
+          when "dow", "dayofweek"
+            date.wday
+          when "doy", "dayofyear"
+            date.yday if date.respond_to?(:yday)
+          else
+            nil
+          end
+        end
+      end
+
+      # DATE_ADD - Add interval to date
+      class DateAdd < ScalarFunction
+        def initialize
+          super(:date_add,
+            description: "Add interval to date",
+            category: :date,
+            min_args: 3,
+            max_args: 3,
+            return_type: :timestamp,
+            deterministic: true,
+            immutable: true
+          )
+        end
+
+        def execute_scalar(args)
+          return nil if args[0].nil?
+
+          date = args[0]
+          interval = args[1].to_i
+          unit = args[2].to_s.downcase
+
+          case unit
+          when "year", "years"
+            date + interval * 365 * 24 * 60 * 60
+          when "month", "months"
+            date + interval * 30 * 24 * 60 * 60
+          when "day", "days"
+            date + interval * 24 * 60 * 60
+          when "hour", "hours"
+            date + interval * 60 * 60
+          when "minute", "minutes"
+            date + interval * 60
+          when "second", "seconds"
+            date + interval
+          else
+            nil
+          end
+        end
+      end
+
+      # DATE_DIFF - Difference between dates
+      class DateDiff < ScalarFunction
+        def initialize
+          super(:date_diff,
+            description: "Difference between dates",
+            category: :date,
+            min_args: 3,
+            max_args: 3,
+            return_type: :integer,
+            deterministic: true,
+            immutable: true
+          )
+        end
+
+        def execute_scalar(args)
+          return nil if args[0].nil? || args[1].nil?
+
+          date1 = args[0]
+          date2 = args[1]
+          unit = args[2].to_s.downcase
+
+          diff = (date2.to_i - date1.to_i).abs
+
+          case unit
+          when "year", "years"
+            diff / (365 * 24 * 60 * 60)
+          when "month", "months"
+            diff / (30 * 24 * 60 * 60)
+          when "day", "days"
+            diff / (24 * 60 * 60)
+          when "hour", "hours"
+            diff / (60 * 60)
+          when "minute", "minutes"
+            diff / 60
+          when "second", "seconds"
+            diff
+          else
+            nil
+          end
+        end
+      end
+
+      # DATE_FORMAT - Format date
+      class DateFormat < ScalarFunction
+        def initialize
+          super(:date_format,
+            description: "Format date",
+            category: :date,
+            min_args: 2,
+            max_args: 2,
+            return_type: :text,
+            deterministic: true,
+            immutable: true
+          )
+        end
+
+        def execute_scalar(args)
+          return nil if args[0].nil? || args[1].nil?
+
+          date = args[0]
+          format = args[1].to_s
+
+          # Simple format substitutions
+          formatted = format
+          formatted = formatted.gsub("%Y", date.year.to_s)
+          formatted = formatted.gsub("%y", date.year.to_s[-2..-1])
+          formatted = formatted.gsub("%m", date.month.to_s.rjust(2, "0"))
+          formatted = formatted.gsub("%d", date.day.to_s.rjust(2, "0"))
+          formatted = formatted.gsub("%H", date.hour.to_s.rjust(2, "0")) if date.respond_to?(:hour)
+          formatted = formatted.gsub("%M", date.min.to_s.rjust(2, "0")) if date.respond_to?(:min)
+          formatted = formatted.gsub("%S", date.sec.to_s.rjust(2, "0")) if date.respond_to?(:sec)
+
+          formatted
+        end
+      end
+
+      # TO_TIMESTAMP - Convert string to timestamp
+      class ToTimestamp < ScalarFunction
+        def initialize
+          super(:to_timestamp,
+            description: "Convert string to timestamp",
+            category: :date,
+            min_args: 1,
+            max_args: 1,
+            return_type: :timestamp,
+            deterministic: true,
+            immutable: true
+          )
+        end
+
+        def execute_scalar(args)
+          return nil if args[0].nil?
+          begin
+            Time.parse(args[0].to_s)
+          rescue
+            nil
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rubydb/functions/function.rb

@@ -0,0 +1,85 @@
+# frozen_string_literal: true
+
+module RubyDB
+  module Functions
+    # Function - Base class for all functions
+    class Function
+      attr_reader :name, :type, :description, :category
+      attr_reader :min_args, :max_args, :return_type
+
+      # Function types
+      TYPE_SCALAR = :scalar
+      TYPE_AGGREGATE = :aggregate
+      TYPE_WINDOW = :window
+      TYPE_SYSTEM = :system
+
+      def initialize(name, type, options = {})
+        @name = name
+        @type = type
+        @description = options[:description] || ""
+        @category = options[:category] || :general
+        @min_args = options.key?(:min_args) ? options[:min_args] : 0
+        @max_args = options.key?(:max_args) ? options[:max_args] : -1 # -1 means unlimited
+        @return_type = options[:return_type] || :text
+        @deterministic = options[:deterministic] != false
+        @strict = options[:strict] || false
+        @immutable = options[:immutable] || false
+        @parallel_safe = options[:parallel_safe] != false
+        @registered_at = Time.now
+      end
+
+      def execute(args)
+        raise NotImplementedError, "#{self.class} must implement #execute"
+      end
+
+      def validate_args(args)
+        if args.size < @min_args
+          raise ArgumentError, "Function '#{@name}' requires at least #{@min_args} arguments, got #{args.size}"
+        end
+
+        if @max_args >= 0 && args.size > @max_args
+          raise ArgumentError, "Function '#{@name}' accepts at most #{@max_args} arguments, got #{args.size}"
+        end
+
+        true
+      end
+
+      def deterministic?
+        @deterministic
+      end
+
+      def strict?
+        @strict
+      end
+
+      def immutable?
+        @immutable
+      end
+
+      def to_hash
+        {
+          name: @name,
+          type: @type,
+          description: @description,
+          category: @category,
+          min_args: @min_args,
+          max_args: @max_args,
+          return_type: @return_type,
+          deterministic: @deterministic,
+          strict: @strict,
+          immutable: @immutable,
+          parallel_safe: @parallel_safe,
+          registered_at: @registered_at.iso8601
+        }
+      end
+
+      def inspect
+        "#<Function name=#{@name} type=#{@type} args=#{@min_args}..#{@max_args}>"
+      end
+
+      def to_s
+        @name.to_s
+      end
+    end
+  end
+end

data/lib/rubydb/functions/json_functions.rb

@@ -0,0 +1,215 @@
+# frozen_string_literal: true
+
+require "json"
+
+module RubyDB
+  module Functions
+    # JsonFunctions - All JSON-related functions
+    class JsonFunctions
+      # JSON_EXTRACT - Extract value from JSON
+      class JsonExtract < ScalarFunction
+        def initialize
+          super(:json_extract,
+            description: "Extract value from JSON",
+            category: :json,
+            min_args: 2,
+            max_args: 2,
+            return_type: :text,
+            deterministic: true,
+            immutable: true
+          )
+        end
+
+        def execute_scalar(args)
+          return nil if args[0].nil? || args[1].nil?
+
+          json = parse_json(args[0])
+          path = args[1].to_s
+
+          result = json
+          path.split(".").each do |key|
+            break unless result.is_a?(Hash) || result.is_a?(Array)
+
+            if result.is_a?(Hash)
+              result = result[key]
+            elsif result.is_a?(Array)
+              idx = key.to_i
+              result = result[idx] if idx >= 0 && idx < result.size
+            end
+          end
+
+          result.is_a?(String) ? result : result.to_json
+        end
+
+        private
+
+        def parse_json(value)
+          if value.is_a?(Hash) || value.is_a?(Array)
+            value
+          elsif value.is_a?(String)
+            JSON.parse(value) rescue {}
+          else
+            {}
+          end
+        end
+      end
+
+      # JSON_ARRAY - Create JSON array
+      class JsonArray < ScalarFunction
+        def initialize
+          super(:json_array,
+            description: "Create JSON array",
+            category: :json,
+            min_args: 0,
+            max_args: -1,
+            return_type: :json,
+            deterministic: true,
+            immutable: true
+          )
+        end
+
+        def execute_scalar(args)
+          args.map { |a| a.is_a?(String) ? a : a.to_s }.to_json
+        end
+      end
+
+      # JSON_OBJECT - Create JSON object
+      class JsonObject < ScalarFunction
+        def initialize
+          super(:json_object,
+            description: "Create JSON object",
+            category: :json,
+            min_args: 2,
+            max_args: -1,
+            return_type: :json,
+            deterministic: true,
+            immutable: true
+          )
+        end
+
+        def execute_scalar(args)
+          result = {}
+          i = 0
+          while i < args.size - 1
+            key = args[i].to_s
+            value = args[i + 1]
+            result[key] = value.is_a?(String) ? value : value.to_s
+            i += 2
+          end
+          result.to_json
+        end
+      end
+
+      # JSON_ARRAY_LENGTH - Get JSON array length
+      class JsonArrayLength < ScalarFunction
+        def initialize
+          super(:json_array_length,
+            description: "Get JSON array length",
+            category: :json,
+            min_args: 1,
+            max_args: 1,
+            return_type: :integer,
+            deterministic: true,
+            immutable: true
+          )
+        end
+
+        def execute_scalar(args)
+          return nil if args[0].nil?
+
+          json = parse_json(args[0])
+          json.is_a?(Array) ? json.size : 0
+        end
+
+        private
+
+        def parse_json(value)
+          if value.is_a?(Hash) || value.is_a?(Array)
+            value
+          elsif value.is_a?(String)
+            JSON.parse(value) rescue {}
+          else
+            {}
+          end
+        end
+      end
+
+      # JSON_TYPE - Get JSON value type
+      class JsonType < ScalarFunction
+        def initialize
+          super(:json_type,
+            description: "Get JSON value type",
+            category: :json,
+            min_args: 1,
+            max_args: 1,
+            return_type: :text,
+            deterministic: true,
+            immutable: true
+          )
+        end
+
+        def execute_scalar(args)
+          return nil if args[0].nil?
+
+          json = parse_json(args[0])
+          case json
+          when Hash then "object"
+          when Array then "array"
+          when String then "string"
+          when Integer then "integer"
+          when Float then "number"
+          when true, false then "boolean"
+          when nil then "null"
+          else "unknown"
+          end
+        end
+
+        private
+
+        def parse_json(value)
+          if value.is_a?(Hash) || value.is_a?(Array)
+            value
+          elsif value.is_a?(String)
+            JSON.parse(value) rescue {}
+          else
+            {}
+          end
+        end
+      end
+
+      # JSON_KEYS - Get JSON object keys
+      class JsonKeys < ScalarFunction
+        def initialize
+          super(:json_keys,
+            description: "Get JSON object keys",
+            category: :json,
+            min_args: 1,
+            max_args: 1,
+            return_type: :json,
+            deterministic: true,
+            immutable: true
+          )
+        end
+
+        def execute_scalar(args)
+          return nil if args[0].nil?
+
+          json = parse_json(args[0])
+          json.is_a?(Hash) ? json.keys.to_json : [].to_json
+        end
+
+        private
+
+        def parse_json(value)
+          if value.is_a?(Hash) || value.is_a?(Array)
+            value
+          elsif value.is_a?(String)
+            JSON.parse(value) rescue {}
+          else
+            {}
+          end
+        end
+      end
+    end
+  end
+end