algebra_db 0.1.0

data/bin/console

@@ -0,0 +1,91 @@
+#!/usr/bin/env ruby
+
+require 'bundler/setup'
+require 'algebra_db'
+require 'logger'
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+require 'pry'
+
+##
+# Basic user table
+class User < AlgebraDB::Table
+  self.table_name = :users
+
+  column :id, :Integer
+  column :first_name, :Text
+  column :last_name, :Text
+
+  relationship :users_not_me, User do |other_users|
+    other_users.id.neq(id)
+  end
+
+  relationship :audits, -> { UserAudit } do |user_audits|
+    user_audits.user_id.eq(id)
+  end
+
+  ##
+  # Can return expressions!
+  def full_name
+    first_name.append(AlgebraDB::Build.param(' ')).append(last_name)
+  end
+end
+
+##
+# Fake audit log for users
+class UserAudit < AlgebraDB::Table
+  self.table_name = :user_audits
+
+  column :id, :Integer
+  column :user_id, :Integer
+  column :scopes_granted, AlgebraDB::Value::Array::Text
+  column :changes, AlgebraDB::Value::JSONB
+
+  relationship :user, User do |user|
+    user.id.eq(user_id)
+  end
+
+  relationship :similar_scopes, UserAudit do |other_audits|
+    other_audits.scopes_granted.overlaps(scopes_granted).and(
+      other_audits.id.neq(id)
+    )
+  end
+end
+
+COOL_QUERY = AlgebraDB::Statement::Select.run_syntax do
+  audits = all(UserAudit)
+  similar = join_relationship(audits.similar_scopes)
+  audit_users = join_relationship(audits.user)
+  similar_users = join_relationship(similar.user)
+  select(
+    parent_id: audits.id,
+    parent_scopes: audits.scopes_granted,
+    parent_user: audit_users.full_name,
+    child_id: similar.id,
+    child_scopes: similar.scopes_granted,
+    child_user: similar_users.full_name
+  )
+end
+
+##
+# Connection wrapper that logs stuff
+class LoggedConnection
+  def initialize(logger, connection)
+    @logger = logger
+    @connection = connection
+  end
+
+  attr_reader :logger, :connection
+
+  def exec_params(query, params, &block)
+    logger.debug(query)
+    connection.exec_params(query, params, &block)
+  end
+end
+
+CONN = LoggedConnection.new(Logger.new($stdout), PG::Connection.new('postgres://localhost/algebra_db_test'))
+
+Pry.start

data/bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/lib/algebra_db.rb

@@ -0,0 +1,16 @@
+require 'algebra_db/version'
+require 'pg'
+
+##
+# Root namespace for the gem.
+module AlgebraDB
+  class Error < StandardError; end
+  autoload(:Build, 'algebra_db/build')
+  autoload(:Def, 'algebra_db/def')
+  autoload(:Exec, 'algebra_db/exec')
+  autoload(:Value, 'algebra_db/value')
+  autoload(:SyntaxBuilder, 'algebra_db/syntax_builder')
+  autoload(:Statement, 'algebra_db/statement')
+  autoload(:Table, 'algebra_db/table')
+  # Your code goes here...
+end

data/lib/algebra_db/build.rb

@@ -0,0 +1,20 @@
+module AlgebraDB
+  ##
+  # Namespace for syntax builders.
+  module Build
+    autoload(:Op, 'algebra_db/build/op')
+    autoload(:Between, 'algebra_db/build/between')
+    autoload(:Param, 'algebra_db/build/param')
+    autoload(:Column, 'algebra_db/build/column')
+    autoload(:TableFrom, 'algebra_db/build/table_from')
+    autoload(:SelectItem, 'algebra_db/build/select_item')
+    autoload(:Join, 'algebra_db/build/join')
+    autoload(:SelectList, 'algebra_db/build/select_list')
+
+    ##
+    # Returns a raw parameter builder, with no value type.
+    def self.param(value)
+      Param.new(value)
+    end
+  end
+end

data/lib/algebra_db/build/between.rb

@@ -0,0 +1,25 @@
+module AlgebraDB
+  module Build
+    ##
+    # A BETWEEN expression builder.
+    class Between < Struct.new(:between_type, :choose, :start, :finish) # rubocop:disable Style/StructInheritance
+      VALID_TYPES =
+        %i[between not_between between_symmetric not_between_symmetric].freeze
+      def initialize(between_type, choose, start, finish)
+        super(between_type, choose, start, finish)
+
+        return if VALID_TYPES.include?(between_type)
+
+        raise ArgumentError, "#{between_type} must be one of #{VALID_TYPES.inspect}"
+      end
+
+      def render_syntax(builder)
+        choose.render_syntax(builder)
+        builder.text(between_type.to_s.gsub('_', ' ').upcase)
+        start.render_syntax(builder)
+        builder.text('AND')
+        finish.render_syntax(builder)
+      end
+    end
+  end
+end

data/lib/algebra_db/build/column.rb

@@ -0,0 +1,13 @@
+module AlgebraDB
+  module Build
+    Column = Struct.new(:table, :column) do
+      def render_syntax(builder)
+        builder.text(%("#{table}"."#{column}"))
+      end
+
+      def default_select_item_alias
+        column
+      end
+    end
+  end
+end

data/lib/algebra_db/build/join.rb

@@ -0,0 +1,35 @@
+module AlgebraDB
+  module Build
+    ##
+    # Syntax for a join.
+    class Join < Struct.new(:type, :table, :condition) # rubocop:disable Style/StructInheritance
+      JOIN_EXPRS = {
+        inner: 'INNER JOIN',
+        left: 'LEFT OUTER JOIN',
+        right: 'RIGHT OUTER JOIN',
+        inner_lateral: 'INNER JOIN LATERAL',
+        left_lateral: 'LEFT JOIN LATERAL',
+        right_lateral: 'RIGHT JOIN LATERAL'
+      }.freeze
+
+      TYPES = JOIN_EXPRS.keys.freeze
+
+      def initialize(type, table, condition)
+        super(type, table, condition)
+
+        raise ArgumentError, "unrecognized join type #{type}" unless TYPES.include?(type)
+      end
+
+      def render_syntax(builder)
+        builder.text(join_expr)
+        table.render_syntax(builder)
+        builder.text('ON')
+        condition.render_syntax(builder)
+      end
+
+      def join_expr
+        JOIN_EXPRS[type]
+      end
+    end
+  end
+end

data/lib/algebra_db/build/op.rb

@@ -0,0 +1,13 @@
+module AlgebraDB
+  module Build
+    Op = Struct.new(:operator, :lhs, :rhs) do
+      def render_syntax(builder)
+        builder.parenthesize do
+          lhs.render_syntax(builder)
+          builder.text(operator.to_s)
+          rhs.render_syntax(builder)
+        end
+      end
+    end
+  end
+end

data/lib/algebra_db/build/param.rb

@@ -0,0 +1,9 @@
+module AlgebraDB
+  module Build
+    Param = Struct.new(:value) do
+      def render_syntax(builder)
+        builder.param(value)
+      end
+    end
+  end
+end

data/lib/algebra_db/build/select_item.rb

@@ -0,0 +1,22 @@
+module AlgebraDB
+  module Build
+    SelectItem = Struct.new(:value, :select_alias) do
+      def initialize(value, select_alias)
+        super(value, select_alias)
+
+        raise ArgumentError, "value can't be nil" if value.nil?
+        raise ArgumentError, "select_alias can't be nil" if select_alias.nil?
+      end
+
+      def render_syntax(builder)
+        value.render_syntax(builder)
+        builder.text 'AS'
+        builder.text(%("#{select_alias}"))
+      end
+
+      def decoder
+        value.decoder
+      end
+    end
+  end
+end

data/lib/algebra_db/build/select_list.rb

@@ -0,0 +1,64 @@
+module AlgebraDB
+  module Build
+    ##
+    # Build up a select list.
+    class SelectList < Struct.new(:items) # rubocop:disable Style/StructInheritance
+      def initialize(*selects)
+        super(selects.flat_map { |i| convert_select_item(i) })
+
+        items.each do |i|
+          same_name = items.select { |i2| i2.select_alias == i.select_alias }
+
+          raise ArgumentError, "duplicate key #{i.select_alias}" if same_name.count > 1
+        end
+      end
+
+      def render_syntax(builder)
+        builder.separate(items) do |i, b|
+          i.render_syntax(b)
+        end
+      end
+
+      ##
+      # Row decoder that delegates to the decoders of
+      # the items in the select list.
+      class RowDecoder < AlgebraDB::Exec::RowDecoder
+        def initialize(columns) # rubocop:disable Lint/MissingSuper
+          @columns = columns
+          @column_decoders = columns.map(&:decoder)
+        end
+
+        attr_reader :column_decoders
+
+        def pg_type_map
+          PG::TypeMapByColumn.new(column_decoders.map(&:pg_decoder))
+        end
+
+        def decode_row(row)
+          values = row.values.map.with_index do |r, i|
+            @column_decoders[i].decode_value(r)
+          end
+          row_struct.new(*values)
+        end
+
+        def row_struct
+          @row_struct ||= Struct.new(*@columns.map { |c| c.select_alias.to_sym })
+        end
+      end
+
+      def row_decoder
+        RowDecoder.new(items)
+      end
+
+      private
+
+      def convert_select_item(item)
+        if item.respond_to?(:to_select_item)
+          item.to_select_item
+        else
+          item.map { |k, v| SelectItem.new(v, k) }
+        end
+      end
+    end
+  end
+end

data/lib/algebra_db/build/table_from.rb

@@ -0,0 +1,10 @@
+module AlgebraDB
+  module Build
+    TableFrom = Struct.new(:original_table, :table_alias) do
+      def render_syntax(builder)
+        builder.text(original_table.to_s)
+        builder.text(table_alias.to_s)
+      end
+    end
+  end
+end

data/lib/algebra_db/def.rb

@@ -0,0 +1,7 @@
+module AlgebraDB
+  ##
+  # Contains definitional helpers.
+  module Def
+    autoload(:Relationship, 'algebra_db/def/relationship')
+  end
+end

data/lib/algebra_db/def/relationship.rb

@@ -0,0 +1,20 @@
+module AlgebraDB
+  module Def
+    ##
+    # Defines a relationship between two tables.
+    class Relationship
+      def initialize(joined_table, relater_proc)
+        @joined_table = joined_table
+        @relater_proc = relater_proc
+      end
+
+      def join_clause(joined_relation)
+        @relater_proc.call(joined_relation)
+      end
+
+      def joined_table
+        @joined_table.is_a?(Proc) ? @joined_table.call : @joined_table
+      end
+    end
+  end
+end

data/lib/algebra_db/exec.rb

@@ -0,0 +1,9 @@
+module AlgebraDB
+  ##
+  # Namespace for things that execute queries, and helpers.
+  module Exec
+    autoload(:Delivery, 'algebra_db/exec/delivery')
+    autoload(:Decoder, 'algebra_db/exec/decoder')
+    autoload(:RowDecoder, 'algebra_db/exec/row_decoder')
+  end
+end

data/lib/algebra_db/exec/decoder.rb

@@ -0,0 +1,20 @@
+module AlgebraDB
+  module Exec
+    ##
+    # Informational class that holds a decoder.
+    class Decoder
+      ##
+      # The decoder given to postgres for a string.
+      def pg_decoder
+        PG::TextDecoder::String.new
+      end
+
+      ##
+      # Post-processing: after we use the pg decoder to load from
+      # DB, transform it here! By default, does nothing.
+      def decode_value(db_value)
+        db_value
+      end
+    end
+  end
+end

data/lib/algebra_db/exec/delivery.rb

@@ -0,0 +1,35 @@
+module AlgebraDB
+  module Exec
+    ##
+    # Something we can hand off to a connection
+    # to get back ruby values to play with.
+    class Delivery
+      def initialize(query_builder, select_decoder)
+        @query_builder = query_builder
+        @select_decoder = select_decoder
+      end
+
+      def execute!(connection)
+        return enum_for(:execute!, connection) unless block_given?
+
+        execute_raw!(connection) do |result|
+          result.type_map = @select_decoder.pg_type_map
+          result.each do |row|
+            yield @select_decoder.decode_row(row)
+          end
+        end
+      end
+
+      ##
+      # Execute a query raw, IE, don't do decoding.
+      def execute_raw!(connection)
+        sb = SyntaxBuilder.new.tap { |t| @query_builder.render_syntax(t) }
+        # rubocop:disable Style/ExplicitBlockArgument
+        connection.exec_params(sb.syntax, sb.params) do |res|
+          yield res
+        end
+        # rubocop:enable Style/ExplicitBlockArgument
+      end
+    end
+  end
+end

data/lib/algebra_db/exec/row_decoder.rb

@@ -0,0 +1,15 @@
+module AlgebraDB
+  module Exec
+    ##
+    # Represents a thing that can decode a row.
+    class RowDecoder
+      def pg_type_map
+        PG::TypeMapAllStrings.new
+      end
+
+      def decode_row(row)
+        row
+      end
+    end
+  end
+end