jaql 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 64c4660a85aa4514e7fc0633577549cc5ed20693
+  data.tar.gz: 89641ea69a7cd69181324701b4c31e38064e912b
+SHA512:
+  metadata.gz: a2dc3820003fce5aca2acc1f3fdea3deb849f97472ffff32f2258363642fe63ed264b650e03e7386dca6b2097167209710172fd62f0e291e54ff1922a978798f
+  data.tar.gz: f60f9b2b3df488299807ae75fe7a281f8eda99045364e7cc2f4346104ec2fe5910dee9a36ce9d45b42c3af603b692261ad520e93f25b01fb3ab450b3b7f22be2

data/.gitignore

@@ -0,0 +1,18 @@
+.ruby-version
+/.idea/
+/vendor/
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+*.bundle
+*.so
+*.o
+*.a
+mkmf.log
+/TODO.txt

data/Gemfile

@@ -0,0 +1,6 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in jaql.gemspec
+gemspec
+
+gem 'dart', path: '../dart'

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2015 Ed Posnak
+
+MIT License
+
+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/README.md

@@ -0,0 +1,32 @@
+# Jaql
+
+JAQL provides fast postgres JSON generation and support for the JSON API Query Language.
+
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'jaql'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install jaql
+
+## Usage
+
+TODO: Write usage instructions here
+
+## Contributing
+
+1. Fork it ( https://github.com/[my-github-username]/jaql/fork )
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create a new Pull Request

data/Rakefile

@@ -0,0 +1,2 @@
+require "bundler/gem_tasks"
+

data/jaql.gemspec

@@ -0,0 +1,29 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'jaql/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "jaql"
+  spec.version       = Jaql::VERSION
+  spec.authors       = ["Ed Posnak"]
+  spec.email         = ["ed.posnak@gmail.com"]
+  spec.summary       = %q{JSON query language in ruby}
+  spec.description   = %q{JSON query language implementation using postgres JSON functions}
+  spec.homepage      = "https://github.com/edposnak"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_dependency 'abstract_method', '~> 1.2'
+
+  spec.add_dependency 'activesupport', '~> 4.2'
+  spec.add_development_dependency 'pg', '~> 0.18'
+  spec.add_dependency 'dart', '~> 0'
+
+  spec.add_development_dependency 'bundler', '~> 1.7'
+  spec.add_development_dependency 'rake', '~> 10.0'
+end

data/lib/jaql.rb

@@ -0,0 +1,21 @@
+require 'abstract_method'
+
+require 'dart' # just brings in core, other resolvers brought in dynamically as needed
+
+require 'jaql/version'
+
+require 'jaql/sql_generation'
+
+require 'jaql/json_string'
+require 'jaql/resource'
+
+
+module Jaql
+
+  module_function
+
+  def resource(scope, options={})
+    Resource.new(scope, options)
+  end
+
+end

data/lib/jaql/json_string.rb

@@ -0,0 +1,27 @@
+module Jaql
+
+  class JSONString
+
+    def initialize(json)
+      raise "#[self.class} initialized with a #{json.class}" unless json.is_a?(String)
+      @json = json
+    end
+
+    # specifying :json format makes Rails and Grape call #to_json on any object it gets back, including JSON
+    # strings, so we just wrap the json in a JSONString that returns it when to_json is called
+    # NB: this method ignores all args and returns the wrapped string as-is
+    def to_json(*args)
+      @json
+    end
+
+    def to_str
+      @json
+    end
+
+    def to_s
+      @json
+    end
+
+  end
+
+end

data/lib/jaql/resource.rb

@@ -0,0 +1,28 @@
+module Jaql
+  # Resource wraps a scope, which can be an ActiveRecord::Relation, Sequel dataset, table name, ORM model instance, etc.
+  # It provides index and show methods that produce JSON for the scope.
+  class Resource
+    attr_reader :scope
+    private :scope
+
+    class NotFoundError < StandardError
+    end
+
+    # TODO infer table from string/symbol, e.g. Jaql.resource(:users).show(params[:query])
+
+    # @param [Hash] options
+    # @param [Object] scope defines the scope to search
+    def initialize(scope, options={})
+      @scope = scope
+    end
+
+    def index(query_spec={})
+      JSONString.new SqlGeneration::RunnableQuery.for(scope, query_spec).json_array
+    end
+
+    def show(query_spec={})
+      JSONString.new SqlGeneration::RunnableQuery.for(scope, query_spec).json_row
+    end
+
+  end
+end

data/lib/jaql/sql_generation.rb

@@ -0,0 +1,14 @@
+require_relative 'sql_generation/field'
+require_relative 'sql_generation/association_sql.rb'
+require_relative 'sql_generation/associated_column_field'
+require_relative 'sql_generation/association_field'
+require_relative 'sql_generation/association_function_field'
+require_relative 'sql_generation/column_field'
+require_relative 'sql_generation/error_field'
+
+require_relative 'sql_generation/query_parsing'
+require_relative 'sql_generation/query'
+require_relative 'sql_generation/runnable_query_factory_methods'
+require_relative 'sql_generation/runnable_query'
+require_relative 'sql_generation/sequel_query'
+require_relative 'sql_generation/active_record_query'

data/lib/jaql/sql_generation/active_record_query.rb

@@ -0,0 +1,18 @@
+module Jaql
+  module SqlGeneration
+    # A RunnableQuery extends Query with the ability to produce JSON from postgres by applying spec to scope
+    class ActiveRecordQuery < RunnableQuery
+      private
+
+      def scope_selected_sql
+        # TODO implement client-supplied scopes (where, order, limit) at outer layer
+        scope.select(fields_sql).to_sql
+      end
+
+      def run(sql_to_run, output_col)
+        scope.connection.execute(sql_to_run).first[output_col.to_s]
+      end
+
+    end
+  end
+end

data/lib/jaql/sql_generation/associated_column_field.rb

@@ -0,0 +1,38 @@
+module Jaql
+  module SqlGeneration
+    # Allows for creation of fields from some column on some association, e.g. creator.last_name
+    class AssociatedColumnField < Field
+      include AssociationSQL
+
+      attr_reader :association, :column_name, :display_name
+      private :association, :column_name, :display_name
+
+      def initialize(association, column_name, display_name=nil, subquery=nil)
+        @association = association
+        @column_name = column_name
+        @display_name = display_name
+        @subquery = subquery
+        @associated_table_alias = subquery.table_name_alias
+      end
+
+      def to_sql
+        [comment_sql, field_sql].join("\n")
+      end
+
+      private
+
+      def comment_sql
+        "-- #{association.associated_table}.#{column_name} (from #{association.type} #{association.name})"
+      end
+
+      def field_sql
+        select_sql = "SELECT #{table_name_sql(association)}.#{quote column_name} AS #{quote(display_name)}"
+        cte = "#{select_sql}\n  #{from_sql(association)}\n  #{scope_sql(association)}"
+
+        # return the column value if the association is *_to_one, otherwise return an array
+        association.to_one? ? "(#{cte})" : "(SELECT array(#{cte}) AS #{display_name})"
+      end
+
+    end
+  end
+end

data/lib/jaql/sql_generation/association_field.rb

@@ -0,0 +1,37 @@
+module Jaql
+  module SqlGeneration
+    class AssociationField < Field
+      include AssociationSQL
+
+      attr_reader :association, :display_name, :subquery
+      private :association, :display_name, :subquery
+
+
+      # e.g. child_undo_broadcast_ass, :child_undo_broadcast_id, json: [:id, :start_time]
+      def initialize(association, display_name=nil, subquery=nil)
+        @association  = association
+        @display_name = display_name
+        @subquery     = subquery
+        @associated_table_alias = subquery.table_name_alias
+      end
+
+      def to_sql
+        [comment_sql, field_sql].join("\n")
+      end
+
+      private
+
+      def comment_sql
+        "-- #{association.type} #{association.name} (#{association.associated_table})"
+      end
+
+      def field_sql
+        select_sql = "SELECT #{subquery.fields_sql}"
+        cte = "#{select_sql}\n  #{from_sql(association)}\n  #{scope_sql(association, subquery.scope_options)}"
+        return_type = association.to_one? ? Query::ROW_RETURN_TYPE : Query::ARRAY_RETURN_TYPE
+        field_sql = subquery.json_sql(cte, display_name || association.name, return_type)
+      end
+
+    end
+  end
+end

data/lib/jaql/sql_generation/association_function_field.rb

@@ -0,0 +1,48 @@
+module Jaql
+  module SqlGeneration
+    # Allows for creation of fields from some column on some association, e.g. creator.last_name
+    class AssociationFunctionField < Field
+
+      include AssociationSQL
+
+      COUNT_FUNCTION = 'count'
+      EXISTS_FUNCTION = 'exists'
+
+      SUPPORTED_FUNCTIONS = [COUNT_FUNCTION, EXISTS_FUNCTION]
+      def self.supports?(function_name)
+        SUPPORTED_FUNCTIONS.include?(function_name.downcase)
+      end
+
+
+      attr_reader :association, :function_name, :display_name
+      private :association, :function_name, :display_name
+
+      def initialize(association, function_name, display_name=nil, subquery=nil)
+        @association = association
+        @function_name = function_name.to_s.downcase
+        @display_name = display_name
+        @subquery = subquery
+        @associated_table_alias = subquery.table_name_alias
+      end
+
+      def to_sql
+        [comment_sql, field_sql].join("\n")
+      end
+
+      private
+
+      def comment_sql
+        "-- #{association.associated_table}.#{function_name} (from #{association.type} #{association.name})"
+      end
+
+      def field_sql
+        case function_name
+        when COUNT_FUNCTION
+          "(SELECT COUNT(*) AS #{quote(display_name)}\n  #{from_sql(association)}\n  #{scope_sql(association)})"
+        when EXISTS_FUNCTION
+          "(SELECT EXISTS (SELECT * #{from_sql(association)}\n  #{scope_sql(association, limit: 1)} ) AS #{quote(display_name)})"
+        end
+      end
+    end
+  end
+end

data/lib/jaql/sql_generation/association_sql.rb

@@ -0,0 +1,79 @@
+module Jaql
+  module SqlGeneration
+    module AssociationSQL
+      # TODO the associations themselves should provide this SQL, and lean on the ORMs and all their nifty features to
+      # produce it. This will address the more complicated :through associations involving long chains of all types of
+      # associations
+
+      # includers must respond_to:
+      # @associated_table_alias
+
+      private
+
+      def table_name_sql(association)
+        quote(@associated_table_alias || association.associated_table)
+      end
+
+      def from_sql(association)
+        ass_table = "#{quote association.associated_table} #{@associated_table_alias ? " #{quote @associated_table_alias}" : ''}"
+        join_table = quote(association.join_table) if is_join?(association)
+        "FROM #{[ass_table, join_table].compact.join(', ')}"
+      end
+
+      def scope_sql(association, options={})
+        ass_scope = association.scope
+        client_scope = options.symbolize_keys
+        sql = "WHERE (#{join_cond_sql(association)})"
+
+        # Client WHERE combines with association WHERE
+        if client_where = client_scope[:where]
+          sql << " AND (#{client_where})"
+        end
+        if ass_where = ass_scope[:where]
+          sql << " AND (#{ass_where})"
+        end
+
+        # Client provided ORDER and LIMIT override that of the association
+        if the_order = client_scope[:order] || ass_scope[:order]
+          sql << " ORDER BY (#{the_order})"
+        end
+
+        if ass_limit = client_scope[:limit] || ass_scope[:limit]
+          sql << " LIMIT (#{ass_limit})"
+        end
+
+        # TODO OFFSET etc.
+        sql
+      end
+
+      # super private
+
+      def is_join?(ass)
+        ass.respond_to?(:join_table)
+      end
+
+      def join_cond_sql(association)
+        if @associated_table_alias
+          # TODO clean up this ugly mess
+          case association
+          when Dart::ManyToManyAssociation
+            *ass_chain, target_ass = association.join_associations
+            ass_chain.map(&method(:join_cond_sql_for_direct)).join(' AND ') + " AND #{join_cond_sql_for_direct(target_ass, nil, @associated_table_alias)}"
+          when Dart::OneToOneAssociation, Dart::OneToManyAssociation
+            join_cond_sql_for_direct(association, @associated_table_alias, nil)
+          when Dart::ManyToOneAssociation
+            join_cond_sql_for_direct(association, nil, @associated_table_alias)
+          end
+        else
+          ass_chain = is_join?(association) ? association.join_associations : [association]
+          ass_chain.map(&method(:join_cond_sql_for_direct)).join(' AND ')
+        end
+      end
+
+      def join_cond_sql_for_direct(ass, child_table_alias=nil, parent_table_alias=nil)
+        "#{quote(child_table_alias || ass.child_table)}.#{quote ass.foreign_key} = #{quote(parent_table_alias || ass.parent_table)}.#{quote ass.primary_key}"
+      end
+
+    end
+  end
+end

data/lib/jaql/sql_generation/column_field.rb

@@ -0,0 +1,17 @@
+module Jaql
+  module SqlGeneration
+    class ColumnField < Field
+      attr_reader :table_name, :column_name, :display_name
+      private :table_name, :column_name, :display_name
+
+      def initialize(table_name, column_name, display_name=nil, subquery_spec=nil)
+        @table_name, @column_name = table_name, column_name
+        @display_name = display_name if column_name != display_name
+      end
+
+      def to_sql
+        "#{quote table_name}.#{quote column_name}#{display_name && " AS #{quote(display_name)}"}"
+      end
+    end
+  end
+end

data/lib/jaql/sql_generation/error_field.rb

@@ -0,0 +1,16 @@
+module Jaql
+  module SqlGeneration
+    class ErrorField < Field
+      attr_reader :message
+
+      def initialize(message)
+        @message = message
+      end
+
+      def to_sql
+        raise message
+      end
+    end
+  end
+end
+

data/lib/jaql/sql_generation/field.rb

@@ -0,0 +1,15 @@
+module Jaql
+  module SqlGeneration
+
+    class Field
+      abstract_method :to_sql
+
+      private
+
+      def quote(id)
+        "\"#{id}\""
+      end
+    end
+
+  end
+end

data/lib/jaql/sql_generation/query.rb

@@ -0,0 +1,78 @@
+module Jaql
+  module SqlGeneration
+    class Query
+      include QueryParsing
+
+      attr_reader :table_name_alias # public
+      attr_reader :run_context, :spec, :resolver
+      private :run_context, :spec, :resolver
+
+      def initialize(run_context, spec, resolver, table_name_alias=nil)
+        @run_context = run_context or fail "#{self.class} must be initialized with a run_context"
+        @resolver = resolver or fail "#{self.class} must be initialized with a resolver"
+        @table_name_alias = table_name_alias
+
+        # TODO deep stringify keys when spec is a hash
+        hash_spec = spec.is_a?(String) ? JSON.parse(spec) : spec || {}
+        validate!(hash_spec)
+        @spec = hash_spec
+      end
+
+      ARRAY_RETURN_TYPE = :array
+      ROW_RETURN_TYPE = :row
+
+      def json_sql(cte, display_name, return_type)
+        display_name or raise "display_name cannot be blank"
+
+        rel = run_context.tmp_relation_name
+        select_sql = case return_type
+                     when ARRAY_RETURN_TYPE
+                       "coalesce(json_agg(#{rel}), '[]'::JSON)"
+                     when ROW_RETURN_TYPE
+                       "row_to_json(#{rel})"
+                       # uncomment this to return {} instead of nil for empty rows
+                       # "coalesce(row_to_json(#{rel}), '{}'::JSON)"
+                     else
+                       fail "unknown return type: '#{return_type}'"
+                     end
+
+        %Q{( SELECT #{select_sql} AS "#{display_name}" FROM (#{cte}) #{rel} )}
+      end
+
+      def json_array_sql(cte, display_name)
+        json_sql(cte, display_name, ARRAY_RETURN_TYPE)
+      end
+
+      def json_row_sql(cte, display_name)
+        json_sql(cte, display_name, ROW_RETURN_TYPE)
+      end
+
+      def fields_sql
+        return "#{query_table_name}.*" if fields.empty?
+
+        fields.map {|field| field.to_sql}.join(",\n")
+      end
+
+      def scope_options
+        spec.slice(*ASSOCIATION_SCOPE_OPTION_KEYS)
+      end
+
+      private
+
+      def query_table_name
+        # defaults to the real table name, overridden by set_table_name
+        @query_table_name ||= @table_name_alias || resolver.table_name
+      end
+
+      def validate!(spec)
+        spec.keys.all? {|k| k.is_a?(String)} or raise "spec containing non-string keys passed to #{self.class}.new. Currently spec must be a JSON hash"
+      end
+
+      def fields
+        @fields ||= parse_fields
+      end
+
+    end
+  end
+
+end

data/lib/jaql/sql_generation/query_parsing.rb

@@ -0,0 +1,92 @@
+module Jaql
+  module SqlGeneration
+    module QueryParsing
+
+      class InvalidQuery < StandardError ; end
+
+      # includers must respond_to:
+      # query_table_name
+
+      private
+
+      # JAQL Protocol
+      # TODO make all of these KEYS case-insensitive
+      JSON_KEY = 'json'.freeze
+      FROM_KEY = 'from'.freeze
+      WHERE_KEY = 'where'.freeze
+      ORDER_KEY = 'order'.freeze
+      LIMIT_KEY = 'limit'.freeze
+      ASSOCIATION_SCOPE_OPTION_KEYS = [WHERE_KEY, ORDER_KEY, LIMIT_KEY]
+
+      # parses a spec into a list of Fields, each of which may contain their own lists of fields
+      def parse_fields
+        result = []
+
+        # TODO allow
+        #   topics: { } # without from or json
+        #   members: { from: :users } # without json
+        if json = spec[JSON_KEY]
+          json.each do |field|
+            case field
+            when String, Symbol
+              result << column_or_association(field)
+            when Hash
+              field.each do |display_name, subquery_or_real_name|
+                case subquery_or_real_name
+                when String, Symbol
+                  real_name = subquery_or_real_name
+                  result << column_or_association(real_name, display_name)
+                when Hash
+                  subquery_spec = subquery_or_real_name
+                  # peek into the subquery to get the real association name if different from display name
+                  if from_name = subquery_spec[FROM_KEY]
+                    ass, col = from_name.split('.')
+                    if col # get the value from ass.col
+                      result << association_column_or_function(ass, col, display_name, subquery_spec)
+                    else # from_name is the name of the column or association
+                      result << column_or_association(from_name, display_name, subquery_spec)
+                    end
+                  else # display_name is the name of the column or association
+                    result << column_or_association(display_name, nil, subquery_spec)
+                  end
+                end
+              end
+            else
+              raise InvalidQuery.new("json field '#{field}' is a #{field.class}")
+            end
+          end
+        end
+
+        result
+      end
+
+      def association_column_or_function(ass_name, col_name, display_name, subquery_spec)
+        if association = resolver.association_for(ass_name)
+          field_class = AssociationFunctionField.supports?(col_name) ? AssociationFunctionField : AssociatedColumnField
+          field_class.new(association, col_name, display_name, build_subquery(association, subquery_spec))
+        else
+          ErrorField.new "unknown association '#{query_table_name}.#{ass_name}' (#{display_name}: #{ass_name}.#{col_name})"
+        end
+
+      end
+
+      def column_or_association(real_name, display_name=nil, subquery_spec=nil)
+        if column_name = resolver.column_for(real_name)
+          ColumnField.new(query_table_name, column_name, display_name)
+        elsif association = resolver.association_for(real_name)
+          AssociationField.new(association, display_name, build_subquery(association, subquery_spec))
+        else
+          ErrorField.new "unknown column or association '#{query_table_name}.#{real_name}' (#{display_name})"
+        end
+      end
+
+      def build_subquery(association, subquery_spec)
+        new_resolver = resolver.build_from_association(association)
+        # TODO alias any join tables in the association that are the same as resolver.table_name
+        table_alias = "#{association.associated_table}_#{run_context.tmp_relation_name}" if association.associated_table == resolver.table_name
+        Query.new(run_context, subquery_spec, new_resolver, table_alias)
+      end
+
+    end
+  end
+end

data/lib/jaql/sql_generation/runnable_query.rb

@@ -0,0 +1,53 @@
+module Jaql
+  module SqlGeneration
+    # A RunnableQuery extends Query with the ability to produce JSON from postgres by applying spec to scope
+    class RunnableQuery < Query
+      extend RunnableQueryFactoryMethods
+
+      abstract_method :scope_selected_sql, :run
+
+      attr_reader :scope
+      private :scope
+
+      def initialize(scope, spec, resolver)
+        @scope = scope
+
+        super(Context.new, spec, resolver)
+      end
+
+      # Run the query and produce JSON
+      JSON_RESULT_COL_NAME = 'json_data'.freeze
+
+      def json_array
+        run_returning ARRAY_RETURN_TYPE
+      end
+
+      def json_row
+        run_returning ROW_RETURN_TYPE
+      end
+
+      def run_returning(return_type)
+        select_sql = scope_selected_sql
+
+        sql_to_run = json_sql(select_sql, JSON_RESULT_COL_NAME, return_type)
+        puts "\n\n****************************** sql_to_run:\n#{sql_to_run} \n"
+        run(sql_to_run, JSON_RESULT_COL_NAME)
+      end
+
+      # The context of a particular run
+      # Currently just a temporary relation name generator
+      class Context
+        def initialize(prefix=nil)
+          @prefix       = prefix || 'r'
+          @relation_num = 0
+        end
+
+        def tmp_relation_name()
+          @relation_num += 1
+          "#{@prefix}#{@relation_num}"
+        end
+      end
+    end
+
+  end
+end

data/lib/jaql/sql_generation/runnable_query_factory_methods.rb

@@ -0,0 +1,58 @@
+module Jaql
+  module SqlGeneration
+    module RunnableQueryFactoryMethods
+      def for(scope, query_spec)
+        scope_class = scope.class
+
+        case scope_class.name
+
+        when 'Sequel::Postgres::Dataset'
+          if scope.respond_to?(:model) # Sequel::Postgres::Dataset with Sequel::Model
+            sequel_model_query(scope, query_spec, scope.model)
+          else # Sequel::Postgres::Dataset (no model)
+            sequel_table_query(scope, query_spec, scope.first_source)
+          end
+
+        when 'ActiveRecord::Relation'
+          active_record_model_query(scope, query_spec, scope.klass)
+
+        else # could be an ORM model instance
+          if scope_class.ancestors.map(&:name).include?('Sequel::Model')
+            sequel_model_query(scope, query_spec, scope_class)
+          elsif scope_class.ancestors.map(&:name).include?('ActiveRecord::Base')
+            active_record_model_query(scope, query_spec, scope_class)
+          else
+            fail "cannot determine resolver for scope with type '#{scope_class}'"
+          end
+        end
+      end
+
+      private
+
+      def active_record_model_query(scope, query_spec, model)
+        unless defined?(Dart::Reflection::ActiveRecordModel::Resolver)
+          require 'dart/active_record_model_reflection'
+        end
+        resolver = Dart::Reflection::ActiveRecordModel::Resolver.new(model)
+        ActiveRecordQuery.new(scope, query_spec, resolver)
+      end
+
+      def sequel_table_query(scope, query_spec, table)
+        unless defined?(Dart::Reflection::SequelTable::Resolver)
+          require 'dart/sequel_table_reflection'
+        end
+        resolver = Dart::Reflection::SequelTable::Resolver.new(table)
+        SequelQuery.new(scope, query_spec, resolver)
+      end
+
+      def sequel_model_query(scope, query_spec, model)
+        unless defined?(Dart::Reflection::SequelModel::Resolver)
+          require 'dart/sequel_model_reflection'
+        end
+        resolver = Dart::Reflection::SequelModel::Resolver.new(model)
+        SequelQuery.new(scope, query_spec, resolver)
+      end
+
+    end
+  end
+end

data/lib/jaql/sql_generation/sequel_query.rb

@@ -0,0 +1,17 @@
+module Jaql
+  module SqlGeneration
+    class SequelQuery < RunnableQuery
+      private
+
+      def scope_selected_sql
+        # TODO implement client-supplied scopes (where, order, limit) at outer layer
+        scope.select(Sequel.lit(fields_sql)).sql
+      end
+
+      def run(sql_to_run, output_col)
+        scope.db[sql_to_run].first[output_col.to_sym]
+      end
+
+    end
+  end
+end

data/lib/jaql/version.rb

@@ -0,0 +1,3 @@
+module Jaql
+  VERSION = "0.0.1"
+end

metadata

@@ -0,0 +1,152 @@
+--- !ruby/object:Gem::Specification
+name: jaql
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Ed Posnak
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-05-11 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: abstract_method
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.2'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.2'
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4.2'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4.2'
+- !ruby/object:Gem::Dependency
+  name: pg
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.18'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.18'
+- !ruby/object:Gem::Dependency
+  name: dart
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.7'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.7'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+description: JSON query language implementation using postgres JSON functions
+email:
+- ed.posnak@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- jaql.gemspec
+- lib/jaql.rb
+- lib/jaql/json_string.rb
+- lib/jaql/resource.rb
+- lib/jaql/sql_generation.rb
+- lib/jaql/sql_generation/active_record_query.rb
+- lib/jaql/sql_generation/associated_column_field.rb
+- lib/jaql/sql_generation/association_field.rb
+- lib/jaql/sql_generation/association_function_field.rb
+- lib/jaql/sql_generation/association_sql.rb
+- lib/jaql/sql_generation/column_field.rb
+- lib/jaql/sql_generation/error_field.rb
+- lib/jaql/sql_generation/field.rb
+- lib/jaql/sql_generation/query.rb
+- lib/jaql/sql_generation/query_parsing.rb
+- lib/jaql/sql_generation/runnable_query.rb
+- lib/jaql/sql_generation/runnable_query_factory_methods.rb
+- lib/jaql/sql_generation/sequel_query.rb
+- lib/jaql/version.rb
+homepage: https://github.com/edposnak
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.4.5
+signing_key: 
+specification_version: 4
+summary: JSON query language in ruby
+test_files: []