{"id":25527145,"url":"https://github.com/vprokopchuk256/mv-postgresql","last_synced_at":"2025-04-11T06:10:13.257Z","repository":{"id":56884908,"uuid":"1459163","full_name":"vprokopchuk256/mv-postgresql","owner":"vprokopchuk256","description":"Postgresql constraints in migrations similiar to ActiveRecord validations","archived":false,"fork":false,"pushed_at":"2018-12-05T02:36:20.000Z","size":168,"stargazers_count":20,"open_issues_count":2,"forks_count":2,"subscribers_count":1,"default_branch":"master","last_synced_at":"2025-04-11T06:09:37.153Z","etag":null,"topics":["constraints","ruby"],"latest_commit_sha":null,"homepage":"","language":"Ruby","has_issues":true,"has_wiki":null,"has_pages":null,"mirror_url":null,"source_name":null,"license":"mit","status":null,"scm":"git","pull_requests_enabled":true,"icon_url":"https://github.com/vprokopchuk256.png","metadata":{"files":{"readme":"README.md","changelog":null,"contributing":null,"funding":null,"license":"LICENSE.txt","code_of_conduct":null,"threat_model":null,"audit":null,"citation":null,"codeowners":null,"security":null,"support":null}},"created_at":"2011-03-09T13:57:04.000Z","updated_at":"2024-02-06T20:34:52.000Z","dependencies_parsed_at":"2022-08-20T23:40:42.218Z","dependency_job_id":null,"html_url":"https://github.com/vprokopchuk256/mv-postgresql","commit_stats":null,"previous_names":[],"tags_count":16,"template":false,"template_full_name":null,"repository_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/vprokopchuk256%2Fmv-postgresql","tags_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/vprokopchuk256%2Fmv-postgresql/tags","releases_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/vprokopchuk256%2Fmv-postgresql/releases","manifests_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/vprokopchuk256%2Fmv-postgresql/manifests","owner_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/owners/vprokopchuk256","download_url":"https://codeload.github.com/vprokopchuk256/mv-postgresql/tar.gz/refs/heads/master","host":{"name":"GitHub","url":"https://github.com","kind":"github","repositories_count":248351382,"owners_count":21089270,"icon_url":"https://github.com/github.png","version":null,"created_at":"2022-05-30T11:31:42.601Z","updated_at":"2022-07-04T15:15:14.044Z","host_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub","repositories_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories","repository_names_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repository_names","owners_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/owners"}},"keywords":["constraints","ruby"],"created_at":"2025-02-19T22:17:18.066Z","updated_at":"2025-04-11T06:10:13.165Z","avatar_url":"https://github.com/vprokopchuk256.png","language":"Ruby","readme":"[![Build Status](https://travis-ci.org/vprokopchuk256/mv-postgresql.svg?branch=master)](https://travis-ci.org/vprokopchuk256/mv-postgresql)\n[![Coverage Status](https://coveralls.io/repos/vprokopchuk256/mv-postgresql/badge.png?branch=master)](https://coveralls.io/r/vprokopchuk256/mv-postgresql?branch=master)\n[![Gem Version](https://badge.fury.io/rb/mv-postgresql.svg)](http://badge.fury.io/rb/mv-postgresql)\n\n# `Migration Validators` project. PostgreSQL driver.\n\nDefine validations directly in DB as PostgreSQL constraints and integrate them into your model transparently. See [mv-core](https://github.com/vprokopchuk256/mv-core) for details. There you will be able to review high level project information. Below you can see details of the migration validations that are supported by PostgreSQL driver.\n\n#Table Of Contents\n* [Validations](#validations)\n  * [uniqueness](#uniqueness)\n  * [length](#length)\n  * [inclusion](#inclusion)\n  * [exclusion](#exclusion)\n  * [presence](#presence)\n  * [absence](#absence)\n  * [format](#format)\n  * [custom](#custom)\n* [Version History](#version history)\n* [Contributing](#contributing)\n\n# Validations\n\n### uniqueness\n\n  Examples:\n\n  validate uniqueness of the column `column_name`:\n\n  ```ruby\n  def up\n    validates :table_name, :column_name, uniqueness: true\n  end\n\n  def down\n    validates :table_name, :column_name, uniqueness: false\n  end\n  ```\n\n  define validation as trigger with specified failure message:\n\n  ```ruby\n  def up\n    validates :table_name, :column_name,\n                    uniqueness: { message: 'Error message', as: :trigger }\n  end\n\n  def down\n    validates :table_name, :column_name, uniqueness: false\n  end\n  ```\n\n  define validation as unique index:\n\n  ```ruby\n  def up\n    validates :table_name, :column_name, uniqueness: { as: :index }\n  end\n\n  def down\n    validates :table_name, :column_name, uniqueness: false\n  end\n  ```\n\n  all above are available in a create and change table blocks:\n\n  ```ruby\n  def change\n    create_table :table_name do |t|\n       t.string :column_name, validates: { uniqueness: true }\n    end\n  end\n  ```\n\n  ```ruby\n  def up\n    change :table_name do |t|\n       t.change :column_name, :string, validates: { uniqueness: false }\n    end\n  end\n\n  def down\n    change :table_name do |t|\n       t.change :column_name, :string, validates: { uniqueness: false }\n    end\n  end\n  ```\n\n  simplifications (version \u003e= 2.1 is required):\n\n  ```ruby\n  def change\n    create_table :table_name do |t|\n       t.string :column_name, uniqueness: true\n    end\n  end\n  ```\n\n  Options:\n\n  * `:message` - text of the error message that will be shown if constraint violated.  Ignored unless `:as == :trigger`\n  * `:index_name` - name of the index that will be created for validator. Ignored unless `:as == :index`\n  * `:on` - validation event. Possible values `[:save, :update, :create]`. Ignored unless `:as == :trigger`. Default value `:save`\n  * `:create_tigger_name` - name of the 'before insert' trigger that will be created if `:as == :trigger` \u0026\u0026 `:on` in `[:save, :create]`\n  * `:update_tigger_name` - name of the 'before update' trigger that will be created if `:as == :trigger` \u0026\u0026 `:on` in `[:save, :update]`\n  * `:allow_nil` - ignore validation for nil values. Ignored unless `:as == :trigger`. Default value: `false`\n  * `:allow_blank` - ignore validation for blank values. Ignored unless `:as == :trigger`. Default value: `false`\n  * `:as` - defines the way how constraint will be implemented. Possible values: `[:index, :trigger]`. Default value: `:index`\n\n### length\n\nExamples:\n\n  ```ruby\n  def up\n    validates :table_name, :column_name,\n              length: { in: 5..8, message: 'Wrong length message'}\n  end\n\n  def down\n    validates :table_name, :column_name, length: false\n  end\n  ```\n\nallow `NULL`:\n\n  ```ruby\n  def up\n    validates :table_name, :column_name,\n              length: { is: 3, allow_nil: true}\n  end\n\n  def down\n    validates :table_name, :column_name, length: false\n  end\n  ```\n\n  allow blank values:\n\n  ```ruby\n  def up\n    validates :table_name, :column_name,\n              length: { maximum: 3,\n                        allow_blank: true,\n                        too_long: 'Value is longer than 3 symbols' }\n  end\n\n  def down\n    validates :table_name, :column_name, length: false\n  end\n  ```\n\n  define constraint in trigger:\n\n  ```ruby\n  def up\n    validates :table_name, :column_name,\n                         length: { maximum: 3,\n                                   as: :trigger,\n                                   too_long: 'Value is longer than 3 symbols' }\n  end\n\n  def down\n    validates :table_name, :column_name, length: false\n  end\n  ```\n\n  all above are available in a create and change table blocks:\n\n  ```ruby\n  def change\n    create_table :table_name do |t|\n       t.string :column_name, validates: { length: { is: 3, allow_nil: true} }\n    end\n  end\n  ```\n\n  ```ruby\n  def up\n    change :table_name do |t|\n       t.change :column_name, :string, validates: { length: { is: 3 } }\n    end\n  end\n\n  def down\n    change :table_name do |t|\n       t.change :column_name, :string, validates: { length: false }\n    end\n  end\n  ```\n\n  simplifications (version \u003e= 2.1 is required):\n\n  ```ruby\n  def change\n    create_table :table_name do |t|\n      t.string :string_3, length: 3\n      t.string :string_from_1_to_3, length: 1..3,\n      t.string :string_1_or_3, length: [1, 3]\n      t.string :string_4, validates: { length: 4 }\n      t.string :string_4_in_trigger: length: { is: 4, as: :trigger }\n    end\n  end\n  ```\n\n  Options:\n\n  * `in` - range or array that length of the value should be contained in.\n  * `within` - synonym of `:in`\n  * `is` - exact length of the value\n  * `maximum` -  maximum allowed length\n  * `minimum` - minimum allowed length\n  * `message` - message that should be shown if validation failed and specific message is not defined. Ignored unless `:as == :trigger`\n  * `too_long` - message that will be shown if value longer than allowed. Ignored unless maximum value is defined\n  * `too_short` - message that will be shown if value shorter than allowed. Ignored unless minimum value is defined\n  * `on` -  validation event. Possible values `[:save, :update, :create]`. Ignored unless `:as == :trigger`. Default value: `:save`\n  * `create_tigger_name` - Name of the 'before insert' trigger that will be created if `:as == :trigger` \u0026\u0026 `:on` in `[:save, :create]`\n  * `update_tigger_name` - Name of the 'before update' trigger that will be created if `:as == :trigger` \u0026\u0026 `:on` in `[:save, :update]`\n  * `allow_nil` - ignore validation for nil values. Default value: `false`\n  * `allow_blank` - ignore validation for blank values. Default value: `false`\n  * `as` - defines the way how constraint will be implemented. Possible values: `[:trigger, :check]` Default value: `:check`\n\n### inclusion\n\n  Examples:\n\n  valid values array:\n\n  ```ruby\n  def up\n    validates :table_name, :column_name, inclusion: { in: [1, 2, 3] }\n  end\n\n  def down\n    validates :table_name, :column_name, inclusion: false\n  end\n  ```\n\n  with failure message specified:\n\n  ```ruby\n  def up\n    validates :table_name, :column_name,\n    inclusion: { in: [1, 2, 3],\n                 message: \"Column value should be equal to 1 or 2 or 3\" }\n  end\n\n  def down\n    validates :table_name, :column_name, inclusion: false\n  end\n  ```\n\n  make it as check constraint:\n\n  ```ruby\n  def up\n    validates :table_name, :column_name,\n              inclusion: { in: [1, 2, 3], as: :check }\n  end\n\n  def down\n    validates :table_name, :column_name, inclusion: false\n  end\n  ```\n\n  make it in trigger:\n\n  ```ruby\n  def up\n    validates :table_name, :column_name,\n                           inclusion: { in: 1..3,\n                                        on: :create,\n                                        as: :trigger }\n  end\n\n  def down\n    validates :table_name, :column_name, inclusion: false\n  end\n  ```\n\n  all above are available in a create and change table blocks:\n\n  ```ruby\n  def change\n    create_table :table_name do |t|\n       t.integer :column_name, validates: { inclusion: { in: 1..3 } }\n    end\n  end\n  ```\n\n  ```ruby\n  def up\n    change :table_name do |t|\n       t.change :column_name, :integer, validates: { inclusion: { in: 1..3 } }\n    end\n  end\n\n  def down\n    change :table_name do |t|\n       t.change :column_name, :integer, validates: { inclusion: false }\n    end\n  end\n  ```\n\n  simplifications (version \u003e= 2.1 is required):\n\n  ```ruby\n  def change\n    create_table :table_name do |t|\n      t.string :str_or_str_1, inclusion: ['str', 'str1']\n      t.string :from_str_to_str_1, inclusion: 'str'..'str1'\n      t.string :str_or_str_1_in_trigger, inclusion: { in: ['str', 'str1'],\n                                                      as: :trigger}\n    end\n  end\n  ```\n\n  Options:\n\n  * `in` - range or array that column value should be contained in.\n  * `message` - message that should be shown if validation failed. Ignored unless `:as == :trigger`\n  * `on` -  validation event. Possible values `[:save, :update, :create]`. Ignored unless `:as == :trigger`. Default value: `:save`\n  * `create_tigger_name` - Name of the 'before insert' trigger that will be created if `:as == :trigger` \u0026\u0026 `:on` in `[:save, :create]`\n  * `update_tigger_name` - Name of the 'before update' trigger that will be created if `:as == :trigger` \u0026\u0026 `:on` in `[:save, :update]`\n  * `allow_nil` - ignore validation for nil values. Default value: `false`\n  * `allow_blank` - ignore validation for blank values. Default value: `false`\n  * `as` - defines the way how constraint will be implemented. Possible values: `[:trigger, :check]` Default value: `:check`\n\n\n### exclusion\n\n  Examples:\n\n  exclude 1, 2, and 3:\n\n  within `create_table` statement:\n\n  ```ruby\n  def change\n    create_table :tabld_name do |t|\n      t.integer :column_name, validates: { exclusion: { in: [1, 2, 3] } }\n    end\n  end\n  ```\n\n  or as standalone statements:\n\n  ```ruby\n  def up\n    validates :table_name, :column_name, exclusion: { in: [1, 2, 3] }\n  end\n\n  def down\n    validates :table_name, :column_name, exclusion: false\n  end\n  ```\n\n  the same with failure message:\n\n  ```ruby\n  def up\n    validates :table_name, :column_name,\n      exclusion: {\n        in: [1, 2, 3],\n        message: \"Column 'column_name' should not  be equal to 1 or 2 or 3\" }\n  end\n\n  def down\n    validates :table_name, :column_name, exclusion: false\n  end\n  ```\n\n  as check constraint:\n\n  ```ruby\n  def up\n  validates :table_name, :column_name,\n                         exclusion: { in: [1, 2, 3], as: :check }\n  end\n\n  def down\n    validates :table_name, :column_name, exclusion: false\n  end\n  ```\n\n  as trigger:\n\n  ```ruby\n  def up\n  validates :table_name, :column_name,\n                               exclusion: { in: 1..3,\n                                            on: :create,\n                                            as: :trigger }\n  end\n\n  def down\n    validates :table_name, :column_name, exclusion: false\n  end\n  ```\n\n  all above are available in a create and change table blocks:\n\n  ```ruby\n  def change\n    create_table :table_name do |t|\n       t.integer :column_name, validates: { exclusion: { in: 1..3 } }\n    end\n  end\n  ```\n\n  ```ruby\n  def up\n    change :table_name do |t|\n       t.change :column_name, :integer, validates: { exclusion: { in: 1..3 } }\n    end\n  end\n\n  def down\n    change :table_name do |t|\n       t.change :column_name, :integer, validates: { exclusion: false }\n    end\n  end\n  ```\n\n  simplifications (version \u003e= 2.1 is required):\n\n  ```ruby\n  def change\n    create_table :table_name do |t|\n      t.string :neither_str_nor_str_1, exclusion: ['str', 'str1']\n      t.string :from_str_to_str_1, exclusion: 'str'..'str1'\n      t.string :str_or_str_1_in_trigger, exclusion: { in: ['str', 'str1'],\n                                                      as: :trigger}\n    end\n  end\n  ```\n\n  Options:\n\n  * `:in` - range or array that column value should NOT be contained in.\n  * `:message` - message that should be shown if validation failed. Ignored unless `:as == :trigger`\n  * `:on` -  validation event. Possible values `[:save, :update, :create]`. Ignored unless `:as == :trigger`. Default value: `:save`\n  * `:create_tigger_name` - Name of the 'before insert' trigger that will be created if `:as == :trigger` \u0026\u0026 `:on` in `[:save, :create]`\n  * `:update_tigger_name` - Name of the 'before update' trigger that will be created if `:as == :trigger` \u0026\u0026 `:on` in `[:save, :update]`\n  * `:allow_nil` - ignore validation for `nil` values. Default value: `false`\n  * `:allow_blank` - ignore validation for blank values. Default value: `false`\n  * `:as` - defines the way how constraint will be implemented. Possible values: `[:trigger, :check]` Default value: `:check`\n\n### presence\n\n  Examples:\n\n  ```ruby\n  def up\n    validates :table_name, :column_name, presence: true\n  end\n\n  def down\n    validates :table_name, :column_name, presence: false\n  end\n  ```\n\n  with failure message:\n\n  ```ruby\n  def up\n    validates :table_name, :column_name,\n                    presence: { message: 'value should not be empty' }\n  end\n\n  def down\n    validates :table_name, :column_name, presence: false\n  end\n  ```\n\n  implemented as trigger:\n\n  ```ruby\n  def up\n    validates :table_name, :column_name,\n                    presence: { message: 'value should not be empty',\n                                as: :trigger }\n  end\n\n  def down\n    validates :table_name, :column_name, presence: false\n  end\n  ```\n\n  check when record is inserted only:\n\n  ```ruby\n  def up\n    validates :table_name, :column_name,\n                    presence: { message: 'value should not be empty',\n                                as: :trigger,\n                                on: :create }\n  end\n\n  def down\n    validates :table_name, :column_name, presence: false\n  end\n  ```\n\n  all above are available in a create and change table blocks:\n\n  ```ruby\n  def change\n    create_table :table_name do |t|\n       t.string :column_name, validates: { presence: true }\n    end\n  end\n  ```\n\n  ```ruby\n  def up\n    change :table_name do |t|\n       t.change :column_name, :string, validates: { presence: true }\n    end\n  end\n\n  def down\n    change :table_name do |t|\n       t.change :column_name, :string, validates: { presence: false }\n    end\n  end\n  ```\n\n  simplifications (version \u003e= 2.1 is required):\n\n  ```ruby\n  create_table :table_name do |t|\n    t.string :presence_in_check, presence: true\n    t.string :presence_in_trigger, presence: { as: :trigger, on: :create }\n  end\n  ```\n\n  Options:\n\n  * `message` - message that should be shown if validation failed. Ignored unless `:as == :trigger`\n  * `on` -  validation event. Possible values `[:save, :update, :create]`. Ignored unless `:as == :trigger`. Default value: `:save`\n  * `create_tigger_name` - Name of the 'before insert' trigger that will be created if `:as == :trigger` \u0026\u0026 `:on` in `[:save, :create]`\n  * `update_tigger_name` - Name of the 'before update' trigger that will be created if `:as == :trigger` \u0026\u0026 `:on` in `[:save, :update]`\n  * `allow_nil` - ignore validation for `nil` values. Default value: `false`\n  * `allow_blank` - ignore validation for blank values. Default value: `false`\n  * `as` - defines the way how constraint will be implemented. Possible values: `[:trigger, :check]` Default value: `:check`\n\n### absence\n\n  Examples:\n\n  ```ruby\n  def up\n    validates :table_name, :column_name, absence: true\n  end\n\n  def down\n    validates :table_name, :column_name, absence: false\n  end\n  ```\n\n  with failure message:\n\n  ```ruby\n  def up\n    validates :table_name, :column_name,\n                    absence: { message: 'value should be empty' }\n  end\n\n  def down\n    validates :table_name, :column_name, absence: false\n  end\n  ```\n\n  implemented as trigger:\n\n  ```ruby\n  def up\n    validates :table_name, :column_name,\n                    absence: { message: 'value should be empty',\n                                as: :trigger }\n  end\n\n  def down\n    validates :table_name, :column_name, absence: false\n  end\n  ```\n\n  check when record is inserted only:\n\n  ```ruby\n  def up\n    validates :table_name, :column_name,\n                    absence: { message: 'value should be empty',\n                                as: :trigger,\n                                on: :create }\n  end\n\n  def down\n    validates :table_name, :column_name, absence: false\n  end\n  ```\n\n  all above are available in a create and change table blocks:\n\n  ```ruby\n  def change\n    create_table :table_name do |t|\n       t.string :column_name, validates: { absence: true }\n    end\n  end\n  ```\n\n  ```ruby\n  def up\n    change :table_name do |t|\n       t.change :column_name, :string, validates: { absence: true }\n    end\n  end\n\n  def down\n    change :table_name do |t|\n       t.change :column_name, :string, validates: { absence: false }\n    end\n  end\n  ```\n\n  simplifications (version \u003e= 2.1 is required):\n\n  ```ruby\n  def change\n    create_table :table_name do |t|\n      t.string :absence_in_check, absence: true\n      t.string :absence_in_trigger, absence: { as: :trigger, on: :create }\n    end\n  end\n  ```\n\n  Options:\n\n  * `message` - message that should be shown if validation failed. Ignored unless `:as == :trigger`\n  * `on` -  validation event. Possible values `[:save, :update, :create]`. Ignored unless `:as == :trigger`. Default value: `:save`\n  * `create_tigger_name` - Name of the 'before insert' trigger that will be created if `:as == :trigger` \u0026\u0026 `:on` in `[:save, :create]`\n  * `update_tigger_name` - Name of the 'before update' trigger that will be created if `:as == :trigger` \u0026\u0026 `:on` in `[:save, :update]`\n  * `allow_nil` - ignore validation for `nil` values. Default value: `false`\n  * `allow_blank` - ignore validation for blank values. Default value: `false`\n  * `as` - defines the way how constraint will be implemented. Possible values: `[:trigger, :check]` Default value: `:check`\n\n### format\n\n  Examples:\n\n  allows only values that contains 'word' inside:\n\n  ```ruby\n  def up\n    validates :table_name, :column_name, format: { with: /word/ }\n  end\n\n  def down\n    validates :table_name, :column_name, format: false\n  end\n  ```\n\n  with failure message:\n\n  ```ruby\n  def up\n  validates :table_name, :column_name,\n    format: { with: /word/,\n              message: 'Column_name value should contain start word' }\n  end\n\n  def down\n    validates :table_name, :column_name, format: false\n  end\n  ```\n\n  implemented as trigger:\n\n  ```ruby\n  def up\n    validates :table_name, :column_name,\n      format: { with: /word/,\n                message: 'Column_name value should contain start word',\n                as: :trigger }\n  end\n\n  def down\n    validates :table_name, :column_name, format: false\n  end\n  ```\n\n  all above are available in a create and change table blocks:\n\n  ```ruby\n  def change\n    create_table :table_name do |t|\n      t.string :column_name, validates { format: { with: /word/ } }\n    end\n  end\n  ```\n\n  ```ruby\n  def up\n    change :table_name do |t|\n      t.change :column_name, :string, validates: { format: { with: /word/ } }\n    end\n  end\n\n  def down\n    change :table_name do |t|\n      t.change :column_name, :string, validates: { format: false }\n    end\n  end\n  ```\n\n  simplifications (version \u003e= 2.1 is required):\n\n  ```ruby\n  def change\n    create_table :table_name do |t|\n      t.string :contains_word, format: /word/\n      t.string :contains_word_in_trigger, format: { with: /word/,\n                                                    as: :trigger }\n    end\n  end\n  ```\n\n  Options:\n\n  * `with` - regular expression that column value should be matched to\n  * `message` - message that should be shown if validation failed. Ignored unless `:as == :trigger`\n  * `on` -  validation event. Possible values `[:save, :update, :create]`. Ignored unless `:as == :trigger`. Default value: `:save`\n  * `create_tigger_name` - Name of the 'before insert' trigger that will be created if `:as == :trigger` \u0026\u0026 `:on` in `[:save, :create]`\n  * `update_tigger_name` - Name of the 'before update' trigger that will be created if `:as == :trigger` \u0026\u0026 `:on` in `[:save, :update]`\n  * `allow_nil` - ignore validation for `nil` values. Default value: `false`\n  * `allow_blank` - ignore validation for blank values. Default value: `false`\n  * `as` - defines the way how constraint will be implemented. Possible values: `[:trigger, :check]` Default value: `:check`\n\n### custom\n\n  (version \u003e= 2.1 is required)\n\n  Examples:\n\n  allows only values that contains 'word' inside:\n\n  ```ruby\n  def up\n    validates :table_name, :column_name,\n                        custom: { statement: \"TRIM({column_name}) ~ 'word'\" }\n  end\n\n  def down\n    validates :table_name, :column_name, custom: false\n  end\n  ```\n\n  with failure message:\n\n  ```ruby\n  def up\n    validates :table_name, :column_name,\n      custom: { statement: \"TRIM({column_name}) ~ 'word'\",\n                message: 'Column_name value should contain start word' }\n  end\n\n  def down\n    validates :table_name, :column_name, custom: false\n  end\n  ```\n\n  implemented as trigger:\n\n  ```ruby\n  def up\n    validates :table_name, :column_name,\n      custom: { statement: \"TRIM({column_name}) ~ 'word'\",\n                message: 'Column_name value should contain start word',\n                as: :trigger }\n  end\n\n  def down\n    validates :table_name, :column_name, custom: false\n  end\n  ```\n\n  all above are available in a create and change table blocks:\n\n  ```ruby\n  def change\n    create_table :table_name do |t|\n      t.string :column_name,\n            validates: { custom: { statement: \"TRIM({column_name}) ~ 'word'\"} }\n    end\n  end\n  ```\n\n  ```ruby\n  def up\n    change :table_name do |t|\n      t.change :column_name, :string,\n            validates: { custom: { statement: \"TRIM({column_name}) ~ 'word'\"} }\n    end\n  end\n\n  def down\n    change :table_name do |t|\n      t.change :column_name, :string, validates: { custom: false }\n    end\n  end\n  ```\n\n  simplifications (version \u003e= 2.1 is required):\n\n  ```ruby\n  def change\n    create_table :table_name do |t|\n      t.string :contains_word, custom: \"TRIM({contains_word}) ~ 'word'\"\n      t.string :contains_word_synonym,\n               validates: \"TRIM({contains_word_synonym}) ~ 'word'\"\n      t.string :contains_word_in_trigger,\n            custom: { statement: \"TRIM({contains_word_in_trigger}) ~ 'word'\",\n            as: :trigger }\n    end\n  end\n  ```\n\n  Options:\n\n  * `statement` - db expression that column value should be matched to\n  * `message` - message that should be shown if validation failed. Ignored unless `:as == :trigger`\n  * `on` -  validation event. Possible values `[:save, :update, :create]`. Ignored unless `:as == :trigger`. Default value: `:save`\n  * `create_tigger_name` - Name of the 'before insert' trigger that will be created if `:as == :trigger` \u0026\u0026 `:on` in `[:save, :create]`\n  * `update_tigger_name` - Name of the 'before update' trigger that will be created if `:as == :trigger` \u0026\u0026 `:on` in `[:save, :update]`\n  * `allow_nil` - ignore validation for `nil` values. Default value: `false`\n  * `allow_blank` - ignore validation for blank values. Default value: `false`\n  * `as` - defines the way how constraint will be implemented. Possible values: `[:trigger, :check]` Default value: `:check`\n\n## Version History\n\n**(2.0.0)** (17 Jan, 2015)\n\n* Completely rewritten. Migrated to Ruby 2.0 and RoR 4\n\n**(2.1.0)** (22 Jan, 2015)\n\n* Custom validation\n\n**(2.2.0)** (28 Jan, 2015)\n\n* Integration with ActiveRecord\n\n**(2.2.1)** (29 May, 2015)\n\n* Made it possible to use several mv-* drivers in the same project\n\n**(2.2.2)** (20 Jul, 2015)\n\n* Fix issue with invalid parameters number in `add_column` and `change_column` methods\n\n**(2.2.3)** (23 Nov, 2015)\n\n* Do not camel case column name in error message\n\n**(2.2.4)** (9 Feb, 2016)\n\n* Support booleans in inclusion validator\n\n**(2.2.5)** (23 Feb, 2016)\n\n* Suppress exception while running db:schema:load\n\n**(2.2.7)** (12 Sep, 2016)\n\n* Escape single quotes in the custom validation statement body\n\n**(2.2.8)** (4 Dec, 2018)\n\n* Bump required pg version\n\n## Contributing\n\n* Check out the latest master to make sure the feature hasn't been implemented or the bug hasn't been fixed yet\n* Check out the issue tracker to make sure someone already hasn't requested it and/or contributed it\n* Fork the project\n* Start a feature/bugfix branch\n* Commit and push until you are happy with your contribution\n* Make sure to add tests for it. This is important so I don't break it in a future version unintentionally.\n* Please try not to mess with the Rakefile, version, or history. If you want to have your own version, or is otherwise necessary, that is fine, but please isolate to its own commit so I can cherry-pick around it.\n\n","funding_links":[],"categories":[],"sub_categories":[],"project_url":"https://awesome.ecosyste.ms/api/v1/projects/github.com%2Fvprokopchuk256%2Fmv-postgresql","html_url":"https://awesome.ecosyste.ms/projects/github.com%2Fvprokopchuk256%2Fmv-postgresql","lists_url":"https://awesome.ecosyste.ms/api/v1/projects/github.com%2Fvprokopchuk256%2Fmv-postgresql/lists"}