pg_column_byte_packer 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 0b3b506f62b7b77b22577939d71057487ac9577573927e31fe9ae88b03e18a24
+  data.tar.gz: 54b478a7824de37ade407f615f25f246014d61ec311087bba86779d71d6cb237
+SHA512:
+  metadata.gz: 8a71b91c4644867ee0462da1d4f08321ddc4aeb409e0910a074ade6fb881338e3445c94c22a0c95fbab21a9c8617f24006404cf262cf8ab1c806076a212a4f05
+  data.tar.gz: 3b752736a44949477bc6d65f41a58901a8ac52d4b8b0637a84d0eeb247b23a2067d39c6a939f7c0a2c69acf0dad5f28066e3e99ff76079dc72f9d87c09de81a4

data/.gitignore

@@ -0,0 +1,13 @@
+/.bundle/
+/.yardoc
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+Gemfile.lock
+gemfiles/*.lock
+
+# rspec failure tracking
+.rspec_status

data/.pryrc

@@ -0,0 +1,21 @@
+if defined?(PryByebug)
+  Pry.commands.alias_command 'c', 'continue'
+  Pry.commands.alias_command 's', 'step'
+  Pry.commands.alias_command 'n', 'next'
+  Pry.commands.alias_command 'f', 'finish'
+end
+
+# https://github.com/pry/pry/issues/1275#issuecomment-131969510
+# Prevent issue where text input does not display on screen in container after typing Ctrl-C in a pry repl
+at_exit do
+  exit!(1)
+end
+
+trap('INT') do
+  begin
+    Pry.run_command "continue", :show_output => true, :target => Pry.current
+  rescue
+    exit
+  end
+end
+# End pry Ctrl-C workaround

data/.rspec

@@ -0,0 +1,3 @@
+--format documentation
+--color
+--require spec_helper

data/.ruby-version

@@ -0,0 +1 @@
+2.6.0

data/.travis.yml

@@ -0,0 +1,28 @@
+sudo: false
+language: ruby
+rvm:
+  - 2.5
+env:
+  global:
+    - PGPORT: "5433"
+  jobs:
+    - PGVERSION: "9.6"
+    - PGVERSION: "10"
+    - PGVERSION: "11"
+    - PGVERSION: "12"
+services:
+  - postgresql
+before_install:
+  - "for CLUSTER_VERSION in $(pg_lsclusters -h | cut -d' ' -f1); do sudo pg_dropcluster $CLUSTER_VERSION main --stop || true; sudo apt-get remove postgresql-client-$CLUSTER_VERSION postgresql-client-common || true; done"
+  - sudo apt-get update
+  - sudo apt-get -y install postgresql-$PGVERSION postgresql-server-dev-$PGVERSION postgresql-contrib-$PGVERSION postgresql-client-$PGVERSION postgresql-client-common
+  - sudo pg_dropcluster $PGVERSION main --stop || true
+  - sudo pg_createcluster $PGVERSION main -D /var/ramfs/postgresql/11/main -- --auth=trust
+  - sudo pg_ctlcluster start $PGVERSION main
+  - gem uninstall -v '>= 2' -i $(rvm gemdir)@global -ax bundler || true
+  - gem install bundler -v 1.15.4
+gemfile:
+  - gemfiles/rails_5.1.gemfile
+  - gemfiles/rails_5.2.gemfile
+  - gemfiles/rails_6.0.gemfile
+script: "bundle exec rake spec"

data/Appraisals

@@ -0,0 +1,12 @@
+appraise "rails-5.1" do
+  gem "activerecord", "5.1.7"
+end
+
+appraise "rails-5.2" do
+  gem "activerecord", "5.2.3"
+end
+
+appraise "rails-6.0" do
+  gem "activerecord", "6.0.0"
+end
+

data/Gemfile

@@ -0,0 +1,6 @@
+source "https://rubygems.org"
+
+git_source(:github) {|repo_name| "https://github.com/#{repo_name}" }
+
+# Specify your gem's dependencies in pg_column_byte_packer.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2020 Braintree Payments
+
+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,58 @@
+# PostgreSQL Column Byte Packer
+
+[![Build Status](https://travis-ci.org/braintree/pg_column_byte_packer.svg?branch=master)](https://travis-ci.org/braintree/pg_column_byte_packer/)
+
+tl;dr: Provides facilities for laying out table column order to optimize for disk space usage both in ActiveRecord migrations and `pg_dump` generated SQL schema files. The general idea and relevant PostgreSQL internals are described in [On Rocks and Sand](https://www.2ndquadrant.com/en/blog/on-rocks-and-sand/).
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'pg_column_byte_packer'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install pg_column_byte_packer
+
+## Usage
+
+There are two ways you can use this library to byte-pack your tables' column layout:
+
+### Re-ordering columns using ActiveRecord migrations
+
+Loading the library automatically patches ActiveRecord's table creation tree walker to automatically re-order columns by alignment size. Therefore all `create_table` calls in ActiveRecord migrations executed after loading the gem will be byte-packing optimized.
+
+Note: Because you need the full table definition to re-order columns, the most benefit occurs when the full table is created in one step (rather than added onto with repeated `add_column` migrations).
+
+### Re-ordering SQL structure files (from `pg_dump`)
+
+ActiveRecord defaults to saving your application's database structure to a `schema.rb` file (which is essentially all of the ActiveRecord migrations commands you'd need to generate the current state of the database). However you can also configure it to save a copy of the database structure in SQL format by setting `config.active_record.schema_format = :sql` in your `config/application.rb` file. With this configuration (and running against a PostgreSQL database) ActiveRecord executes the `pg_dump` utility (included in the PostgreSQL client tools) against your database to generate a `structure.sql` file.
+
+If you have an existing `structure.sql` file (or any structure-only file generated by `pg_dump`), you can update that file to have byte-packed `CREATE TABLE` statements with the following:
+
+```ruby
+PgColumnBytePacker::PgDump.sort_columns_for_definition_file(
+  "<path to structure.sql file>",
+  connection: ActiveRecord::Base.connection
+)
+```
+
+Note: an ActiveRecord connection object is required so that the library can properly determine the data types (and their respective alignment requirements) and column metadata (e.g., `DEFAULT` and `NOT NULL`).
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. Then, run `bundle exec rspec` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment. This project uses Appraisal to test against multiple versions of ActiveRecord; you can run the tests against all supported version with `bundle exec appraisal rspec`.
+
+Running tests will automatically create a test database in the locally running Postgres server. You can find the connection parameters in `spec/spec_helper.rb`, but setting the environment variables `PGHOST`, `PGPORT`, `PGUSER`, and `PGPASSWORD` will override the defaults.
+
+To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](http://opensource.org/licenses/MIT).

data/Rakefile

@@ -0,0 +1,6 @@
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+
+task :default => :spec

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "pg_column_byte_packer"
+
+# 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"
+# Pry.start
+
+require "irb"
+IRB.start(__FILE__)

data/bin/setup

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

data/gemfiles/.bundle/config

@@ -0,0 +1,2 @@
+---
+BUNDLE_RETRY: "1"

data/gemfiles/rails_5.1.gemfile

@@ -0,0 +1,7 @@
+# This file was generated by Appraisal
+
+source "https://rubygems.org"
+
+gem "activerecord", "5.1.7"
+
+gemspec path: "../"

data/gemfiles/rails_5.2.gemfile

@@ -0,0 +1,7 @@
+# This file was generated by Appraisal
+
+source "https://rubygems.org"
+
+gem "activerecord", "5.2.3"
+
+gemspec path: "../"

data/gemfiles/rails_6.0.gemfile

@@ -0,0 +1,7 @@
+# This file was generated by Appraisal
+
+source "https://rubygems.org"
+
+gem "activerecord", "6.0.0"
+
+gemspec path: "../"

data/lib/pg_column_byte_packer.rb

@@ -0,0 +1,147 @@
+require "pg_column_byte_packer/version"
+require "pg_query"
+
+module PgColumnBytePacker
+  def self.sql_type_alignment_cache
+    @@sql_type_alignment_cache ||= {}
+  end
+
+  def self.ordering_key_for_column(connection:, name:, sql_type:, type_schema: nil, primary_key:, nullable:, has_default:)
+    alignment = PgColumnBytePacker.sql_type_alignment_cache[sql_type] ||= (
+      if type_schema.nil?
+        fake_query = "CREATE TABLE t(c #{sql_type});"
+        parsed = begin
+           PgQuery.parse(fake_query)
+         rescue PgQuery::ParseError
+           nil
+         end
+
+        if parsed && (column_def = parsed.tree[0]["RawStmt"]["stmt"]["CreateStmt"]["tableElts"][0]["ColumnDef"])
+          type_identifiers = column_def["typeName"]["TypeName"]["names"].map { |s| s["String"]["str"] }
+          case type_identifiers.size
+          when 1
+            # Do nothing; we already have a bare type.
+          when 2
+            type_schema, bare_type = type_identifiers
+          else
+            raise ArgumentError, "Unexpected number of identifiers in type declaration for column: `#{name}`, identifiers: #{type_identifiers.inspect}"
+          end
+        end
+      end
+
+      bare_type = if type_schema
+        if sql_type.start_with?("#{type_schema}.")
+          sql_type.sub("#{type_schema}.", "")
+        elsif sql_type.start_with?("\"#{type_schema}\".")
+          sql_type.sub("\"#{type_schema}\".", "")
+        else
+          sql_type
+        end
+      else
+        sql_type
+      end
+
+      # Ignore array designations. This seems like something we could
+      # so with the parsing above, and we could, and, in fact, that
+      # would also almost certain allow us to rip out most of the
+      # ActiveRecord generate alias type name matching below, but
+      # it would also mean a more thorough refactor below for types
+      # with size designations (e.g., when ActiveRecord generates
+      # "float(23)"). So we use this simple regex cleanup for now.
+      bare_type = bare_type.sub(/(\[\])+\Z/, "")
+
+      # Sort out the alignment. Most of the type name matching is to
+      # support the naming variants that ActiveRecord generates (often
+      # they're aliases, like "integer", for which PostgreSQL internally
+      # has a different canonical name, like "int4"). There are also
+      # a few cases we have to handle where the output from pgdump
+      # doesn't match the canonical name in pg_type; e.g., "float8" is
+      # canonical, but pgdump outputs "double precision".
+      case bare_type
+      when "bigint", "double precision", /\Atimestamp.*/, /\Abigserial( primary key)?/
+        8 # Actual alignment for these types.
+      when "integer", "date", "decimal", "real", /\Aserial( primary key)?/
+        4 # Actual alignment for these types.
+      when "bytea"
+        # These types generally have an alignment of 4, but values of at most 127 bytes
+        # long they are optimized into 2 byte alignment.
+        # Since we'd expect any binary fields to be relatively long, we'll assume they
+        # won't fit into the optimized case.
+        4
+      when "text", "citext", "character varying"
+        # These types generally have an alignment of 4, but values of at most 127 bytes
+        # long they are optimized into 2 byte alignment.
+        # Since we don't have a good heuristic for determining which columns are likely
+        # to be long or short, we currently just slot them all after the columns we
+        # believe will always be long.
+        # If desired we could also differentiate on length limits if set.
+        3
+      when /\Acharacter varying\(\d+\)/
+        if (limit = /\Acharacter varying\((\d+)\)/.match(sql_type)[1])
+          if limit.to_i <= 127
+            2
+          else
+            4
+          end
+        end
+      when /\Afloat(\(\d+\))?/
+        precision_match = /\Afloat\((\d+)\)?/.match(sql_type)
+        if precision_match
+          # Precision here is a number of binary digits;
+          # see https://www.postgresql.org/docs/10/datatype-numeric.html
+          # for more information.
+          if precision_match[1].to_i >= 25
+            8 # Double precision
+          else
+            4 # Real
+          end
+        else
+          8 # Default is double precision
+        end
+      when "smallint", "boolean"
+        2 # Actual alignment for these types.
+      else
+        typtype, typalign = connection.select_rows(<<~SQL, "Type Lookup").first
+          SELECT typ.typtype, typ.typalign
+          FROM pg_type typ
+          JOIN pg_namespace nsp ON nsp.oid = typ.typnamespace
+          WHERE typname = '#{connection.quote_string(bare_type)}'
+            #{type_schema ? "AND nsp.nspname = '#{connection.quote_string(type_schema)}'" : ""}
+        SQL
+
+        if typtype.nil?
+          raise ArgumentError, "Got sql_type: `#{sql_type}` and type_schema: `#{type_schema}` but was unable to find entry in pg_type."
+        end
+
+        if typtype == "e"
+          4
+        else
+          case typalign
+          when "c"
+            0
+          when "s"
+            2
+          when "i"
+            4
+          when "d"
+            8
+          else
+            0
+          end
+        end
+      end
+    )
+
+    # Ordering components in order of most importance to least importance.
+    [
+      -alignment, # Sort alignment descending.
+      primary_key ? 0 : 1, # Sort PRIMARY KEY first.
+      nullable ? 1 : 0, # Sort NOT NULL first.
+      has_default && nullable ? 0 : 1, # Sort DEFAULT first (but only when also nullable).
+      name, # Sort name ascending.
+    ]
+  end
+end
+
+require "pg_column_byte_packer/schema_statements"
+require "pg_column_byte_packer/pg_dump"

data/lib/pg_column_byte_packer/pg_dump.rb

@@ -0,0 +1,119 @@
+module PgColumnBytePacker
+  module PgDump
+    def self.sort_columns_for_definition_file(path, connection:)
+      sorted_dump_output = []
+      current_block_start = nil
+      current_block_body = []
+      current_table_name = nil
+      block_begin_prefix_pattern = /\ACREATE TABLE ([^\(]+) \(/
+      block_end_line_pattern = /\A\);?\n\Z/
+
+      File.foreach(path) do |line|
+        if current_block_start.nil? && (create_table_match = block_begin_prefix_pattern.match(line))
+          current_block_start = line
+          current_block_body = []
+          current_table_name = create_table_match[1]
+        elsif current_block_start
+          if line =~ block_end_line_pattern
+            sorted_dump_output << current_block_start
+            table_lines = _sort_table_lines(
+              connection: connection,
+              qualified_table: current_table_name,
+              lines: current_block_body
+            )
+            table_lines = table_lines.map.with_index do |column_line, index|
+              has_trailing_comma = column_line =~ /,\s*\Z/
+              last_line = index == table_lines.size - 1
+              if !last_line && !has_trailing_comma
+                column_line.sub(/(.+)(\s*)\Z/, '\1,\2')
+              elsif last_line && has_trailing_comma
+                column_line.sub(/,(\s*)\Z/, '\1')
+              else
+                column_line
+              end
+            end
+            sorted_dump_output.concat(table_lines)
+            sorted_dump_output << line
+
+            current_block_body = []
+            current_block_start = nil
+            current_table_name = nil
+          else
+            current_block_body << line
+          end
+        else
+          sorted_dump_output << line
+        end
+      end
+
+      File.write(path, sorted_dump_output.join)
+    end
+
+    def self._sort_table_lines(connection:, qualified_table:, lines:)
+      schema, table = qualified_table.match(/([^\.]+)\.([^\.]+)/)[1..-1]
+
+      lines.sort_by do |line|
+        line = line.chomp
+
+        # To handle the vagaries of quoted keywords as column names
+        # and spaces/special characters in column names, we resort
+        # to using PostgreSQL's parsing code itself on a faked
+        # CREATE TABLE call with a single column; we could parse
+        # the entire CREATE TABLE statement we have in the file,
+        # but then we'd have to figure out a way to recreate that
+        # query from the parse tree, and therein lies madness.
+        line_without_comma = line[-1] == "," ? line[0..-2] : line
+        fake_query = "CREATE TABLE t(#{line_without_comma});"
+        parsed = begin
+           PgQuery.parse(fake_query)
+         rescue PgQuery::ParseError
+           nil
+         end
+
+        # Ignore CONSTRAINT definitions etc.
+        if parsed && (column_def = parsed.tree[0]["RawStmt"]["stmt"]["CreateStmt"]["tableElts"][0]["ColumnDef"])
+          column = column_def["colname"]
+
+          values = connection.select_rows(<<~SQL, "Column and Type Info").first
+            SELECT
+              pg_catalog.format_type(attr.atttypid, attr.atttypmod),
+              typ_nsp.nspname,
+              attr.attnotnull,
+              attr.atthasdef,
+              EXISTS (
+                SELECT 1
+                FROM pg_index idx
+                WHERE idx.indisprimary
+                  AND attr.attnum = ANY(idx.indkey)
+                  AND idx.indrelid = attr.attrelid
+              )
+            FROM pg_catalog.pg_attribute attr
+            JOIN pg_catalog.pg_type typ ON typ.oid = attr.atttypid
+            JOIN pg_catalog.pg_class cls ON cls.oid = attr.attrelid
+            JOIN pg_catalog.pg_namespace attr_nsp ON attr_nsp.oid = cls.relnamespace
+            JOIN pg_catalog.pg_namespace typ_nsp ON typ_nsp.oid = typ.typnamespace
+            WHERE attr.attname = '#{connection.quote_string(column)}'
+              AND attr_nsp.nspname = '#{connection.quote_string(schema)}'
+              AND cls.relname = '#{connection.quote_string(table)}'
+              AND NOT attr.attisdropped
+          SQL
+          sql_type, type_schema, not_null, has_default, primary_key = values
+
+          PgColumnBytePacker.ordering_key_for_column(
+            connection: connection,
+            name: column,
+            sql_type: sql_type,
+            type_schema: type_schema,
+            primary_key: primary_key,
+            nullable: !not_null,
+            has_default: has_default
+          )
+        else
+          # All non-column lines we want to sort at the end
+          # of the table defintion statement.
+          [2**32]
+        end
+      end
+    end
+  end
+end

data/lib/pg_column_byte_packer/schema_statements.rb

@@ -0,0 +1,44 @@
+require "active_record"
+require "active_record/migration"
+
+module PgColumnBytePacker
+  module SchemaCreation
+    def visit_TableDefinition(o)
+      columns_hash = o.instance_variable_get(:@columns_hash)
+
+      sorted_column_tuples = columns_hash.sort_by do |name, col|
+        sql_type = type_to_sql(
+          col.type,
+          :limit => col.limit,
+          :precision => col.precision,
+          :scale => col.scale,
+          :primary_key => col.primary_key?,
+        )
+
+        nullable = if sql_type.match(/\A(big)?serial( primary key)?/)
+          col.null == true
+        else
+          col.null.nil? || col.null == true
+        end
+
+        PgColumnBytePacker.ordering_key_for_column(
+          connection: @conn,
+          name: name,
+          sql_type: sql_type,
+          primary_key: col.options[:primary_key],
+          nullable: nullable,
+          has_default: !col.default.nil?
+        )
+      end
+
+      columns_hash.clear
+      sorted_column_tuples.each do |(name, column)|
+        columns_hash[name] = column
+      end
+
+      super(o)
+    end
+  end
+end
+
+ActiveRecord::ConnectionAdapters::AbstractAdapter::SchemaCreation.prepend(PgColumnBytePacker::SchemaCreation)

data/lib/pg_column_byte_packer/version.rb

@@ -0,0 +1,3 @@
+module PgColumnBytePacker
+  VERSION = "1.0.0"
+end

data/pg_column_byte_packer.gemspec

@@ -0,0 +1,37 @@
+lib = File.expand_path("../lib", __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require "pg_column_byte_packer/version"
+
+Gem::Specification.new do |spec|
+  spec.name          = "pg_column_byte_packer"
+  spec.version       = PgColumnBytePacker::VERSION
+  spec.authors       = [
+    "jcoleman",
+  ]
+  spec.email         = ["code@getbraintree.com"]
+
+  spec.summary       = %q{Auto-order table columns for optimize disk space usage}
+  spec.homepage      = "https://github.com/braintree/pg_column_byte_packer"
+  spec.license       = "MIT"
+
+  # Specify which files should be added to the gem when it is released.
+  # The `git ls-files -z` loads the files in the RubyGem that have been added into git.
+  spec.files         = Dir.chdir(File.expand_path('..', __FILE__)) do
+    `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  end
+  spec.bindir        = "exe"
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "rspec", "~> 3.0"
+  spec.add_development_dependency "relation_to_struct"
+  spec.add_development_dependency "db-query-matchers", "~> 0.9.0"
+  spec.add_development_dependency "pry"
+  spec.add_development_dependency "pry-byebug"
+  spec.add_development_dependency "appraisal", "~> 2.2.0"
+
+  spec.add_dependency "pg"
+  spec.add_dependency "activerecord", ">= 5.1", "< 6.1"
+  spec.add_dependency "pg_query"
+end

metadata

@@ -0,0 +1,210 @@
+--- !ruby/object:Gem::Specification
+name: pg_column_byte_packer
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- jcoleman
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2020-09-29 00:00:00.000000000 Z
+dependencies:
+- !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'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+- !ruby/object:Gem::Dependency
+  name: relation_to_struct
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: db-query-matchers
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.9.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.9.0
+- !ruby/object:Gem::Dependency
+  name: pry
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: pry-byebug
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: appraisal
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 2.2.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 2.2.0
+- !ruby/object:Gem::Dependency
+  name: pg
+  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: activerecord
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '5.1'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '6.1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '5.1'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '6.1'
+- !ruby/object:Gem::Dependency
+  name: pg_query
+  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'
+description: 
+email:
+- code@getbraintree.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".pryrc"
+- ".rspec"
+- ".ruby-version"
+- ".travis.yml"
+- Appraisals
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- bin/console
+- bin/setup
+- gemfiles/.bundle/config
+- gemfiles/rails_5.1.gemfile
+- gemfiles/rails_5.2.gemfile
+- gemfiles/rails_6.0.gemfile
+- lib/pg_column_byte_packer.rb
+- lib/pg_column_byte_packer/pg_dump.rb
+- lib/pg_column_byte_packer/schema_statements.rb
+- lib/pg_column_byte_packer/version.rb
+- pg_column_byte_packer.gemspec
+homepage: https://github.com/braintree/pg_column_byte_packer
+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: []
+rubygems_version: 3.1.2
+signing_key: 
+specification_version: 4
+summary: Auto-order table columns for optimize disk space usage
+test_files: []