algebra_db 0.1.0

data/lib/algebra_db/statement.rb

@@ -0,0 +1,7 @@
+module AlgebraDB
+  ##
+  # Namespace for statement modules.
+  module Statement
+    autoload(:Select, 'algebra_db/statement/select')
+  end
+end

data/lib/algebra_db/statement/select.rb

@@ -0,0 +1,84 @@
+module AlgebraDB
+  module Statement
+    ##
+    # A select statement executor.
+    class Select
+      def self.run_syntax(&block)
+        new.tap { |t| t.instance_eval(&block) }
+      end
+
+      def initialize
+        @wheres = []
+        @froms = []
+        @joins = []
+        @select = nil
+      end
+
+      ##
+      # Give a {AlgebgraDB::Table} or something else
+      # that responds to #to_relation, gives you back
+      # a relation that you can use further in the query.
+      #
+      # If you use `relationish` in another query (by storing it in a variable out of scope),
+      # it will break!
+      def all(relationish)
+        unless relationish.respond_to?(:to_relation)
+          raise ArgumentError, "#{relationish} does not respond to to_relation!"
+        end
+
+        relation = relationish.to_relation(next_table_alias)
+        @froms << relation.from_clause
+        relation
+      end
+
+      def where(filter)
+        @wheres << filter
+      end
+
+      def select(*selects)
+        @select = Build::SelectList.new(*selects)
+      end
+
+      def join_relationship(relationship, type: :inner)
+        joins(relationship.joined_table, type: type) do |rel|
+          relationship.join_clause(rel)
+        end
+      end
+
+      def joins(other_table, type: :inner, &block)
+        relation = other_table.to_relation(next_table_alias)
+        join_clause = block.call(relation)
+        @joins << Build::Join.new(type, relation.from_clause, join_clause)
+        relation
+      end
+
+      def raw_param(ruby_value)
+        Build.param(ruby_value)
+      end
+
+      def to_delivery
+        raise ArgumentError, 'nothing selected' unless @select
+
+        Exec::Delivery.new(self, @select.row_decoder)
+      end
+
+      def render_syntax(builder)
+        raise ArgumentError, 'no select' unless @select
+
+        builder.text('SELECT')
+        @select.render_syntax(builder)
+        builder.text('FROM')
+        builder.separate(@froms) { |f, b| f.render_syntax(b) }
+        @joins.each { |j| j.render_syntax(builder) }
+        return if @wheres.empty?
+
+        builder.text('WHERE')
+        builder.separate(@wheres, separator: ' AND') { |w, b| w.render_syntax(b) }
+      end
+
+      def next_table_alias
+        :"t_#{@froms.count + @joins.count + 1}"
+      end
+    end
+  end
+end

data/lib/algebra_db/syntax_builder.rb

@@ -0,0 +1,54 @@
+module AlgebraDB
+  ##
+  # Class that builds syntax.
+  class SyntaxBuilder
+    def initialize(params = [])
+      @params = params
+      @syntax = +''
+    end
+
+    def text(str)
+      @syntax << str
+      @syntax << ' '
+    end
+
+    def text_nospace(str)
+      @syntax << str
+    end
+
+    def param(param)
+      text "$#{@params.length + 1}"
+      @params << param
+    end
+
+    def separate(listish, separator: ',')
+      raise ArgumentError, 'need a block' unless block_given?
+
+      len = listish.length
+      listish.each.with_index do |e, i|
+        yield e, self
+        unless (i + 1) == len
+          @syntax.strip!
+          text(separator)
+        end
+      end
+    end
+
+    def parenthesize
+      raise ArgumentError, 'need a block' unless block_given?
+
+      text_nospace('(')
+      yield self
+      @syntax.strip!
+      text(')')
+    end
+
+    def syntax
+      @syntax.dup
+    end
+
+    def params
+      @params.map(&:dup)
+    end
+  end
+end

data/lib/algebra_db/table.rb

@@ -0,0 +1,98 @@
+module AlgebraDB
+  ##
+  # Represent a table in AlgebraDB.
+  # You should subclass this for your own tables.
+  #
+  # You should not call #new on this directly.
+  # Instead, use the *class* in a syntax runner.
+  class Table
+    class << self
+      ##
+      # Hash of column_name -> column_type
+      #
+      # This returns a value modified with {#dup}, so modifying it
+      # will have no effect on the table defintion.
+      def columns
+        (@columns || {}).dup
+      end
+
+      ##
+      # We customize the inspect method to return a quick defintion of this table.
+      # This makes working with it in a REPL much, much easier.
+      def inspect
+        str = "#<#{name}:#{object_id} "
+        str << "columns=[#{columns.keys.map(&:inspect).join(', ')}]>"
+      end
+
+      def column(name, value)
+        value = ::AlgebraDB::Value.const_get(value) if value.is_a?(Symbol)
+        @columns ||= {}
+        @columns[name.to_sym] = value
+        define_method(name) do
+          value.new(Build::Column.new(table_alias, name))
+        end
+      end
+
+      ##
+      # Does this table contain this column?
+      def column?(name)
+        columns.key?(name.to_sym)
+      end
+
+      def to_relation(relation_alias)
+        new(relation_alias)
+      end
+
+      def relationship(name, other_table, &block)
+        (@relationships ||= {})[name] = other_table
+        define_method(name) do
+          relater_proc =
+            if block.arity == 2
+              proc { |other_relation| block.call(self, other_relation) }
+            else
+              proc { |other_relation| instance_exec(other_relation, &block) }
+            end
+          Def::Relationship.new(other_table, relater_proc)
+        end
+      end
+
+      ##
+      # Determine the relationships defined on this table.
+      # This is a pretty simple hash of the name of the relationship to the related table.
+      # It does not include any information on *how* to obtain that relationship: you need to use
+      # the defined instance method on a table instance to get that.
+      attr_reader :relationships
+      ##
+      # The name of this table in Postgres-land.
+      # This is anything you want, and we don't default this.
+      # TODO: maybe default this to follow some kind of rails conventions?
+      attr_accessor :table_name
+    end
+
+    def initialize(table_alias)
+      @table_alias = table_alias
+    end
+
+    def from_clause
+      Build::TableFrom.new(self.class.table_name, @table_alias)
+    end
+
+    def column(name)
+      self.class.columns.fetch(name.to_sym).new(
+        Build::Column.new(table_alias, name)
+      )
+    end
+
+    def columns
+      self.class.columns.keys.map do |k|
+        column(k)
+      end
+    end
+
+    def to_select_item
+      columns.flat_map(&:to_select_item)
+    end
+
+    attr_reader :table_alias
+  end
+end

data/lib/algebra_db/value.rb

@@ -0,0 +1,45 @@
+module AlgebraDB
+  ##
+  # Base class for value types in the DB.
+  class Value < Struct.new(:builder) # rubocop:disable Style/StructInheritance
+    autoload(:Array, 'algebra_db/value/array')
+    autoload(:Text, 'algebra_db/value/text')
+    autoload(:Integer, 'algebra_db/value/integer')
+    autoload(:Bool, 'algebra_db/value/bool')
+    autoload(:Double, 'algebra_db/value/double')
+    autoload(:JSONB, 'algebra_db/value/jsonb')
+    autoload(:Operations, 'algebra_db/value/operations')
+
+    extend AlgebraDB::Value::Operations::Definition
+
+    def render_syntax(syntax_builder)
+      builder.render_syntax(syntax_builder)
+    end
+
+    def to_select_item
+      unless builder.respond_to?(:default_select_item_alias)
+        raise ArgumentError, "#{builder.inspect} has no default alias for us as a select item"
+      end
+
+      Build::SelectItem.new(self, builder.default_select_item_alias)
+    end
+
+    def decoder
+      Exec::Decoder.new
+    end
+
+    {
+      eq: '=', neq: '<>',
+      lt: '<', lt_eq: '<=',
+      gt: '>', gt_eq: '>='
+    }.each { |k, v| binop(k, v, :Bool) }
+
+    Build::Between::VALID_TYPES.each do |t|
+      define_method(t) do |lhs, rhs|
+        Value::Bool.new(
+          Build::Between.new(t, self, lhs, rhs)
+        )
+      end
+    end
+  end
+end

data/lib/algebra_db/value/array.rb

@@ -0,0 +1,55 @@
+module AlgebraDB
+  class Value
+    ##
+    # Represents Postgres arrays with an inner type.
+    class Array < Value
+      def self.of(other)
+        Class.new(other) do
+          include AlgebraDB::Value::Array::ArrayOps
+
+          def decoder
+            AlgebraDB::Value::Array::Decoder.new(super)
+          end
+        end
+      end
+      ##
+      # Decodes into ruby arrays.
+      class Decoder < AlgebraDB::Exec::Decoder
+        def initialize(inner_decoder) # rubocop:disable Lint/MissingSuper
+          @inner_decoder = inner_decoder
+        end
+
+        def pg_decoder
+          PG::TextDecoder::Array.new.tap do |decoder|
+            decoder.elements_type = @inner_decoder.pg_decoder
+          end
+        end
+
+        def decode_value(db_value)
+          db_value.map { |v| @inner_decoder.decode_value(v) }
+        end
+      end
+
+      ##
+      # Array operations, mixed into generated array value classes.
+      module ArrayOps
+        extend Operations::Definition
+
+        binop(:contains, :'@>', :Bool)
+        binop(:is_contained_by, :'<@', :Bool)
+        binop(:overlaps, :'&&', :Bool)
+        binop(:concat, :'||', :Bool)
+      end
+
+      def decoder
+        AlgebraDB::Value::Array::Decoder.new(builder.decoder)
+      end
+
+      # Convenience constants
+      Text = of(::AlgebraDB::Value::Text)
+      Double = of(::AlgebraDB::Value::Double)
+      Integer = of(::AlgebraDB::Value::Integer)
+      JSONB = of(::AlgebraDB::Value::JSONB)
+    end
+  end
+end

data/lib/algebra_db/value/bool.rb

@@ -0,0 +1,31 @@
+module AlgebraDB
+  class Value
+    ##
+    # Represents a Postgres boolean value.
+    class Bool < Value
+      def and(other)
+        Value::Bool.new(
+          Build::Op.new('AND', self, other)
+        )
+      end
+
+      def or(other)
+        Value::Bool.new(
+          Build::Op.new('OR', self, other)
+        )
+      end
+
+      ##
+      # Specialization of this decoder.
+      class Decoder < AlgebraDB::Exec::Decoder
+        def decode_value(db_value)
+          db_value == 't'
+        end
+      end
+
+      def decoder
+        Decoder.new
+      end
+    end
+  end
+end

data/lib/algebra_db/value/double.rb

@@ -0,0 +1,20 @@
+module AlgebraDB
+  class Value
+    ##
+    # Represents a Postgres double value.
+    class Double < Value
+      include Operations::Numeric
+      ##
+      # Specialization of this decoder.
+      class Decoder < AlgebraDB::Exec::Decoder
+        def pg_decoder
+          PG::TextDecoder::Float.new
+        end
+      end
+
+      def decoder
+        Decoder.new
+      end
+    end
+  end
+end

data/lib/algebra_db/value/integer.rb

@@ -0,0 +1,20 @@
+module AlgebraDB
+  class Value
+    ##
+    # Represents a Postgres integer value.
+    class Integer < Value
+      include Operations::Numeric
+      ##
+      # Specialization of this decoder.
+      class Decoder < AlgebraDB::Exec::Decoder
+        def pg_decoder
+          PG::TextDecoder::Integer.new
+        end
+      end
+
+      def decoder
+        Decoder.new
+      end
+    end
+  end
+end

data/lib/algebra_db/value/jsonb.rb

@@ -0,0 +1,19 @@
+module AlgebraDB
+  class Value
+    ##
+    # Represents Postgres JSONB values.
+    class JSONB < Value
+      ##
+      # Decoder just decodes to a hash.
+      class Decoder < AlgebraDB::Exec::Decoder
+        def pg_decoder
+          PG::TextDecoder::JSON.new
+        end
+      end
+
+      def decoder
+        Decoder.new
+      end
+    end
+  end
+end

data/lib/algebra_db/value/operations.rb

@@ -0,0 +1,10 @@
+module AlgebraDB
+  class Value
+    ##
+    # Easily define operations on values.
+    module Operations
+      autoload(:Definition, 'algebra_db/value/operations/definition')
+      autoload(:Numeric, 'algebra_db/value/operations/numeric')
+    end
+  end
+end