pgsnap 1.0.0.beta.10

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: f23fdcee25f7ea505b0c471fe2757ad29d6a95491e1a952bd9d86dd517ded524
+  data.tar.gz: 6186c19247c3b871c57a1fce5a71bce1789960167643001bfe041d6e8627b89b
+SHA512:
+  metadata.gz: ab23995a482352b22bfa5564fa30faff1ba57f548f8a4bbad379cd7ebc6078bc562ec12c9660976a6172c2af44cb1b46778fbf1de58622c1a0ccd7c072018b56
+  data.tar.gz: 1d10672e506a839f9cbb84116faa216dee1dedef87ada3fe62cb42e3fdea5e9599d541e37fce097e074d1d2f390fead27916156a32af214fb4dbf221452eb8d8

data/.gitignore

@@ -0,0 +1,8 @@
+/.bundle/
+/.yardoc
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/

data/.reek.yml

@@ -0,0 +1,11 @@
+---
+detectors:
+  IrresponsibleModule:
+    enabled: false
+
+directories:
+  test:
+    InstanceVariableAssumption:
+      enabled: false
+    UncommunicativeMethodName:
+      enabled: false

data/.rubocop.yml

@@ -0,0 +1,14 @@
+AllCops:
+  Exclude:
+    - bin/**/*
+    - Gemfile
+    - Guardfile
+    - Rakefile
+    - '*.gemspec'
+  TargetRubyVersion: 2.5.3
+
+Style/Documentation:
+  Enabled: false
+
+Metrics/LineLength:
+  Max: 80

data/.ruby-version

@@ -0,0 +1 @@
+2.5.3

data/.travis.yml

@@ -0,0 +1,7 @@
+---
+sudo: false
+language: ruby
+cache: bundler
+rvm:
+  - 2.5.3
+before_install: gem install bundler -v 1.17.1

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2018 David Chin
+
+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,40 @@
+Construct composable, structured, PostgreSQL queries in plain Ruby.
+
+## Configure database connection
+
+In a configuration file, named `config.rb` for example:
+
+```ruby
+module Queries
+  Pgsnap.set_configuration do |config|
+    config.dbname = 'your_db_name_here'
+  end
+
+  class Config < Pgsnap::Query; end
+end
+```
+
+Inherit the configuration file in your query, named `query_for_one.rb`
+for example:
+
+```ruby
+module Queries
+  class Hello < Queries::Config
+    def select_list
+      select_list_item %('hello'), :greeting
+    end
+  end
+end
+```
+
+Try it out in the console:
+
+```ruby
+pry(main)> q = Queries::Hello.new
+pry(main)> q.result
+#=> ["hello"]
+pry(main)> q.columns
+#=> [:greeting]
+pry(main)> q.json
+#=> [{"greeting"=>"hello"}]
+```

data/lib/pgsnap.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+require 'pgsnap/version'
+
+require 'pgsnap/configuration'
+
+require 'pgsnap/utils'
+
+require 'pgsnap/connection'
+require 'pgsnap/base_table'
+require 'pgsnap/nested_json'
+require 'pgsnap/pg_result'
+require 'pgsnap/select_command'
+require 'pgsnap/query'
+require 'pgsnap/table_columns_cache'
+
+module Pgsnap
+  class Error < StandardError; end
+
+  Pgsnap.set_configuration do |config|
+    config.dbname = 'pgsnap'
+  end
+end

data/lib/pgsnap/base_table.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module Pgsnap
+  class BaseTable
+    attr_reader :table_name
+
+    def initialize(table_name:)
+      @table_name = table_name.to_sym
+    end
+
+    def columns
+      cached_columns || Pgsnap::TableColumnsCache.set do |cache|
+        cache[table_name] = Pgsnap::Query.new(
+          "SELECT * FROM #{table_name} WHERE false"
+        ).columns
+      end
+    end
+
+    private
+
+    def cached_columns
+      Pgsnap::TableColumnsCache.columns[table_name]
+    end
+  end
+end

data/lib/pgsnap/configuration.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+# http://lizabinante.com/blog/creating-a-configurable-ruby-gem/
+module Pgsnap
+  class << self
+    # :reek:Attribute
+    attr_writer :configuration
+
+    def configuration
+      @configuration ||= Configuration.new
+    end
+
+    def reset_configuration
+      @configuration = Configuration.new
+    end
+
+    def set_configuration
+      yield(configuration)
+    end
+  end
+
+  class Configuration
+    # :reek:Attribute
+    attr_accessor :dbname
+
+    def initialize
+      @dbname = nil # nil specifies that this config is required
+    end
+  end
+end

data/lib/pgsnap/connection.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+require 'pg'
+
+module Pgsnap
+  class Connection
+    attr_reader :connection, :dbname
+
+    def initialize
+      @dbname = Pgsnap.configuration.dbname
+      connect
+    end
+
+    def connect
+      @connection = PG.connect(dbname: dbname).tap do |conn|
+        # # (A)
+        # # otherwise, all values are returned as strings
+        # # https://github.com/ged/ruby-pg#type-casts
+        # # got Warning: no type cast defined for type "xid" with oid 28.
+        # #   Please cast this type explicitly to TEXTto be safe for future
+        # #   changes.
+        # # => so, used (B)
+        # conn.type_map_for_results = PG::BasicTypeMapForResults.new(conn)
+
+        # (B)
+        # https://stackoverflow.com/questions/34795078/
+        #   pg-gem-warning-no-type-cast-defined-for-type-numeric/
+        #   51882462#51882462
+        map = PG::BasicTypeMapForResults.new(conn)
+        map.default_type_map = PG::TypeMapAllStrings.new
+        conn.type_map_for_results = map
+      end
+    end
+
+    def dbname_from_status
+      status[0]['datname']
+    end
+
+    def status
+      connection.exec('SELECT * FROM pg_stat_activity')
+    end
+  end
+end

data/lib/pgsnap/nested_json.rb

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+module Pgsnap
+  class NestedJson
+    attr_reader :command
+
+    def initialize
+      @_u = Pgsnap::Utils
+      @command = {}
+      construct_command
+    end
+
+    def nesting
+      @nesting ||= stringified_command
+    end
+
+    def order_by_clause; end
+
+    def select_list_item(expression, expression_alias)
+      # handles 'table_name.*' expression
+      raise(
+        Error,
+        'select list item cannot be * columns in a nested JSON select command'
+      ) if expression[/^.+\.(\*)$/, 1]
+
+      raise Error, 'expression_alias cannot be empty' unless expression_alias
+
+      select_list_struct << "#{expression} AS #{expression_alias}"
+    end
+
+    def sort(expression, direction = 'ASC')
+      order_by_clause_struct << [expression, direction.upcase]
+    end
+
+    private
+
+    attr_reader :_u
+
+    def construct_command
+      select_list
+      order_by_clause
+    end
+
+    def order_by_clause_struct
+      command[:order_by_clause] ||= []
+    end
+
+    def select_list_struct
+      command[:select_list] ||= []
+    end
+
+    def stringified_command
+      a = _u.wrap_in_parentheses(
+        _u.build_clause('SELECT', select_list_struct, ',')
+      )
+      b = _u.join_with_space([
+        'SELECT x FROM',
+        a,
+        'AS x'
+      ].compact)
+      c = _u.wrap_in_parentheses(b)
+      _u.join_with_space([
+        c,
+        _u.build_clause(
+          'ORDER BY',
+          order_by_clause_struct.map { |item| item.join(' ') },
+          ','
+        )
+        ].compact)
+    end
+  end
+end

data/lib/pgsnap/pg_result.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+module Pgsnap
+  class PgResult
+
+    def initialize(select_command)
+      @select_command = select_command
+      set_pg_result
+    end
+
+    def columns
+      (0..(number_of_columns - 1)).map { |idx| column_name(idx) }
+    end
+
+    def number_of_columns
+      pg_result.nfields
+    end
+
+    def number_of_rows
+      pg_result.ntuples
+    end
+
+    def array_of_hashes
+      native.first
+    end
+
+    def native
+      number_of_rows == 1 ? values.first : values
+    end
+
+    def nested_json_result
+      native.first
+    end
+
+    def values
+      pg_result.values
+    end
+
+    private
+
+    attr_reader :pg_result, :select_command
+
+    def column_name(idx)
+      pg_result.fname(idx).to_sym
+    end
+
+    def set_pg_result
+      pg_result || @pg_result = Pgsnap::Connection.new.connection.exec(
+        select_command
+      )
+    end
+  end
+end

data/lib/pgsnap/query.rb

@@ -0,0 +1,150 @@
+# frozen_string_literal: true
+
+require 'json'
+
+module Pgsnap
+  # :reek:TooManyMethods
+  class Query
+    def initialize
+      construct_command
+    end
+
+    # Results
+    ##
+
+    # Executes a new instance of query on PostgreSQL
+    def json
+      pgresult_instance(select_command_json).array_of_hashes
+    end
+
+    def json_string
+      json.to_json
+    end
+
+    # Executes a new instance of query on PostgreSQL
+    def result
+      pgresult_instance(select_command).native
+    end
+
+    # SELECT commands
+    ##
+
+    def as_subquery
+      _u.wrap_in_parentheses(select_command)
+    end
+
+    def select_command
+      _c.select_command
+    end
+
+    def select_command_json
+      _c.select_command_json
+    end
+
+    def select_command_json_string
+      _c.select_command_json_string
+    end
+
+
+    # Metadata
+    ##
+
+    # command struct
+    def command
+      _c.command
+    end
+
+    def columns
+      raise Error, 'Query has not executed yet' unless pgresult
+
+      pgresult.columns
+    end
+
+    def dbname
+      Pgsnap.configuration.dbname
+    end
+
+    # Commands
+    ##
+
+    def from(table_reference, table_reference_alias)
+      _c.from(table_reference, table_reference_alias)
+    end
+
+    def inner_join(table_reference, table_reference_alias, on:)
+      _c.inner_join(table_reference, table_reference_alias, on)
+    end
+
+    def group(group_expression)
+      _c.group(group_expression)
+    end
+
+    def json_agg(nesting_definition)
+      _c.json_agg(nesting_definition)
+    end
+
+    def limit(number_of_rows)
+      _c.limit(number_of_rows)
+    end
+
+    def literal(query_string)
+      _c.literal(query_string)
+    end
+
+    def relation(query_class, relation_alias = nil)
+      _c.relation(query_class, relation_alias)
+    end
+
+    def select_list_item(expression, expression_alias = nil)
+      _c.select_list_item(expression, expression_alias)
+    end
+
+    def sort(sort_expression, direction = 'ASC')
+      _c.sort(sort_expression, direction)
+    end
+
+    def values(*expression)
+      _c.values(*expression)
+    end
+
+    private
+
+    attr_reader :pgresult
+
+    # constructs query from methods defined in subclass
+    def construct_command
+      select_list
+      table_expression
+      group_by_clause
+      order_by_clause
+    end
+
+    # optional
+    ##
+
+    def group_by_clause; end
+
+    def order_by_clause; end
+
+    def table_expression; end
+
+    # aliases
+    ##
+
+    def _c
+      @_c ||= Pgsnap::SelectCommand.new
+    end
+
+    def _u
+      @_u ||= Pgsnap::Utils
+    end
+
+    # metadata
+    ##
+
+    def pgresult_instance(select_command)
+      @pgresult = Pgsnap::PgResult.new(select_command)
+      pgresult
+    end
+  end
+end

data/lib/pgsnap/select_command.rb

@@ -0,0 +1,123 @@
+# frozen_string_literal: true
+
+module Pgsnap
+  # :reek:TooManyMethods
+  class SelectCommand
+    attr_reader :command
+
+    def initialize
+      @_u = Pgsnap::Utils
+      @command = {}
+    end
+
+    # SELECT commands
+    ##
+
+    def select_command
+      @select_command ||= literal_query_string || stringified_command
+    end
+
+    def select_command_json
+      "SELECT JSON_AGG(relation) FROM (#{select_command}) relation"
+    end
+
+    # Commands
+
+    def from(table_reference, table_reference_alias)
+      table_expression_struct <<
+        "#{table_reference} AS #{table_reference_alias}"
+    end
+
+    def group(expression)
+      group_by_clause_struct << expression
+    end
+
+    def inner_join(table_reference, table_reference_alias, on)
+      table_expression_struct <<
+        "INNER JOIN #{table_reference} AS #{table_reference_alias} ON #{on}"
+    end
+
+    def limit(number_of_rows)
+      limit_clause_struct << number_of_rows
+    end
+
+    def literal(query_string)
+      literal_query_string_struct << query_string
+    end
+
+    def json_agg(nesting_definition)
+      "JSON_AGG(#{nesting_definition})"
+    end
+
+    def relation(query_class, relation_alias)
+      cmd.relation(query_class, relation_alias)
+    end
+
+    def select_list_item(expression, expression_alias)
+      # handles 'table_name.*' expression
+      return select_list_struct << expression if expression[/^.+\.(\*)$/, 1]
+
+      raise Error, 'expression_alias cannot be empty' unless expression_alias
+
+      select_list_struct << "#{expression} AS #{expression_alias}"
+    end
+
+    def sort(expression, direction = 'ASC')
+      order_by_clause_struct << [expression, direction.upcase]
+    end
+
+    def values(*expression)
+      squished = _u.squish(expression)
+      wrapped_in_single_quotes = _u.wrap_in_single_quotes(squished)
+      comma_joined = _u.join_with_comma(wrapped_in_single_quotes)
+      "(VALUES(#{comma_joined}))"
+    end
+
+    private
+
+    attr_reader :_u
+
+    def limit_clause_struct
+      command[:limit_clause] ||= []
+    end
+
+    def literal_query_string
+      command[:literal_query_string].join if
+        literal_query_string_struct.size > 0
+    end
+
+    def literal_query_string_struct
+      command[:literal_query_string] ||= []
+    end
+
+    def group_by_clause_struct
+      command[:group_by_clause] ||= []
+    end
+
+    def order_by_clause_struct
+      command[:order_by_clause] ||= []
+    end
+
+    def select_list_struct
+      command[:select_list] ||= []
+    end
+
+    def stringified_command
+      _u.join_with_space([
+        _u.build_clause('SELECT', select_list_struct, ','),
+        _u.build_clause('FROM', table_expression_struct, ' '),
+        _u.build_clause('GROUP BY', group_by_clause_struct, ','),
+        _u.build_clause(
+          'ORDER BY',
+          order_by_clause_struct.map { |item| item.join(' ') },
+          ','
+        ),
+        _u.build_scalar('LIMIT', limit_clause_struct.first)
+      ].compact)
+    end
+
+    def table_expression_struct
+      command[:table_expression] ||= []
+    end
+  end
+end

data/lib/pgsnap/table_columns_cache.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+# caches table columns queried from the database
+module Pgsnap
+  class TableColumnsCache
+    class << self
+      # :reek:Attribute
+      attr_writer :cache
+
+      def cache
+        @cache ||= new
+      end
+
+      def columns
+        cache.columns
+      end
+
+      def set
+        yield(cache.columns)
+      end
+    end
+
+    # :reek:Attribute
+    attr_accessor :columns
+
+    def initialize
+      @columns = {}
+    end
+  end
+end

data/lib/pgsnap/utils.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+module Pgsnap
+  module Utils
+    class << self
+      def build_clause(clause, content_array, separator)
+        return unless content_array.length.positive?
+
+        pretty_separator = separator == ' ' ? separator : "#{separator} "
+        "#{clause} #{content_array.join(pretty_separator)}"
+      end
+
+      def build_scalar(clause, content)
+        "#{clause} #{content}" if content
+      end
+
+      # '   i    wanna  be     squished'
+      # => "i wanna be squished"
+      #
+      # [1, '   i    wanna  be     squished']
+      # => [1, "i wanna be squished"]
+      def squish(content)
+        return content.split.join(' ') if content.is_a?(String)
+
+        return content.map { |elem| squish(elem) } if content.is_a?(Array)
+
+        content
+      end
+
+      def wrap_in_parentheses(content)
+        "(#{content})"
+      end
+
+      # [1, 'i wanna be wrapped in single quotes']
+      # => [1, "'i wanna be wrapped in single quotes'"]
+      def wrap_in_single_quotes(content)
+        return %('#{content}') if content.is_a?(String)
+
+        if content.is_a?(Array)
+          return content.map { |elem| wrap_in_single_quotes(elem) }
+        end
+
+        content
+      end
+
+      # [1, "'i wanna be wrapped in single quotes'"]
+      # => "1, 'i wanna be wrapped in single quotes'"
+      def join_with_comma(content)
+        return content.join(', ') if content.is_a?(Array)
+
+        content
+      end
+
+      # [1, "'i wanna be wrapped in single quotes'"]
+      # => "1, 'i wanna be wrapped in single quotes'"
+      def join_with_space(content)
+        return content.join(' ') if content.is_a?(Array)
+
+        content
+      end
+    end
+  end
+end

data/lib/pgsnap/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module Pgsnap
+  VERSION = '1.0.0.beta.10'
+end

metadata

@@ -0,0 +1,80 @@
+--- !ruby/object:Gem::Specification
+name: pgsnap
+version: !ruby/object:Gem::Version
+  version: 1.0.0.beta.10
+platform: ruby
+authors:
+- David Chin
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2018-12-29 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: pg
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.1'
+description: Construct composable, structured, PostgreSQL queries in plain Ruby.
+email:
+- dlcmhd@me.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".reek.yml"
+- ".rubocop.yml"
+- ".ruby-version"
+- ".travis.yml"
+- CHANGELOG.md
+- LICENSE.txt
+- README.md
+- lib/pgsnap.rb
+- lib/pgsnap/base_table.rb
+- lib/pgsnap/configuration.rb
+- lib/pgsnap/connection.rb
+- lib/pgsnap/nested_json.rb
+- lib/pgsnap/pg_result.rb
+- lib/pgsnap/query.rb
+- lib/pgsnap/select_command.rb
+- lib/pgsnap/table_columns_cache.rb
+- lib/pgsnap/utils.rb
+- lib/pgsnap/version.rb
+homepage: https://pgsnap-ruby.briefnotes.net
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://pgsnap-ruby.briefnotes.net
+  source_code_uri: https://github.com/dlcmh/pgsnap-ruby
+  changelog_uri: https://github.com/dlcmh/pgsnap-ruby/blob/master/CHANGELOG.md
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.0.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">"
+    - !ruby/object:Gem::Version
+      version: 1.3.1
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.7.6
+signing_key: 
+specification_version: 4
+summary: Pgsnap makes working with PostgreSQL queries infinitely more pleasant.
+test_files: []