Ruby on Rails 5.2 - ActiveRecord::ConnectionAdapters::SchemaStatements

मॉड्यूल ActiveRecord :: ConnectionAdapters :: SchemaStatements




ruby

मॉड्यूल ActiveRecord :: ConnectionAdapters :: SchemaStatements

सार्वजनिक प्रवृत्ति के तरीके

add_belongs_to (table_name, Ref_name, ** विकल्प)
इसके लिए उपनाम: add_reference
add_column (table_name, column_name, type, options = {}) स्रोत दिखाएं
# File activerecord/lib/active_record/connection_adapters/abstract/schema_statements.rb, line 578
def add_column(table_name, column_name, type, options = {})
  at = create_alter_table table_name
  at.add_column(column_name, type, options)
  execute schema_creation.accept at
end

एक नया type स्तंभ जोड़ें जिसका नाम column_name से table_name

type पैरामीटर आम तौर पर प्रवासी मूल प्रकारों में से एक है, जो निम्न में से एक है :primary_key :string :text :integer :bigint :float :decimal , :numeric :datetime :time :date :binary :boolean

आप इस सूची में एक प्रकार का उपयोग नहीं कर सकते हैं जब तक कि यह आपके डेटाबेस द्वारा समर्थित हो (उदाहरण के लिए, MySQL में "बहुभुज"), लेकिन यह डेटाबेस अज्ञेय नहीं होगा और आमतौर पर इसे टाला जाना चाहिए।

उपलब्ध विकल्प हैं (इनमें से कोई भी डिफ़ॉल्ट रूप से मौजूद नहीं है):

  • :limit - एक अधिकतम कॉलम लंबाई का अनुरोध करता है। यह एक के लिए वर्णों की संख्या है :string कॉलम और बाइट्स की संख्या के लिए :text :binary और :integer कॉलम। इस विकल्प को कुछ बैकएंड द्वारा अनदेखा किया गया है।

  • :default - कॉलम का डिफ़ॉल्ट मान। NULL लिए nil उपयोग करें।

  • :null - अनुमति देता है या स्तंभ में पूर्ण मान को अस्वीकार करता है।

  • :precision - के लिए सटीक निर्दिष्ट करता है :decimal और :numeric कॉलम।

  • :scale - :decimal और :numeric कॉलम के लिए स्केल निर्दिष्ट करता है।

  • :comment - कॉलम के लिए टिप्पणी निर्दिष्ट करता है। इस विकल्प को कुछ बैकएंड द्वारा अनदेखा किया गया है।

नोट: परिशुद्धता महत्वपूर्ण अंकों की कुल संख्या है, और पैमाने दशमलव अंकों के बाद संग्रहीत किए जाने वाले अंकों की संख्या है। उदाहरण के लिए, संख्या 123.45 में 5 की परिशुद्धता और 2 के पैमाने पर है। 5 की सटीकता के साथ एक दशमलव और 2 के पैमाने पर -999.99 से लेकर 999.99 तक हो सकते हैं।

कृपया विभिन्न RDBMS कार्यान्वयन व्यवहारों से अवगत रहें :decimal कॉलम:

  • SQL मानक कहता है कि डिफ़ॉल्ट स्केल 0 :scale <= :precision होना चाहिए, और :precision की आवश्यकताओं के बारे में कोई टिप्पणी नहीं करता है।

  • MySQL:: :precision [1..63] :scale [0..30]। डिफ़ॉल्ट है (10,0)।

  • PostgreSQL:: :precision [1..infinity] :scale [0..infinity]। डिफ़ॉल्ट नहीं।

  • SQLite3: कोई प्रतिबंध नहीं :precision और :scale , लेकिन अधिकतम समर्थित :precision 16 है। कोई डिफ़ॉल्ट नहीं।

  • ओरेकल:: :precision [1..38] :scale [-84..127]। डिफ़ॉल्ट है (38,0)।

  • DB2:: :precision [1..63] :scale [0..62]। डिफ़ॉल्ट अज्ञात।

  • SqlServer:: :precision [1..38] :scale [0..38]। डिफ़ॉल्ट (38,0)।

उदाहरण

add_column(:users, :picture, :binary, limit: 2.megabytes)
# ALTER TABLE "users" ADD "picture" blob(2097152)

add_column(:articles, :status, :string, limit: 20, default: 'draft', null: false)
# ALTER TABLE "articles" ADD "status" varchar(20) DEFAULT 'draft' NOT NULL

add_column(:answers, :bill_gates_money, :decimal, precision: 15, scale: 2)
# ALTER TABLE "answers" ADD "bill_gates_money" decimal(15,2)

add_column(:measurements, :sensor_reading, :decimal, precision: 30, scale: 20)
# ALTER TABLE "measurements" ADD "sensor_reading" decimal(30,20)

# While :scale defaults to zero on most databases, it
# probably wouldn't hurt to include it.
add_column(:measurements, :huge_integer, :decimal, precision: 30)
# ALTER TABLE "measurements" ADD "huge_integer" decimal(30)

# Defines a column that stores an array of a type.
add_column(:users, :skills, :text, array: true)
# ALTER TABLE "users" ADD "skills" text[]

# Defines a column with a database-specific type.
add_column(:shapes, :triangle, 'polygon')
# ALTER TABLE "shapes" ADD "triangle" polygon
add_foreign_key (from_table, to_table, विकल्प = {}) स्रोत दिखाएं
# File activerecord/lib/active_record/connection_adapters/abstract/schema_statements.rb, line 960
def add_foreign_key(from_table, to_table, options = {})
  return unless supports_foreign_keys?

  options = foreign_key_options(from_table, to_table, options)
  at = create_alter_table from_table
  at.add_foreign_key to_table, options

  execute schema_creation.accept(at)
end

एक नई विदेशी कुंजी जोड़ता है। from_table कुंजी कॉलम के साथ तालिका है, to_table में संदर्भित प्राथमिक कुंजी है।

विदेशी कुंजी को निम्नलिखित पैटर्न के नाम पर रखा जाएगा: fk_rails_<identifier>identifier एक 10 वर्ण लंबा तार है जो नियतात्मक रूप से from_table और column से उत्पन्न होता है। एक कस्टम नाम :name विकल्प के साथ निर्दिष्ट किया जा सकता है।

एक साधारण विदेशी कुंजी बनाना
add_foreign_key :articles, :authors

उत्पन्न करता है:

ALTER TABLE "articles" ADD CONSTRAINT fk_rails_e74ce85cbc FOREIGN KEY ("author_id") REFERENCES "authors" ("id")
एक विशिष्ट कॉलम पर एक विदेशी कुंजी बनाना
add_foreign_key :articles, :users, column: :author_id, primary_key: "lng_id"

उत्पन्न करता है:

ALTER TABLE "articles" ADD CONSTRAINT fk_rails_58ca3d3a82 FOREIGN KEY ("author_id") REFERENCES "users" ("lng_id")
कैस्केडिंग विदेशी कुंजी बनाना
add_foreign_key :articles, :authors, on_delete: :cascade

उत्पन्न करता है:

ALTER TABLE "articles" ADD CONSTRAINT fk_rails_e74ce85cbc FOREIGN KEY ("author_id") REFERENCES "authors" ("id") ON DELETE CASCADE

options हैश में निम्नलिखित कुंजियाँ शामिल हो सकती हैं:

:column

from_table पर विदेशी कुंजी कॉलम नाम। to_table.singularize + "_id" लिए डिफ़ॉल्ट

:primary_key

प्राथमिक कुंजी स्तंभ नाम to_table पर। id लिए चूक।

:name

बाधा नाम। fk_rails_<identifier> लिए डिफ़ॉल्ट।

:on_delete

क्रिया जो ON DELETE । मान्य मान हैं :nullify :cascade और :restrict

:on_update

कार्रवाई जो ON UPDATE । मान्य मान हैं :nullify :cascade और :restrict

:validate

(केवल पोस्टग्रैट्स) निर्दिष्ट करें कि बाधा को मान्य किया जाना चाहिए या नहीं। true अवहेलना।

add_index (table_name, column_name, options = {}) स्रोत दिखाएं
# File activerecord/lib/active_record/connection_adapters/abstract/schema_statements.rb, line 763
def add_index(table_name, column_name, options = {})
  index_name, index_type, index_columns, index_options = add_index_options(table_name, column_name, options)
  execute "CREATE #{index_type} INDEX #{quote_column_name(index_name)} ON #{quote_table_name(table_name)} (#{index_columns})#{index_options}"
end

तालिका में एक नया सूचकांक जोड़ता है। column_name एक एकल Symbol या Symbol एक Symbol हो सकता है।

जब तक आप पास नहीं होते हैं, तब तक तालिका के नाम और स्तंभ का नाम (नाम) सूचकांक का नाम दिया जाएगा।

एक साधारण सूचकांक बनाना
add_index(:suppliers, :name)

उत्पन्न करता है:

CREATE INDEX suppliers_name_index ON suppliers(name)
एक अद्वितीय सूचकांक बनाना
add_index(:accounts, [:branch_id, :party_id], unique: true)

उत्पन्न करता है:

CREATE UNIQUE INDEX accounts_branch_id_party_id_index ON accounts(branch_id, party_id)
एक नामांकित सूचकांक बनाना
add_index(:accounts, [:branch_id, :party_id], unique: true, name: 'by_branch_party')

उत्पन्न करता है:

CREATE UNIQUE INDEX by_branch_party ON accounts(branch_id, party_id)
विशिष्ट कुंजी लंबाई के साथ एक सूचकांक बनाना
add_index(:accounts, :name, name: 'by_name', length: 10)

उत्पन्न करता है:

CREATE INDEX by_name ON accounts(name(10))
कई कुंजी के लिए विशिष्ट कुंजी लंबाई के साथ एक सूचकांक बनाना
add_index(:accounts, [:name, :surname], name: 'by_name_surname', length: {name: 10, surname: 15})

उत्पन्न करता है:

CREATE INDEX by_name_surname ON accounts(name(10), surname(15))

नोट: SQLite सूचकांक लंबाई का समर्थन नहीं करता है।

सॉर्ट क्रम (desc या asc, asc डिफ़ॉल्ट है) के साथ एक इंडेक्स बनाना
add_index(:accounts, [:branch_id, :party_id, :surname], order: {branch_id: :desc, party_id: :asc})

उत्पन्न करता है:

CREATE INDEX by_branch_desc_party ON accounts(branch_id DESC, party_id ASC, surname)

नोट: MySQL केवल 8.0.1 से सूचकांक क्रम का समर्थन करता है (पहले के संस्करणों ने वाक्यविन्यास को स्वीकार किया लेकिन इसे अनदेखा किया)।

आंशिक सूचकांक बनाना
add_index(:accounts, [:branch_id, :party_id], unique: true, where: "active")

उत्पन्न करता है:

CREATE UNIQUE INDEX index_accounts_on_branch_id_and_party_id ON accounts(branch_id, party_id) WHERE active

नोट: आंशिक सूचकांक केवल PostgreSQL और SQLite 3.8.0+ के लिए समर्थित हैं।

एक विशिष्ट विधि के साथ एक सूचकांक बनाना
add_index(:developers, :name, using: 'btree')

उत्पन्न करता है:

CREATE INDEX index_developers_on_name ON developers USING btree (name) -- PostgreSQL
CREATE INDEX index_developers_on_name USING btree ON developers (name) -- MySQL

नोट: केवल PostgreSQL और MySQL द्वारा समर्थित है

एक विशिष्ट ऑपरेटर वर्ग के साथ एक सूचकांक बनाना
add_index(:developers, :name, using: 'gist', opclass: :gist_trgm_ops)
# CREATE INDEX developers_on_name ON developers USING gist (name gist_trgm_ops) -- PostgreSQL

add_index(:developers, [:name, :city], using: 'gist', opclass: { city: :gist_trgm_ops })
# CREATE INDEX developers_on_name_and_city ON developers USING gist (name, city gist_trgm_ops) -- PostgreSQL

add_index(:developers, [:name, :city], using: 'gist', opclass: :gist_trgm_ops)
# CREATE INDEX developers_on_name_and_city ON developers USING gist (name gist_trgm_ops, city gist_trgm_ops) -- PostgreSQL

नोट: केवल PostgreSQL द्वारा समर्थित है

एक विशिष्ट प्रकार के साथ एक सूचकांक बनाना
add_index(:developers, :name, type: :fulltext)

उत्पन्न करता है:

CREATE FULLTEXT INDEX index_developers_on_name ON developers (name) -- MySQL

नोट: केवल MySQL द्वारा समर्थित है।

add_reference (table_name, ref_name, ** विकल्प) स्रोत दिखाएं
# File activerecord/lib/active_record/connection_adapters/abstract/schema_statements.rb, line 873
def add_reference(table_name, ref_name, **options)
  ReferenceDefinition.new(ref_name, options).add_to(update_table_definition(table_name, self))
end

एक संदर्भ जोड़ता है। संदर्भ स्तंभ डिफ़ॉल्ट रूप से एक बड़ा बिंदु है :type एक अलग प्रकार निर्दिष्ट करने के लिए :type विकल्प का उपयोग किया जा सकता है। वैकल्पिक रूप से _type कॉलम जोड़ता है, यदि :polymorphic विकल्प प्रदान किया जाता है। add_reference और add_belongs_to स्वीकार्य हैं।

options हैश में निम्नलिखित कुंजियाँ शामिल हो सकती हैं:

:type

संदर्भ स्तंभ प्रकार। डिफॉल्ट्स :bigint

:index

एक उपयुक्त सूचकांक जोड़ें। सत्य की अवहेलना। इस विकल्प के उपयोग के लिए add_index देखें।

:foreign_key

एक उपयुक्त विदेशी कुंजी बाधा जोड़ें। झूठे की अवहेलना करता है।

:polymorphic

क्या अतिरिक्त _type कॉलम जोड़ा जाना चाहिए। झूठे की अवहेलना करता है।

:null

क्या स्तंभ नल की अनुमति देता है। सत्य की अवहेलना।

एक user_id bigint कॉलम बनाएँ
add_reference(:products, :user)
एक user_id स्ट्रिंग कॉलम बनाएँ
add_reference(:products, :user, type: :string)
सप्लायर_आईडी, सप्लायर_टाइप कॉलम और उपयुक्त इंडेक्स बनाएं
add_reference(:products, :supplier, polymorphic: true, index: true)
एक अद्वितीय सूचकांक के साथ एक सप्लायर_आईडी कॉलम बनाएँ
add_reference(:products, :supplier, index: { unique: true })
एक नामांकित इंडेक्स के साथ एक सप्लायर_आईडी कॉलम बनाएं
add_reference(:products, :supplier, index: { name: "my_supplier_index" })
एक आपूर्तिकर्ता_ कॉलम और उपयुक्त विदेशी कुंजी बनाएँ
add_reference(:products, :supplier, foreign_key: true)
आपूर्तिकर्ता तालिका और फर्मों की तालिका के लिए एक विदेशी कुंजी बनाएं
add_reference(:products, :supplier, foreign_key: {to_table: :firms})
इसके रूप में भी उपनाम: add_belongs_to
add_timestamps (table_name, विकल्प = {}) स्रोत दिखाएं
# File activerecord/lib/active_record/connection_adapters/abstract/schema_statements.rb, line 1115
def add_timestamps(table_name, options = {})
  options[:null] = false if options[:null].nil?

  add_column table_name, :created_at, :datetime, options
  add_column table_name, :updated_at, :datetime, options
end

टाइमस्टैम्प ( created_at और updated_at ) कॉलम को table_name जोड़ता है। अतिरिक्त विकल्प (जैसे :null ) add_column भेजे गए हैं।

add_timestamps(:suppliers, null: true)
मान_माइग्रेटेड_अप्टो_वर्जन (संस्करण, माइग्रेशन_पाथ) शो स्रोत
# File activerecord/lib/active_record/connection_adapters/abstract/schema_statements.rb, line 1037
def assume_migrated_upto_version(version, migrations_paths)
  migrations_paths = Array(migrations_paths)
  version = version.to_i
  sm_table = quote_table_name(ActiveRecord::SchemaMigration.table_name)

  migrated = ActiveRecord::SchemaMigration.all_versions.map(&:to_i)
  versions = migration_context.migration_files.map do |file|
    migration_context.parse_migration_filename(file).first.to_i
  end

  unless migrated.include?(version)
    execute "INSERT INTO #{sm_table} (version) VALUES (#{quote(version)})"
  end

  inserting = (versions - migrated).select { |v| v < version }
  if inserting.any?
    if (duplicate = inserting.detect { |v| inserting.count(v) > 1 })
      raise "Duplicate migration #{duplicate}. Please renumber your migrations to resolve the conflict."
    end
    if supports_multi_insert?
      execute insert_versions_sql(inserting)
    else
      inserting.each do |v|
        execute insert_versions_sql(v)
      end
    end
  end
end
change_column (table_name, column_name, प्रकार, विकल्प = {}) स्रोत दिखाएं
# File activerecord/lib/active_record/connection_adapters/abstract/schema_statements.rb, line 612
def change_column(table_name, column_name, type, options = {})
  raise NotImplementedError, "change_column is not implemented"
end

नए विकल्पों के अनुसार कॉलम की परिभाषा को बदल देता है। ActiveRecord::ConnectionAdapters::TableDefinition#column उन विकल्पों के विवरण के लिए देखें जिनका आप उपयोग कर सकते हैं।

change_column(:suppliers, :name, :string, limit: 80)
change_column(:accounts, :description, :text)
change_column_comment (table_name, column_name, टिप्पणी) स्रोत दिखाएँ
# File activerecord/lib/active_record/connection_adapters/abstract/schema_statements.rb, line 1177
def change_column_comment(table_name, column_name, comment)
  raise NotImplementedError, "#{self.class} does not support changing column comments"
end

एक स्तंभ के लिए टिप्पणी को बदलता है या इसे हटा देता है यदि nil

change_column_default (table_name, column_name, default_or_changes) स्रोत दिखाएं
# File activerecord/lib/active_record/connection_adapters/abstract/schema_statements.rb, line 630
def change_column_default(table_name, column_name, default_or_changes)
  raise NotImplementedError, "change_column_default is not implemented"
end

एक कॉलम के लिए एक नया डिफ़ॉल्ट मान सेट करता है:

change_column_default(:suppliers, :qualification, 'new')
change_column_default(:accounts, :authorized, 1)

डिफ़ॉल्ट रूप से nil सेट करने से डिफ़ॉल्ट रूप से ड्रॉप हो जाता है:

change_column_default(:users, :email, nil)

पास होने वाला हैश :from और :to इस परिवर्तन को प्रवास में प्रतिवर्ती बना देगा:

change_column_default(:posts, :state, from: nil, to: "draft")
change_column_null (table_name, column_name, null, default = nil) स्रोत दिखाएँ
# File activerecord/lib/active_record/connection_adapters/abstract/schema_statements.rb, line 650
def change_column_null(table_name, column_name, null, default = nil)
  raise NotImplementedError, "change_column_null is not implemented"
end

सेट या एक स्तंभ पर NOT NULL बाधा को हटा। null ध्वज इंगित करता है कि क्या मान NULL हो सकता NULL । उदाहरण के लिए

change_column_null(:users, :nickname, false)

कहते हैं कि उपनाम NULL (बाधा नहीं जोड़ता) हो सकता है, जबकि

change_column_null(:users, :nickname, true)

उन्हें NULL होने देता NULL (अड़चनें गिराता है)।

मौजूदा NULL को कुछ अन्य मान से बदलने के लिए विधि एक वैकल्पिक चौथे तर्क को स्वीकार करती है। यदि जरूरत पड़ने पर बाधा को सक्षम करने के लिए उस का उपयोग करें, अन्यथा वे पंक्तियाँ मान्य नहीं होंगी।

कृपया ध्यान दें कि चौथा तर्क कॉलम के डिफ़ॉल्ट को सेट नहीं करता है।

change_table (table_name, विकल्प = {}) {| update_table_definition (table_name, रिकॉर्डर) | ...} स्रोत दिखाएं
# File activerecord/lib/active_record/connection_adapters/abstract/schema_statements.rb, line 465
def change_table(table_name, options = {})
  if supports_bulk_alter? && options[:bulk]
    recorder = ActiveRecord::Migration::CommandRecorder.new(self)
    yield update_table_definition(table_name, recorder)
    bulk_change_table(table_name, recorder.commands)
  else
    yield update_table_definition(table_name, self)
  end
end

table में कॉलम बदलने के लिए एक ब्लॉक।

# change_table() yields a Table instance
change_table(:suppliers) do |t|
  t.column :name, :string, limit: 60
  # Other column alterations here
end

options हैश में निम्नलिखित कुंजियाँ शामिल हो सकती हैं:

:bulk

इसे इस तरह बदलने के लिए सही पर सेट करें, जैसे कि एक बल्क परिवर्तन क्वेरी

ALTER TABLE `users` ADD COLUMN age INT, ADD COLUMN birthdate DATETIME ...

झूठे की अवहेलना करता है।

केवल MySQL और PostgreSQL एडॉप्टर पर समर्थित, अन्यत्र अनदेखा किया गया।

एक कॉलम जोड़ें
change_table(:suppliers) do |t|
  t.column :name, :string, limit: 60
end
2 पूर्णांक कॉलम जोड़ें
change_table(:suppliers) do |t|
  t.integer :width, :height, null: false, default: 0
end
Create_at / updated_at कॉलम जोड़ें
change_table(:suppliers) do |t|
  t.timestamps
end
एक विदेशी कुंजी कॉलम जोड़ें
change_table(:suppliers) do |t|
  t.references :company
end

एक company_id(bigint) कॉलम बनाता है।

एक बहुरूपिक विदेशी कुंजी कॉलम जोड़ें
change_table(:suppliers) do |t|
  t.belongs_to :company, polymorphic: true
end

company_type(varchar) और company_id(bigint) कॉलम बनाता है।

एक कॉलम निकालें
change_table(:suppliers) do |t|
  t.remove :company
end
कई कॉलम निकालें
change_table(:suppliers) do |t|
  t.remove :company_id
  t.remove :width, :height
end
एक सूचकांक निकालें
change_table(:suppliers) do |t|
  t.remove_index :company_id
end

सभी स्तंभों के विभिन्न परिवर्तनों के विवरण के लिए Table भी देखें।

change_table_comment (table_name, टिप्पणी) स्रोत दिखाएं
# File activerecord/lib/active_record/connection_adapters/abstract/schema_statements.rb, line 1172
def change_table_comment(table_name, comment)
  raise NotImplementedError, "#{self.class} does not support changing table comments"
end

एक तालिका के लिए टिप्पणी को बदल देता है या nil हटा देता है।

column_exists? (table_name, column_name, प्रकार = nil, विकल्प = {}) स्रोत दिखाएं
# File activerecord/lib/active_record/connection_adapters/abstract/schema_statements.rb, line 132
def column_exists?(table_name, column_name, type = nil, options = {})
  column_name = column_name.to_s
  checks = []
  checks << lambda { |c| c.name == column_name }
  checks << lambda { |c| c.type == type } if type
  column_options_keys.each do |attr|
    checks << lambda { |c| c.send(attr) == options[attr] } if options.key?(attr)
  end

  columns(table_name).any? { |c| checks.all? { |check| check[c] } }
end

यह देखने के लिए जाँच करता है कि क्या किसी तालिका में एक स्तंभ मौजूद है।

# Check a column exists
column_exists?(:suppliers, :name)

# Check a column exists of a particular type
column_exists?(:suppliers, :name, :string)

# Check a column exists with a specific definition
column_exists?(:suppliers, :name, :string, limit: 100)
column_exists?(:suppliers, :name, :string, default: 'default')
column_exists?(:suppliers, :name, :string, null: false)
column_exists?(:suppliers, :tax, :decimal, precision: 8, scale: 2)
कॉलम (तालिका_नाम) स्रोत दिखाएं
# File activerecord/lib/active_record/connection_adapters/abstract/schema_statements.rb, line 111
def columns(table_name)
  table_name = table_name.to_s
  column_definitions(table_name).map do |field|
    new_column_from_field(table_name, field)
  end
end

table_name द्वारा निर्दिष्ट तालिका के लिए Column ऑब्जेक्ट्स की एक सरणी लौटाता है।

create_join_table (table_1, table_2, column_options: {}, ** विकल्प) {| td | ...} स्रोत दिखाएं
# File activerecord/lib/active_record/connection_adapters/abstract/schema_statements.rb, line 368
def create_join_table(table_1, table_2, column_options: {}, **options)
  join_table_name = find_join_table_name(table_1, table_2, options)

  column_options.reverse_merge!(null: false, index: false)

  t1_ref, t2_ref = [table_1, table_2].map { |t| t.to_s.singularize }

  create_table(join_table_name, options.merge!(id: false)) do |td|
    td.references t1_ref, column_options
    td.references t2_ref, column_options
    yield td if block_given?
  end
end

पहले दो तर्कों के शाब्दिक क्रम का उपयोग करके बनाए गए नाम के साथ एक नई ज्वाइन टेबल बनाता है। ये तर्क एक String या एक Symbol

# Creates a table called 'assemblies_parts' with no id.
create_join_table(:assemblies, :parts)

आप एक options हैश पास कर सकते हैं जिसमें निम्नलिखित कुंजियाँ शामिल हो सकती हैं:

:table_name

डिफ़ॉल्ट को ओवरराइड करते हुए तालिका नाम सेट करता है।

:column_options

कॉलम परिभाषा में आप जो भी अतिरिक्त विकल्प चाहते हैं।

:options

कोई भी अतिरिक्त विकल्प जिसे आप तालिका परिभाषा में संलग्न करना चाहते हैं।

:temporary

एक अस्थायी तालिका बनाएं।

:force

इसे बनाने से पहले तालिका को छोड़ने के लिए सही पर सेट करें। झूठे की अवहेलना करता है।

ध्यान दें कि create_join_table डिफ़ॉल्ट रूप से कोई सूचकांक नहीं बनाता है; ऐसा करने के लिए आप इसके ब्लॉक फॉर्म का उपयोग कर सकते हैं:

create_join_table :products, :categories do |t|
  t.index :product_id
  t.index :category_id
end
उत्पन्न SQL (MySQL) के लिए बैकएंड विशिष्ट विकल्प जोड़ें
create_join_table(:assemblies, :parts, options: 'ENGINE=InnoDB DEFAULT CHARSET=utf8')

उत्पन्न करता है:

CREATE TABLE assemblies_parts (
  assembly_id bigint NOT NULL,
  part_id bigint NOT NULL,
) ENGINE=InnoDB DEFAULT CHARSET=utf8
create_table (table_name, टिप्पणी: nil, ** विकल्प) {| td | ...} स्रोत दिखाएं
# File activerecord/lib/active_record/connection_adapters/abstract/schema_statements.rb, line 290
def create_table(table_name, comment: nil, **options)
  td = create_table_definition table_name, options[:temporary], options[:options], options[:as], comment: comment

  if options[:id] != false && !options[:as]
    pk = options.fetch(:primary_key) do
      Base.get_primary_key table_name.to_s.singularize
    end

    if pk.is_a?(Array)
      td.primary_keys pk
    else
      td.primary_key pk, options.fetch(:id, :primary_key), options
    end
  end

  yield td if block_given?

  if options[:force]
    drop_table(table_name, **options, if_exists: true)
  end

  result = execute schema_creation.accept td

  unless supports_indexes_in_create?
    td.indexes.each do |column_name, index_options|
      add_index(table_name, column_name, index_options)
    end
  end

  if supports_comments? && !supports_comments_in_create?
    change_table_comment(table_name, comment) if comment.present?

    td.columns.each do |column|
      change_column_comment(table_name, column.name, column.comment) if column.comment.present?
    end
  end

  result
end

नेम table_name साथ एक नया टेबल बनाता है। table_name String या Symbol हो सकता है।

create_table साथ काम करने के दो तरीके हैं। आप ब्लॉक फॉर्म या रेगुलर फॉर्म का उपयोग कर सकते हैं, जैसे:

ब्लॉक का रूप

# create_table() passes a TableDefinition object to the block.
# This form will not only create the table, but also columns for the
# table.

create_table(:suppliers) do |t|
  t.column :name, :string, limit: 60
  # Other fields here
end

ब्लॉक फॉर्म, शॉर्टहैंड के साथ

# You can also use the column types as method calls, rather than calling the column method.
create_table(:suppliers) do |t|
  t.string :name, limit: 60
  # Other fields here
end

नियमित रूप

# Creates a table called 'suppliers' with no columns.
create_table(:suppliers)
# Add a column to 'suppliers'.
add_column(:suppliers, :name, :string, {limit: 60})

options हैश में निम्नलिखित कुंजियाँ शामिल हो सकती हैं:

:id

चाहे स्वचालित रूप से एक प्राथमिक कुंजी कॉलम जोड़ना हो। सत्य की अवहेलना। ActiveRecord::Base.has_and_belongs_to_many लिए तालिकाओं में शामिल हों ActiveRecord::Base.has_and_belongs_to_many को इसे गलत पर सेट करना चाहिए।

एक Symbol का उपयोग उत्पन्न प्राथमिक कुंजी कॉलम के प्रकार को निर्दिष्ट करने के लिए किया जा सकता है।

:primary_key

प्राथमिक कुंजी का नाम, यदि किसी को स्वचालित रूप से जोड़ा जाना है। id लिए चूक। यदि :id गलत है, तो इस विकल्प को अनदेखा कर दिया जाता है।

यदि कोई सरणी पास हो गई है, तो एक समग्र प्राथमिक कुंजी बनाई जाएगी।

ध्यान दें कि सक्रिय रिकॉर्ड मॉडल स्वचालित रूप से अपनी प्राथमिक कुंजी का पता लगाएगा। स्पष्ट रूप से कुंजी को परिभाषित करने के लिए मॉडल पर self.primary_key= का उपयोग करके इसे टाला जा सकता है।

:options

कोई भी अतिरिक्त विकल्प जिसे आप तालिका परिभाषा में संलग्न करना चाहते हैं।

:temporary

एक अस्थायी तालिका बनाएं।

:force

इसे बनाने से पहले तालिका को छोड़ने के लिए सही पर सेट करें। सेट करें :cascade निर्भर वस्तुओं को भी छोड़ने के लिए :cascade । झूठे की अवहेलना करता है।

:as

तालिका उत्पन्न करने के लिए एसक्यूएल। जब इस विकल्प का उपयोग किया जाता है, तो ब्लॉक को नजरअंदाज कर दिया जाता है, जैसे :id और :primary_key विकल्प।

उत्पन्न SQL (MySQL) के लिए बैकएंड विशिष्ट विकल्प जोड़ें
create_table(:suppliers, options: 'ENGINE=InnoDB DEFAULT CHARSET=utf8')

उत्पन्न करता है:

CREATE TABLE suppliers (
  id bigint auto_increment PRIMARY KEY
) ENGINE=InnoDB DEFAULT CHARSET=utf8
प्राथमिक कुंजी कॉलम का नाम बदलें
create_table(:objects, primary_key: 'guid') do |t|
  t.column :name, :string, limit: 80
end

उत्पन्न करता है:

CREATE TABLE objects (
  guid bigint auto_increment PRIMARY KEY,
  name varchar(80)
)
प्राथमिक कुंजी कॉलम प्रकार बदलें
create_table(:tags, id: :string) do |t|
  t.column :label, :string
end

उत्पन्न करता है:

CREATE TABLE tags (
  id varchar PRIMARY KEY,
  label varchar
)
एक संयुक्त प्राथमिक कुंजी बनाएँ
create_table(:orders, primary_key: [:product_id, :client_id]) do |t|
  t.belongs_to :product
  t.belongs_to :client
end

उत्पन्न करता है:

CREATE TABLE order (
    product_id bigint NOT NULL,
    client_id bigint NOT NULL
);

ALTER TABLE ONLY "orders"
  ADD CONSTRAINT orders_pkey PRIMARY KEY (product_id, client_id);
एक प्राथमिक कुंजी कॉलम न जोड़ें
create_table(:categories_suppliers, id: false) do |t|
  t.column :category_id, :bigint
  t.column :supplier_id, :bigint
end

उत्पन्न करता है:

CREATE TABLE categories_suppliers (
  category_id bigint,
  supplier_id bigint
)
एक क्वेरी के आधार पर एक अस्थायी तालिका बनाएं
create_table(:long_query, temporary: true,
  as: "SELECT * FROM orders INNER JOIN line_items ON order_id=orders.id")

उत्पन्न करता है:

CREATE TEMPORARY TABLE long_query AS
  SELECT * FROM orders INNER JOIN line_items ON order_id=orders.id

ActiveRecord::ConnectionAdapters::TableDefinition#column भी देखें ActiveRecord::ConnectionAdapters::TableDefinition#column बनाने के तरीके के विवरण के लिए।

data_source_exists? (नाम) स्रोत दिखाएँ
# File activerecord/lib/active_record/connection_adapters/abstract/schema_statements.rb, line 45
def data_source_exists?(name)
  query_values(data_source_sql(name), "SCHEMA").any? if name.present?
rescue NotImplementedError
  data_sources.include?(name.to_s)
end

डेटाबेस पर डेटा स्रोत का name मौजूद है या नहीं यह देखने के लिए जाँच करता है।

data_source_exists?(:ebooks)
# File activerecord/lib/active_record/connection_adapters/abstract/schema_statements.rb, line 35
def data_sources
  query_values(data_source_sql, "SCHEMA")
rescue NotImplementedError
  tables | views
end

सक्रिय रिकॉर्ड मॉडल वापस करने के लिए उपयोग करने योग्य नाम देता है। अधिकांश एडेप्टर के लिए इसका मतलब सभी tables और views

drop_join_table (table_1, table_2, विकल्प = {}) स्रोत दिखाएं
# File activerecord/lib/active_record/connection_adapters/abstract/schema_statements.rb, line 388
def drop_join_table(table_1, table_2, options = {})
  join_table_name = find_join_table_name(table_1, table_2, options)
  drop_table(join_table_name)
end

दिए गए तर्कों द्वारा निर्दिष्ट ज्वाइन टेबल को गिराता है। विवरण के लिए create_join_table देखें।

यद्यपि यह आदेश ब्लॉक को अनदेखा करता है यदि एक दिया जाता है, तो यह प्रवास के change विधि में एक प्रदान करने में सहायक हो सकता है ताकि इसे वापस लाया जा सके। उस स्थिति में, ब्लॉक का उपयोग create_join_table द्वारा किया जाएगा।

drop_table (table_name, विकल्प = {}) स्रोत दिखाएं
# File activerecord/lib/active_record/connection_adapters/abstract/schema_statements.rb, line 495
def drop_table(table_name, options = {})
  execute "DROP TABLE#{' IF EXISTS' if options[:if_exists]} #{quote_table_name(table_name)}"
end

डेटाबेस से एक टेबल गिरता है।

:force

सेट करें :cascade निर्भर वस्तुओं को भी छोड़ने के लिए :cascade । झूठे की अवहेलना करता है।

:if_exists

यदि यह मौजूद है तो केवल तालिका को गिराने के लिए true पर सेट करें। झूठे की अवहेलना करता है।

यद्यपि यह आदेश अधिकांश options अनदेखा करता है और यदि ब्लॉक दिया जाता है, तो यह इनको माइग्रेशन के change विधि में प्रदान करने में सहायक हो सकता है, इसलिए इसे वापस लाया जा सकता है। उस स्थिति में, options और ब्लॉक का उपयोग create_table द्वारा किया जाएगा।

foreign_key_exists? (from_table, options_or_to_table = {}) स्रोत दिखाएं
# File activerecord/lib/active_record/connection_adapters/abstract/schema_statements.rb, line 1010
def foreign_key_exists?(from_table, options_or_to_table = {})
  foreign_key_for(from_table, options_or_to_table).present?
end

यह देखने के लिए जाँच करता है कि क्या दी गई विदेशी कुंजी परिभाषा के लिए एक टेबल पर एक विदेशी कुंजी मौजूद है।

# Checks to see if a foreign key exists.
foreign_key_exists?(:accounts, :branches)

# Checks to see if a foreign key on a specified column exists.
foreign_key_exists?(:accounts, column: :owner_id)

# Checks to see if a foreign key with a custom name exists.
foreign_key_exists?(:accounts, name: "special_fk_name")
Foreign_keys (table_name) स्रोत दिखाएं
# File activerecord/lib/active_record/connection_adapters/abstract/schema_statements.rb, line 912
def foreign_keys(table_name)
  raise NotImplementedError, "foreign_keys is not implemented"
end

दी गई तालिका के लिए विदेशी कुंजियों की एक सरणी देता है। विदेशी कुंजियों का प्रतिनिधित्व ForeignKeyDefinition ऑब्जेक्ट्स के रूप में किया जाता है।

index_exists? (table_name, column_name, विकल्प = {}) स्रोत दिखाएं
# File activerecord/lib/active_record/connection_adapters/abstract/schema_statements.rb, line 100
def index_exists?(table_name, column_name, options = {})
  column_names = Array(column_name).map(&:to_s)
  checks = []
  checks << lambda { |i| i.columns == column_names }
  checks << lambda { |i| i.unique } if options[:unique]
  checks << lambda { |i| i.name == options[:name].to_s } if options[:name]

  indexes(table_name).any? { |i| checks.all? { |check| check[i] } }
end

यह देखने के लिए जाँच करता है कि क्या दी गई इंडेक्स परिभाषा के लिए कोई इंडेक्स टेबल पर मौजूद है।

# Check an index exists
index_exists?(:suppliers, :company_id)

# Check an index on multiple columns exists
index_exists?(:suppliers, [:company_id, :company_type])

# Check a unique index exists
index_exists?(:suppliers, :company_id, unique: true)

# Check an index with a custom name exists
index_exists?(:suppliers, :company_id, name: "idx_company_id")
index_name_exists? (table_name, index_name) स्रोत दिखाएं
# File activerecord/lib/active_record/connection_adapters/abstract/schema_statements.rb, line 822
def index_name_exists?(table_name, index_name)
  index_name = index_name.to_s
  indexes(table_name).detect { |i| i.name == index_name }
end

किसी दिए गए नाम के साथ एक सूचकांक के अस्तित्व की पुष्टि करता है।

अनुक्रमित (तालिका_नाम) स्रोत दिखाएं
# File activerecord/lib/active_record/connection_adapters/abstract/schema_statements.rb, line 82
def indexes(table_name)
  raise NotImplementedError, "#indexes is not implemented"
end

दी गई तालिका के लिए अनुक्रमित की एक सरणी देता है।

native_database_types () स्रोत दिखाएं
# File activerecord/lib/active_record/connection_adapters/abstract/schema_statements.rb, line 15
def native_database_types
  {}
end

मूल डेटा प्रकारों के सार डेटा प्रकारों से मैपिंग का एक हैश लौटाता है। ActiveRecord::ConnectionAdapters::TableDefinition#column को मान्यताप्राप्त अमूर्त डेटा प्रकारों के विवरण के लिए देखें।

options_include_default? (विकल्प) स्रोत दिखाएँ
# File activerecord/lib/active_record/connection_adapters/abstract/schema_statements.rb, line 1167
def options_include_default?(options)
  options.include?(:default) && !(options[:null] == false && options[:default].nil?)
end
प्राथमिक_की (table_name) स्रोत दिखाएं
# File activerecord/lib/active_record/connection_adapters/abstract/schema_statements.rb, line 145
def primary_key(table_name)
  pk = primary_keys(table_name)
  pk = pk.first unless pk.size > 1
  pk
end

सिर्फ एक टेबल की प्राथमिक कुंजी देता है

remove_belongs_to (table_name, Ref_name, विदेशी_की: झूठी, बहुरूपिया: गलत, ** विकल्प)
इसके लिए उपनाम: remove_reference
remove_column (table_name, column_name, type = nil, options = {}) स्रोत दिखाएं
# File activerecord/lib/active_record/connection_adapters/abstract/schema_statements.rb, line 602
def remove_column(table_name, column_name, type = nil, options = {})
  execute "ALTER TABLE #{quote_table_name(table_name)} #{remove_column_for_alter(table_name, column_name, type, options)}"
end

तालिका परिभाषा से स्तंभ निकालता है।

remove_column(:suppliers, :qualification)

यदि मौजूद है तो type और options मापदंडों को नजरअंदाज कर दिया जाएगा। यह एक प्रवास change विधि में इन्हें प्रदान करने में सहायक हो सकता है ताकि इसे वापस लाया जा सके। उस स्थिति में, type और options add_column द्वारा उपयोग किए add_column

Remove_columns (table_name, * column_names) स्रोत दिखाएँ
# File activerecord/lib/active_record/connection_adapters/abstract/schema_statements.rb, line 588
def remove_columns(table_name, *column_names)
  raise ArgumentError.new("You must specify at least one column name. Example: remove_columns(:people, :first_name)") if column_names.empty?
  column_names.each do |column_name|
    remove_column(table_name, column_name)
  end
end

तालिका परिभाषा से दिए गए स्तंभों को निकालता है।

remove_columns(:suppliers, :qualification, :experience)
remove_foreign_key (from_table, options_or_to_table = {}) स्रोत दिखाएं
# File activerecord/lib/active_record/connection_adapters/abstract/schema_statements.rb, line 988
def remove_foreign_key(from_table, options_or_to_table = {})
  return unless supports_foreign_keys?

  fk_name_to_delete = foreign_key_for!(from_table, options_or_to_table).name

  at = create_alter_table from_table
  at.drop_foreign_key fk_name_to_delete

  execute schema_creation.accept(at)
end

दी गई विदेशी कुंजी को तालिका से निकालता है। माइग्रेशन रोलबैक के मामले में विदेशी कुंजी को फिर से जोड़ने के लिए प्रदान किए गए किसी भी विकल्प पैरामीटर का उपयोग किया जाएगा। यह अनुशंसा की जाती है कि आप विदेशी कुंजी बनाते समय उपयोग किए जाने वाले किसी भी विकल्प को प्रदान करते हैं ताकि माइग्रेशन ठीक से वापस हो सके।

accounts.branch_id पर विदेशी कुंजी निकालता है।

remove_foreign_key :accounts, :branches

accounts.owner_id पर विदेशी कुंजी निकालता है ।owner_id

remove_foreign_key :accounts, column: :owner_id

accounts टेबल पर special_fk_name नाम की विदेशी कुंजी को हटाता है।

remove_foreign_key :accounts, name: :special_fk_name

options हैश #add_foreign_key के समान कुंजियाँ स्वीकार करता है।

remove_index (table_name, विकल्प = {}) स्रोत दिखाएं
# File activerecord/lib/active_record/connection_adapters/abstract/schema_statements.rb, line 786
def remove_index(table_name, options = {})
  index_name = index_name_for_remove(table_name, options)
  execute "DROP INDEX #{quote_column_name(index_name)} ON #{quote_table_name(table_name)}"
end

दिए गए इंडेक्स को टेबल से हटाता है।

तालिका branch_id में अनुक्रमणिका को निकालता है accounts यदि वास्तव में ऐसा एक सूचकांक मौजूद है।

remove_index :accounts, :branch_id

तालिका branch_id में अनुक्रमणिका को निकालता है accounts यदि वास्तव में ऐसा एक सूचकांक मौजूद है।

remove_index :accounts, column: :branch_id

यदि तालिका में वास्तव में एक ऐसा सूचकांक मौजूद है, तो सूचकांक को branch_id और तालिका party_id में हटा accounts देता है।

remove_index :accounts, column: [:branch_id, :party_id]

तालिका by_branch_party में नामित सूचकांक को निकालता है accounts

remove_index :accounts, name: :by_branch_party
remove_reference (table_name, Ref_name, Foreign_key: false, बहुरूपी: गलत, ** विकल्प) स्रोत दिखाएं
# File activerecord/lib/active_record/connection_adapters/abstract/schema_statements.rb, line 893
def remove_reference(table_name, ref_name, foreign_key: false, polymorphic: false, **options)
  if foreign_key
    reference_name = Base.pluralize_table_names ? ref_name.to_s.pluralize : ref_name
    if foreign_key.is_a?(Hash)
      foreign_key_options = foreign_key
    else
      foreign_key_options = { to_table: reference_name }
    end
    foreign_key_options[:column] ||= "#{ref_name}_id"
    remove_foreign_key(table_name, **foreign_key_options)
  end

  remove_column(table_name, "#{ref_name}_id")
  remove_column(table_name, "#{ref_name}_type") if polymorphic
end

संदर्भ निकालता है। type यदि कोई मौजूद है, तो एक कॉलम भी निकालता है। remove_reference और remove_belongs_to स्वीकार्य हैं।

संदर्भ निकालें
remove_reference(:products, :user, index: true)
बहुरंगी संदर्भ निकालें
remove_reference(:products, :supplier, polymorphic: true)
एक विदेशी कुंजी के साथ संदर्भ निकालें
remove_reference(:products, :user, index: true, foreign_key: true)
इसके अलावा उपनाम: remove_belongs_to
remove_timestamps (table_name, विकल्प = {}) स्रोत दिखाएं
# File activerecord/lib/active_record/connection_adapters/abstract/schema_statements.rb, line 1126
def remove_timestamps(table_name, options = {})
  remove_column table_name, :updated_at
  remove_column table_name, :created_at
end

तालिका परिभाषा से टाइमस्टैम्प कॉलम ( created_at और updated_at ) को निकालता है ।

remove_timestamps(:suppliers)
rename_column (table_name, column_name, new_column_name) स्रोत दिखाएं
# File activerecord/lib/active_record/connection_adapters/abstract/schema_statements.rb, line 658
def rename_column(table_name, column_name, new_column_name)
  raise NotImplementedError, "rename_column is not implemented"
end

एक स्तंभ का नाम बदल देता है।

rename_column(:suppliers, :description, :name)
rename_index (table_name, old_name, new_name) स्रोत दिखाएं
# File activerecord/lib/active_record/connection_adapters/abstract/schema_statements.rb, line 797
def rename_index(table_name, old_name, new_name)
  validate_index_length!(table_name, new_name)

  # this is a naive implementation; some DBs may support this more efficiently (PostgreSQL, for instance)
  old_index_def = indexes(table_name).detect { |i| i.name == old_name }
  return unless old_index_def
  add_index(table_name, old_index_def.columns, name: new_name, unique: old_index_def.unique)
  remove_index(table_name, name: old_name)
end

एक सूचकांक का नाम बदल देता है।

index_people_on_last_name सूचकांक का नाम बदलें index_users_on_last_name :

rename_index :people, 'index_people_on_last_name', 'index_users_on_last_name'
rename_table (table_name, new_name) स्रोत दिखाएं
# File activerecord/lib/active_record/connection_adapters/abstract/schema_statements.rb, line 479
def rename_table(table_name, new_name)
  raise NotImplementedError, "rename_table is not implemented"
end

एक मेज का नाम बदल दिया।

rename_table('octopuses', 'octopi')
table_alias_for (table_name) स्रोत दिखाएं
# File activerecord/lib/active_record/connection_adapters/abstract/schema_statements.rb, line 29
def table_alias_for(table_name)
  table_name[0...table_alias_length].tr(".", "_")
end

वर्तमान एडेप्टर की सीमा के अनुसार एक तालिका उपनाम को ट्रंकुकेट करता है।

table_comment (table_name) स्रोत दिखाएं
# File activerecord/lib/active_record/connection_adapters/abstract/schema_statements.rb, line 24
def table_comment(table_name)
  nil
end

डेटाबेस मेटाडेटा में संग्रहीत तालिका टिप्पणी देता है।

table_exists? (table_name) स्रोत दिखाएं
# File activerecord/lib/active_record/connection_adapters/abstract/schema_statements.rb, line 60
def table_exists?(table_name)
  query_values(data_source_sql(table_name, type: "BASE TABLE"), "SCHEMA").any? if table_name.present?
rescue NotImplementedError
  tables.include?(table_name.to_s)
end

table_name डेटाबेस पर तालिका मौजूद है या नहीं यह देखने के लिए जाँच करता है ।

table_exists?(:developers)
table_options (table_name) स्रोत दिखाएं
# File activerecord/lib/active_record/connection_adapters/abstract/schema_statements.rb, line 19
def table_options(table_name)
  nil
end
तालिकाओं () दिखाएँ स्रोत
# File activerecord/lib/active_record/connection_adapters/abstract/schema_statements.rb, line 52
def tables
  query_values(data_source_sql(type: "BASE TABLE"), "SCHEMA")
end

डेटाबेस में परिभाषित सारणी नामों की एक सरणी देता है।

view_exists? (view_name) स्रोत दिखाएं
# File activerecord/lib/active_record/connection_adapters/abstract/schema_statements.rb, line 75
def view_exists?(view_name)
  query_values(data_source_sql(view_name, type: "VIEW"), "SCHEMA").any? if view_name.present?
rescue NotImplementedError
  views.include?(view_name.to_s)
end

देखने के लिए जाँचता है कि क्या दृश्य view_name डेटाबेस पर मौजूद है।

view_exists?(:ebooks)
# File activerecord/lib/active_record/connection_adapters/abstract/schema_statements.rb, line 67
def views
  query_values(data_source_sql(type: "VIEW"), "SCHEMA")
end

डेटाबेस में परिभाषित नाम नामों की एक सरणी देता है।

Original text