Hier is een voorbeeld van Ruby-code die gebruikmaakt van ActiveRecord om te werken met een PostgreSQL-database en de bewerkingen uit te voeren op een 'producten' tabel: 1. Setup en configuratie: ```ruby # Gemfile gem 'activerecord', '~> 7.0' gem 'pg' ``` Voer daarna `bundle install` uit. 2. Database configuratie: ```ruby require 'active_record' ActiveRecord::Base.establish_connection( adapter: 'postgresql', host: 'localhost', database: 'jouw_database_naam', username: 'jouw_gebruikersnaam', password: 'jouw_wachtwoord' ) ``` 3. Definieer het model: ```ruby class Product < ActiveRecord::Base self.table_name = 'producten' # indien de tabelnaam anders is end ``` 4. Voorbeeld bewerkingen: - Gegevens ophalen: ```ruby # Alle producten producten = Product.all # Specifiek product ophalen product = Product.find_by(id: 1) ``` - Toevoegen: ```ruby nieuw_product = Product.create( naam: 'Nieuwe Productnaam', prijs: 19.99, voorraad: 50 ) ``` - Bijwerken: ```ruby product = Product.find_by(id: 1) if product product.update(prijs: 24.99) end ``` - Verwijderen: ```ruby product = Product.find_by(id: 1) product.destroy if product ``` 5. Veiligheid en onderhoud: - Gebruik altijd ActiveRecord methoden zoals `create`, `update`, `destroy` die SQL-injecties voorkomen. - Gebruik `find_by` in plaats van `find` voor veilige foutafhandeling. - Maak gebruik van transacties indien meerdere bewerkingen worden gedaan die samen moeten slagen. Deze aanpak zorgt voor een veilige, efficiënte en onderhoudbare manier om met je PostgreSQL database te werken via Ruby en ActiveRecord.

Zeker! Hier is een complete implementatie met ActiveRecord voor PostgreSQL: ## 1. Installatie en configuratie Voeg eerst deze gems toe aan je Gemfile: ```ruby gem 'pg' gem 'activerecord' ``` ## 2. Database configuratie Maak een `database.yml` bestand: ```yaml default: &default adapter: postgresql encoding: unicode pool: 5 timeout: 5000 host: localhost username: je_gebruikersnaam password: je_wachtwoord development: <<: *default database: producten_development test: <<: *default database: producten_test production: <<: *default database: producten_production url: <%= ENV['DATABASE_URL'] %> ``` ## 3. Model definitie ```ruby # product.rb require 'active_record' class Product < ActiveRecord::Base # Validaties voor data-integriteit validates :naam, presence: true, length: { minimum: 2 } validates :prijs, presence: true, numericality: { greater_than: 0 } validates :voorraad, numericality: { only_integer: true, greater_than_or_equal_to: 0 } # Scope voor veelgebruikte queries scope :op_voorraad, -> { where('voorraad > 0') } scope :boven_prijs, ->(bedrag) { where('prijs > ?', bedrag) } # Custom method def beschikbaar? voorraad > 0 end end ``` ## 4. Database connectie en migratie ```ruby # database_setup.rb require 'active_record' require_relative 'product' # Database connectie ActiveRecord::Base.establish_connection( adapter: 'postgresql', host: 'localhost', database: 'producten_development', username: 'je_gebruikersnaar', password: 'je_wachtwoord' ) # Migratie (eenmalig uitvoeren) ActiveRecord::Schema.define do create_table :products, force: true do |t| t.string :naam, null: false t.decimal :prijs, precision: 10, scale: 2, null: false t.integer :voorraad, default: 0 t.text :beschrijving t.timestamps end add_index :products, :naam, unique: true end ``` ## 5. CRUD operaties ```ruby # product_operations.rb class ProductOperations # CREATE - Gegevens toevoegen def self.voeg_product_toe(naam, prijs, voorraad = 0, beschrijving = nil) product = Product.new( naam: naam, prijs: prijs, voorraad: voorraad, beschrijving: beschrijving ) if product.save puts "Product succesvol toegevoegd: #{product.naam}" product else puts "Fout bij toevoegen: #{product.errors.full_messages.join(', ')}" nil end end # READ - Gegevens ophalen def self.haal_producten(opties = {}) if opties[:id] Product.find_by(id: opties[:id]) elsif opties[:naam] Product.where('naam ILIKE ?', "%#{opties[:naam]}%") else Product.all end end # UPDATE - Gegevens bijwerken def self.werk_product_bij(id, attributen) product = Product.find_by(id: id) return nil unless product if product.update(attributen) puts "Product succesvol bijgewerkt: #{product.naam}" product else puts "Fout bij bijwerken: #{product.errors.full_messages.join(', ')}" nil end end # DELETE - Gegevens verwijderen def self.verwijder_product(id) product = Product.find_by(id: id) return nil unless product if product.destroy puts "Product succesvol verwijderd: #{product.naam}" true else puts "Fout bij verwijderen" false end end end ``` ## 6. Gebruiksvoorbeelden ```ruby # Gebruik van de operations require_relative 'product_operations' # Product toevoegen nieuw_product = ProductOperations.voeg_product_toe( "Laptop", 899.99, 10, "Krachtige laptop voor dagelijks gebruik" ) # Producten ophalen alle_producten = ProductOperations.haal_producten beschikbare_producten = Product.op_voorraad # Product bijwerken ProductOperations.werk_product_bij(1, { prijs: 799.99, voorraad: 5 }) # Product verwijderen ProductOperations.verwijder_product(1) ``` ## 7. Veiligheidsmaatregelen ```ruby # transaction_beheer.rb class SafeProductOperations def self.veilige_update(id, attributen) ActiveRecord::Base.transaction do product = Product.lock.find_by(id: id) return nil unless product product.update!(attributen) product end rescue ActiveRecord::RecordInvalid => e puts "Transactie mislukt: #{e.message}" nil end end ``` ## 8. Environment configuratie ```ruby # config/environment.rb require 'active_record' require 'dotenv/load' # voor environment variables ActiveRecord::Base.establish_connection( adapter: 'postgresql', host: ENV['DB_HOST'] || 'localhost', database: ENV['DB_NAME'], username: ENV['DB_USER'], password: ENV['DB_PASSWORD'], port: ENV['DB_PORT'] || 5432 ) ``` ## Belangrijke veiligheidsaspecten: 1. **Parameter validatie** via ActiveRecord validaties 2. **SQL injection preventie** door gebruik van prepared statements 3. **Transactionbeheer** voor data-integriteit 4. **Error handling** met duidelijke foutmeldingen 5. **Environment-based configuratie** voor verschillende omgevingen Deze code is modulair, testbaar en volgt best practices voor database interactie met PostgreSQL via ActiveRecord.