prequel 0.0.1

data/LICENSE

@@ -0,0 +1,19 @@
+Copyright (C) 2011 by Nathan Sobo
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/lib/prequel.rb

@@ -0,0 +1,38 @@
+require 'active_support/all'
+require 'sequel'
+require 'prequel/version'
+
+module Prequel
+  extend ActiveSupport::Autoload
+  extend self
+
+  def const_missing(name)
+    if name == :DB
+      const_set(:DB, Sequel::DATABASES.first)
+    else
+      super
+    end
+  end
+
+  def table(name, &block)
+    Relations::Table.new(name, &block)
+  end
+
+  def session
+    Thread.current[:prequel_session] ||= Session.new
+  end
+
+  def clear_session
+    Thread.current[:prequel_session] = nil if Thread.current[:prequel_session]
+  end
+
+  require 'prequel/core_extensions'
+  autoload :CompositeTuple
+  autoload :Expressions
+  autoload :Field
+  autoload :Record
+  autoload :Relations
+  autoload :Session
+  autoload :Sql
+  autoload :Tuple
+end

data/lib/prequel/composite_tuple.rb

@@ -0,0 +1,33 @@
+module Prequel
+  class CompositeTuple
+    attr_reader :left, :right
+
+    def initialize(left, right)
+      @left, @right = left, right
+    end
+
+    def [](name)
+      get_record(name) || get_field_value(name)
+    end
+
+    def get_record(table_name)
+      left.get_record(table_name) || right.get_record(table_name)
+    end
+
+    def get_field_value(name)
+      if name =~ /(.+)__(.+)/
+        table_name = $1.to_sym
+        field_name = $2.to_sym
+        get_record(table_name).try(:get_field_value, field_name)
+      else
+        left.get_field_value(name) || right.get_field_value(name)
+      end
+    end
+
+    def field_values
+      [left.field_values, right.field_values]
+    end
+
+    delegate :inspect, :to => :field_values
+  end
+end

data/lib/prequel/core_extensions.rb

@@ -0,0 +1,62 @@
+module Prequel
+  module HashExtensions
+    def to_predicate
+      raise NotImplementedError unless size == 1
+      keys.first.eq(values.first)
+    end
+
+    Hash.send(:include, self)
+  end
+
+  module SymbolExtensions
+    def as(alias_name)
+      "#{self}___#{alias_name}".to_sym
+    end
+
+    def eq(other)
+      Expressions::Equal.new(self, other)
+    end
+
+    def count
+      Expressions::SetFunction.new(self, :count)
+    end
+
+    def resolve_in_relations(relations)
+      if self =~ /^(.+)___(.+)$/
+        column_name = $1.to_sym
+        alias_name = $2.to_sym
+        Expressions::AliasedExpression.new(column_name, alias_name).resolve_in_relations(relations)
+      else
+        relations.each do |relation|
+          if column = relation.get_column(self)
+            return column
+          end
+        end
+        nil
+      end
+    end
+
+    def to_sql
+      inspect
+    end
+
+    Symbol.send(:include, self)
+  end
+
+  module PrimitiveExtensions
+    def resolve_in_relations(relations)
+      self
+    end
+
+    def resolve_in_query(query)
+      query.add_literal(self)
+    end
+
+    Numeric.send(:include, self)
+    String.send(:include, self)
+    TrueClass.send(:include, self)
+    FalseClass.send(:include, self)
+    NilClass.send(:include, self)
+    Time.send(:include, self)
+  end
+end

data/lib/prequel/expressions.rb

@@ -0,0 +1,12 @@
+module Prequel
+  module Expressions
+    extend ActiveSupport::Autoload
+
+    autoload :AliasedExpression
+    autoload :Column
+    autoload :DerivedColumn
+    autoload :Equal
+    autoload :Expression
+    autoload :SetFunction
+  end
+end

data/lib/prequel/expressions/aliased_expression.rb

@@ -0,0 +1,15 @@
+module Prequel
+  module Expressions
+    class AliasedExpression
+      attr_reader :expression, :alias_name
+
+      def initialize(expression, alias_name)
+        @expression, @alias_name = expression, alias_name
+      end
+
+      def resolve_in_relations(relations)
+        AliasedExpression.new(expression.resolve_in_relations(relations), alias_name)
+      end
+    end
+  end
+end

data/lib/prequel/expressions/column.rb

@@ -0,0 +1,35 @@
+module Prequel
+  module Expressions
+    class Column
+      attr_reader :table, :name, :type
+
+      def initialize(table, name, type)
+        @table, @name, @type = table, name, type
+      end
+
+      def alias_name
+        nil
+      end
+
+      def eq(other)
+        Equal.new(self, other)
+      end
+
+      def qualified_name
+        "#{table.name}__#{name}".to_sym
+      end
+
+      def expression
+        self
+      end
+
+      def origin
+        self
+      end
+
+      def resolve_in_query(query)
+        query.singular_table_refs[table].resolve_column(self)
+      end
+    end
+  end
+end

data/lib/prequel/expressions/derived_column.rb

@@ -0,0 +1,24 @@
+module Prequel
+  module Expressions
+    class DerivedColumn
+      attr_reader :relation, :expression, :alias_name
+      delegate :origin, :to => :expression
+
+      def initialize(relation, expression, alias_name)
+        @relation, @expression, @alias_name = relation, expression, alias_name
+      end
+
+      def name
+        alias_name || expression.name
+      end
+
+      def resolve_in_query(query)
+        if subquery = query.singular_table_refs[relation]
+          subquery.resolve_derived_column(self)
+        else
+          expression.resolve_in_query(query)
+        end
+      end
+    end
+  end
+end

data/lib/prequel/expressions/equal.rb

@@ -0,0 +1,22 @@
+module Prequel
+  module Expressions
+    class Equal
+      attr_reader :left, :right
+      def initialize(left, right)
+        @left, @right = left, right
+      end
+      
+      def resolve_in_relations(relations)
+        Equal.new(left.resolve_in_relations(relations), right.resolve_in_relations(relations))
+      end
+
+      def resolve_in_query(query)
+        Equal.new(left.resolve_in_query(query), right.resolve_in_query(query))
+      end
+
+      def to_sql
+        "#{left.to_sql} = #{right.to_sql}"
+      end
+    end
+  end
+end

data/lib/prequel/expressions/expression.rb

@@ -0,0 +1,10 @@
+module Prequel
+  module Expressions
+    class Expression
+      def as(alias_name)
+        AliasedExpression.new(self, alias_name)
+      end
+    end
+  end
+end
+

data/lib/prequel/expressions/set_function.rb

@@ -0,0 +1,24 @@
+module Prequel
+  module Expressions
+    class SetFunction < Expression
+      attr_reader :expression, :type
+
+      def initialize(expression, type)
+        @expression, @type = expression, type
+      end
+
+      def resolve_in_relations(relations)
+        SetFunction.new(expression.resolve_in_relations(relations), type)
+      end
+
+      def resolve_in_query(query)
+        SetFunction.new(expression.resolve_in_query(query), type)
+      end
+
+      def to_sql
+        "#{type}(#{expression.to_sql})"
+      end
+    end
+  end
+end
+

data/lib/prequel/field.rb

@@ -0,0 +1,10 @@
+module Prequel
+  class Field
+    attr_reader :tuple, :column
+    attr_accessor :value
+
+    def initialize(tuple, column)
+      @tuple, @column = tuple, column
+    end
+  end
+end

data/lib/prequel/record.rb

@@ -0,0 +1,50 @@
+module Prequel
+  class Record < Tuple
+    class << self
+      delegate :all, :result_set, :[], :to_sql, :get_column, :first, :find, :where, :join, :project, :to => :relation
+
+      def table
+        relation
+      end
+
+      def to_relation
+        relation
+      end
+
+      def inherited(klass)
+        table_name = klass.name.demodulize.underscore.pluralize.to_sym
+        klass.relation = Relations::Table.new(table_name, klass)
+      end
+
+      def def_field_accessor(name)
+        def_field_reader(name)
+        def_field_writer(name)
+      end
+
+      def def_field_writer(name)
+        define_method("#{name}=") do |value|
+          set_field_value(name, value)
+        end
+      end
+
+      def column(name, type)
+        relation.def_column(name, type)
+        def_field_accessor(name)
+      end
+
+      def new(field_values={})
+        Prequel.session[table.name][field_values[:id]] ||= super
+      end
+    end
+
+    def table
+      relation
+    end
+
+    public :set_field_value
+
+    def get_record(table_name)
+      self if table_name == table.name
+    end
+  end
+end

data/lib/prequel/relations.rb

@@ -0,0 +1,11 @@
+module Prequel
+  module Relations
+    extend ActiveSupport::Autoload
+
+    autoload :InnerJoin
+    autoload :Projection
+    autoload :Relation
+    autoload :Selection
+    autoload :Table
+  end
+end

data/lib/prequel/relations/inner_join.rb

@@ -0,0 +1,39 @@
+module Prequel
+  module Relations
+    class InnerJoin < Relation
+      attr_reader :left, :right, :predicate
+
+      def initialize(left_operand, right_operand, predicate)
+        @left, @right = left_operand.to_relation, right_operand.to_relation
+        @predicate = resolve(predicate.to_predicate)
+      end
+
+      def get_table(name)
+        left.get_table(name) || right.get_table(name)
+      end
+
+      def columns
+        (left.columns + right.columns).map do |column|
+          derive(column)
+        end
+      end
+
+      def visit(query)
+        query.table_ref = table_ref(query)
+        query.select_list = columns.map do |derived_column|
+          query.resolve_derived_column(derived_column, :qualified)
+        end
+      end
+
+      def table_ref(query)
+        Sql::InnerJoinedTableRef.new(left.table_ref(query), right.singular_table_ref(query), predicate.resolve_in_query(query))
+      end
+
+      protected
+
+      def operands
+        [left, right]
+      end
+    end
+  end
+end

data/lib/prequel/relations/projection.rb

@@ -0,0 +1,86 @@
+module Prequel
+  module Relations
+    class Projection < Relation
+      attr_reader :operand
+
+      def initialize(operand, *symbols)
+        @operand = operand
+        assign_derived_columns(symbols)
+      end
+
+      def get_column(name)
+        if name.to_s.include?("__")
+          super
+        else
+          derived_columns_by_name[name]
+        end
+      end
+
+      def columns
+        derived_columns.values
+      end
+
+      def visit(query)
+        operand.visit(query)
+        query.select_list = columns.map do |derived_column|
+          query.resolve_derived_column(derived_column)
+        end
+
+        if projected_table
+          query.tuple_builder = query.singular_table_refs[projected_table]
+        else
+          query.tuple_builder = self
+        end
+      end
+
+      def build_tuple(field_values)
+        tuple_class.new(field_values)
+      end
+
+      def tuple_class
+        @tuple_class ||= Class.new(Tuple).tap do |tuple_class|
+          tuple_class.relation = self
+          columns.each do |column|
+            tuple_class.def_field_reader(column.name)
+          end
+        end
+      end
+
+      protected
+      attr_reader :projected_table
+
+      def assign_derived_columns(expressions)
+        if @projected_table = detect_projected_table(expressions)
+          projected_table.columns.map do |column|
+            derive(resolve(column.qualified_name.as(column.name)))
+          end
+        else
+          expressions.each do |column_name|
+            derive(resolve(column_name))
+          end
+        end
+      end
+
+      def detect_projected_table(args)
+        return false unless args.size == 1
+        arg = args.first
+        if arg.instance_of?(Table)
+          table_name = arg.name
+        elsif arg.instance_of?(Class) && arg.respond_to?(:table)
+          table_name = arg.table.name
+        elsif arg.instance_of?(Symbol)
+          return false if arg =~ /__/
+          table_name = arg
+        else
+          return false
+        end
+
+        operand.get_table(table_name)
+      end
+
+      def operands
+        [operand]
+      end
+    end
+  end
+end

data/lib/prequel/relations/relation.rb

@@ -0,0 +1,71 @@
+module Prequel
+  module Relations
+    class Relation
+      delegate :to_sql, :result_set, :all, :first, :to => :query
+
+      def query
+        Sql::Query.new(self).build
+      end
+
+      def find(id)
+        where(:id => id).first
+      end
+
+      def where(predicate)
+        Selection.new(self, predicate)
+      end
+
+      def join(right, predicate)
+        InnerJoin.new(self, right, predicate)
+      end
+
+      def project(*symbols)
+        Projection.new(self, *symbols)
+      end
+
+      def table_ref(query)
+        singular_table_ref(query)
+      end
+
+      def singular_table_ref(query)
+        query.add_subquery(self)
+      end
+
+      def to_relation
+        self
+      end
+
+      def get_column(name)
+        resolved = resolve(name)
+        derive(resolved) if resolved
+      end
+
+      protected
+
+      def resolve(expression)
+        expression.resolve_in_relations(operands)
+      end
+
+      def derive(resolved_expression)
+        if resolved_expression.instance_of?(Expressions::AliasedExpression)
+          alias_name = resolved_expression.alias_name
+          resolved_expression = resolved_expression.expression
+        end
+
+          derived_columns[resolved_expression] ||=
+          Expressions::DerivedColumn.new(self, resolved_expression, alias_name).tap do |derived_column|
+            derived_columns[resolved_expression] = derived_column
+            derived_columns_by_name[derived_column.name] = derived_column
+          end
+      end
+
+      def derived_columns
+        @derived_columns ||= {}
+      end
+
+      def derived_columns_by_name
+        @derived_columns_by_name ||= {}
+      end
+    end
+  end
+end

data/lib/prequel/relations/selection.rb

@@ -0,0 +1,31 @@
+module Prequel
+  module Relations
+    class Selection < Relation
+      attr_reader :operand, :predicate
+
+      def initialize(operand, predicate)
+        @operand = operand
+        @predicate = resolve(predicate.to_predicate)
+      end
+
+      delegate :get_table, :to => :operand
+
+      def columns
+        operand.columns.map do |column|
+          derive(column)
+        end
+      end
+
+      def visit(query)
+        operand.visit(query)
+        query.add_condition(predicate.resolve_in_query(query))
+      end
+
+      protected
+
+      def operands
+        [operand]
+      end
+    end
+  end
+end

data/lib/prequel/relations/table.rb

@@ -0,0 +1,56 @@
+module Prequel
+  module Relations
+    class Table < Relation
+      attr_reader :name, :columns_by_name, :tuple_class
+
+      def initialize(name, tuple_class=nil, &block)
+        @name, @tuple_class = name, tuple_class
+        @columns_by_name = {}
+        TableDefinitionContext.new(self).instance_eval(&block) if block
+      end
+
+      def def_column(name, type)
+        columns_by_name[name] = Expressions::Column.new(self, name, type)
+      end
+
+      def [](col_name)
+        "#{name}__#{col_name}".to_sym
+      end
+
+      def get_column(column_name)
+        if column_name.match(/(.+)__(.+)/)
+          qualifier, column_name = $1.to_sym, $2.to_sym
+          return nil unless qualifier == name
+        end
+        columns_by_name[column_name]
+      end
+
+      def get_table(table_name)
+        self if name == table_name
+      end
+
+      def columns
+        columns_by_name.values
+      end
+
+      def visit(query)
+        query.table_ref = table_ref(query)
+      end
+
+      def singular_table_ref(query)
+        query.add_singular_table_ref(self, Sql::TableRef.new(self))
+      end
+
+      class TableDefinitionContext
+        attr_reader :table
+        def initialize(table)
+          @table = table
+        end
+
+        def column(name, type)
+          table.def_column(name, type)
+        end
+      end
+    end
+  end
+end

data/lib/prequel/session.rb

@@ -0,0 +1,12 @@
+module Prequel
+  class Session
+    def initialize
+      @identity_map = Hash.new {|h,k| h[k] = {}}
+    end
+
+    delegate :[], :[]=, :to => :identity_map
+
+    protected
+    attr_reader :identity_map
+  end
+end

data/lib/prequel/sql.rb

@@ -0,0 +1,13 @@
+module Prequel
+  module Sql
+    extend ActiveSupport::Autoload
+
+    autoload :DerivedQueryColumn
+    autoload :InnerJoinedTableRef
+    autoload :NamedTableRef
+    autoload :Query
+    autoload :QueryColumn
+    autoload :Subquery
+    autoload :TableRef
+  end
+end

data/lib/prequel/sql/derived_query_column.rb

@@ -0,0 +1,23 @@
+module Prequel
+  module Sql
+    class DerivedQueryColumn
+      attr_reader :subquery, :name, :expression
+
+      def initialize(subquery, name, expression)
+        @subquery, @name, @expression = subquery, name, expression
+      end
+
+      def to_sql
+        "#{subquery.name}.#{name}"
+      end
+
+      def to_select_clause_sql
+        "#{expression.to_sql} as #{name}"
+      end
+
+      def qualified_name
+        "#{subquery.name}__#{name}"
+      end
+    end
+  end
+end

data/lib/prequel/sql/inner_joined_table_ref.rb

@@ -0,0 +1,23 @@
+module Prequel
+  module Sql
+    class InnerJoinedTableRef
+      attr_reader :left, :right, :predicate
+      def initialize(left, right, predicate)
+        @left, @right, @predicate = left, right, predicate
+      end
+
+      def to_sql
+        [left.to_sql,
+         'inner join',
+         right.to_sql,
+         'on',
+         predicate.to_sql
+        ].join(' ')
+      end
+
+      def build_tuple(field_values)
+        CompositeTuple.new(left.build_tuple(field_values), right.build_tuple(field_values))
+      end
+    end
+  end
+end

data/lib/prequel/sql/named_table_ref.rb

@@ -0,0 +1,19 @@
+module Prequel
+  module Sql
+    module NamedTableRef
+      protected
+
+      def extract_field_values(field_values)
+        {}.tap do |specific_field_values|
+          field_values.each do |field_name, value|
+            if field_name =~ /(.+?)__(.+)/
+              qualifier, field_name = $1.to_sym, $2.to_sym
+              next unless qualifier == name
+            end
+            specific_field_values[field_name] = value
+          end
+        end
+      end
+    end
+  end
+end

data/lib/prequel/sql/query.rb

@@ -0,0 +1,110 @@
+module Prequel
+  module Sql
+    class Query
+      attr_accessor :select_list
+      attr_reader :relation, :table_ref, :conditions, :literals, :singular_table_refs, :subquery_count, :query_columns
+      attr_writer :tuple_builder
+
+      def initialize(relation)
+        @relation = relation
+        @conditions = []
+        @literals = {}
+        @singular_table_refs = { relation => self }
+        @subquery_count = 0
+        @query_columns = {}
+      end
+
+      def all
+        result_set.map do |field_values|
+          tuple_builder.build_tuple(field_values)
+        end
+      end
+
+      def first
+        r = result_set
+        r.empty?? nil : tuple_builder.build_tuple(r.first)
+      end
+
+      def result_set
+        DB[*to_sql]
+      end
+
+      def to_sql
+        [sql_string, literals]
+      end
+
+      def build
+        relation.visit(self)
+        self
+      end
+
+      def table_ref=(table_ref)
+        raise "A table ref has already been assigned" if @table_ref
+        @table_ref = table_ref
+      end
+
+      def add_condition(predicate)
+        conditions.push(predicate)
+      end
+
+      def add_literal(literal)
+        "v#{literals.size + 1}".to_sym.tap do |placeholder|
+          literals[placeholder] = literal
+        end
+      end
+
+      def add_singular_table_ref(relation, table_ref)
+        singular_table_refs[relation] = table_ref
+      end
+
+      def add_subquery(relation)
+        @subquery_count += 1
+        subquery = Subquery.new(self, relation, "t#{subquery_count}".to_sym)
+        add_singular_table_ref(relation, subquery)
+        subquery.build
+      end
+
+      def resolve_derived_column(column, qualified=false)
+        query_columns[column] ||= begin
+          resolved_expression = column.expression.resolve_in_query(self)
+          resolved_name = qualified ? resolved_expression.qualified_name : column.name
+          Sql::DerivedQueryColumn.new(self, resolved_name, resolved_expression)
+        end
+      end
+
+      def tuple_builder
+        @tuple_builder || table_ref
+      end
+
+      protected
+
+      def sql_string
+        ["select",
+          select_clause_sql,
+          "from",
+          from_clause_sql,
+          where_clause_sql,
+        ].compact.join(" ")
+      end
+
+      def select_clause_sql
+        if select_list
+          select_list.map {|column| column.to_select_clause_sql}.join(', ')
+        else
+          '*'
+        end
+      end
+
+      def from_clause_sql
+        table_ref.to_sql
+      end
+
+      def where_clause_sql
+        return nil if conditions.empty?
+        'where ' + conditions.map do |condition|
+          condition.to_sql
+        end.join(' and ')
+      end
+    end
+  end
+end

data/lib/prequel/sql/query_column.rb

@@ -0,0 +1,22 @@
+module Prequel
+  module Sql
+    class QueryColumn
+      attr_reader :table_ref, :name
+      def initialize(table_ref, name)
+        @table_ref, @name = table_ref, name
+      end
+
+      def to_sql
+        "#{table_ref.name}.#{name}"
+      end
+
+      def to_select_clause_sql
+        to_sql
+      end
+
+      def qualified_name
+        "#{table_ref.name}__#{name}"
+      end
+    end
+  end
+end

data/lib/prequel/sql/subquery.rb

@@ -0,0 +1,25 @@
+module Prequel
+  module Sql
+    class Subquery < Query
+      include NamedTableRef
+
+      attr_reader :parent, :relation, :name
+      delegate :columns, :to => :relation
+
+      def initialize(parent, relation, name)
+        @parent, @name = parent, name
+        super(relation)
+      end
+
+      delegate :add_literal, :add_singular_table_ref, :add_subquery, :singular_table_refs, :to => :parent
+
+      def to_sql
+        ['(', sql_string, ') as ', name].join
+      end
+
+      def build_tuple(field_values)
+        tuple_builder.build_tuple(extract_field_values(field_values))
+      end
+    end
+  end
+end

data/lib/prequel/sql/table_ref.rb

@@ -0,0 +1,26 @@
+module Prequel
+  module Sql
+    class TableRef
+      include NamedTableRef
+      attr_reader :relation, :query_columns
+      delegate :name, :columns, :tuple_class, :to => :relation
+
+      def initialize(relation)
+        @relation = relation
+        @query_columns = {}
+      end
+
+      def to_sql
+        name
+      end
+
+      def resolve_column(column)
+        query_columns[column] ||= Sql::QueryColumn.new(self, column.name)
+      end
+
+      def build_tuple(field_values)
+        tuple_class.new(extract_field_values(field_values))
+      end
+    end
+  end
+end

data/lib/prequel/tuple.rb

@@ -0,0 +1,64 @@
+module Prequel
+  class Tuple
+    class_attribute :relation
+
+    class << self
+      delegate :columns, :to => :relation
+
+      def def_field_reader(name)
+        define_method(name) do
+          get_field_value(name)
+        end
+      end
+    end
+
+    def initialize(values = {})
+      initialize_fields
+      soft_update_fields(values)
+    end
+
+    delegate :columns, :to => :relation
+
+    def soft_update_fields(values)
+      values.each do |name, value|
+        set_field_value(name, value)
+      end
+    end
+
+    def get_field_value(name)
+      fields_by_name[name].try(:value)
+    end
+
+    def field_values
+      fields_by_name.inject({}) do |h, (name, field)|
+        h[name] = field.value
+        h
+      end
+    end
+
+    def get_record(name)
+      nil
+    end
+
+    delegate :inspect, :to => :field_values
+
+    protected
+    attr_reader :fields_by_name
+
+    def initialize_fields
+      @fields_by_name = {}
+      columns.each do |column|
+        fields_by_name[column.name] = Field.new(self, column)
+      end
+    end
+
+    def set_field_value(name, value)
+      field = fields_by_name[name]
+      unless field
+        raise "No field found #{name.inspect}"
+      end
+      field.value = value
+    end
+  end
+end
+

data/lib/prequel/version.rb

@@ -0,0 +1,3 @@
+module Prequel
+  VERSION = "0.0.1" unless defined?(::Prequel::VERSION)
+end

metadata

@@ -0,0 +1,119 @@
+--- !ruby/object:Gem::Specification 
+name: prequel
+version: !ruby/object:Gem::Version 
+  prerelease: 
+  version: 0.0.1
+platform: ruby
+authors: 
+- Nathan Sobo
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-03-03 00:00:00 -08:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: activesupport
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 3.0.4
+  type: :runtime
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: sequel
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 3.20.0
+  type: :runtime
+  version_requirements: *id002
+- !ruby/object:Gem::Dependency 
+  name: rspec
+  prerelease: false
+  requirement: &id003 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+  type: :development
+  version_requirements: *id003
+description: Prequel is the database library I've always wanted.
+email: 
+- nathansobo@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- lib/prequel/composite_tuple.rb
+- lib/prequel/core_extensions.rb
+- lib/prequel/expressions/aliased_expression.rb
+- lib/prequel/expressions/column.rb
+- lib/prequel/expressions/derived_column.rb
+- lib/prequel/expressions/equal.rb
+- lib/prequel/expressions/expression.rb
+- lib/prequel/expressions/set_function.rb
+- lib/prequel/expressions.rb
+- lib/prequel/field.rb
+- lib/prequel/record.rb
+- lib/prequel/relations/inner_join.rb
+- lib/prequel/relations/projection.rb
+- lib/prequel/relations/relation.rb
+- lib/prequel/relations/selection.rb
+- lib/prequel/relations/table.rb
+- lib/prequel/relations.rb
+- lib/prequel/session.rb
+- lib/prequel/sql/derived_query_column.rb
+- lib/prequel/sql/inner_joined_table_ref.rb
+- lib/prequel/sql/named_table_ref.rb
+- lib/prequel/sql/query.rb
+- lib/prequel/sql/query_column.rb
+- lib/prequel/sql/subquery.rb
+- lib/prequel/sql/table_ref.rb
+- lib/prequel/sql.rb
+- lib/prequel/tuple.rb
+- lib/prequel/version.rb
+- lib/prequel.rb
+- LICENSE
+- README.md
+has_rdoc: true
+homepage: http://github.com/nathansobo/prequel
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.5.2
+signing_key: 
+specification_version: 3
+summary: A ground-up relational algebraic ORM.
+test_files: []
+