class Client < ApplicationRecord
  self.table_name = "CLIENT"
  self.primary_key = "CID"
end

Rails.application.config.active_record.pluralize_table_names = false

primary_key_prefix
table_name_prefix
table_name_suffix

def message=(txt)
  write_attribute(:message, txt + ' in bed')
end
#  or
def message=(txt)
  self[:message] = txt + ' in bed'
end

User.cache do
  puts User.first
  puts User.first
  puts User.first
end

user[:name]
user.slice(:name)
user.attributes[:name]

before_validation :fix_rate
def fix_rate
  self[:rate] = rate_before_type_cast.tr('$,','')
end

attr_readonly :social_security_number

class User < ApplicationRecord
  has_secure_token
end
>> user = User.create
>> => # < User id: … >> user.token = > “njHcvhKSwX9toZKEe9YETA8C”>> user.regenerate_token
has_secure_token :auth_token

attribute :category, :string, default: 'n/a'
attribute :repeats, :boolean, default: false

ActiveRecord::Type.register :inquiry, Inquiry.new

class Inquiry < ActiveRecord::Type::String
  def type
    :inquiry
  end

  def cast(value)
    super.inquiry #  See docs for [String.inquiry](:note:059eadc0-9cd8-4955-bb41-b579e5877cb7)
  end
end

class Event < ApplicationRecord
  attribute :repeats, Inquiry.new
end

User.joins(:comments).group("users.name").count("comments.id")

belongs_to :user, counter_cache: true

module Asteroid
  class NearEarthObject < ApplicationRecord
    validates :name, :absolute_magnitude_h, :estimated_diameter, presence: true
    store :estimated_diameter, accessors: %i[kilometers meters miles feet]
    alias_attribute :id, :neo_reference_id
  end
end

Project.update_all({manager: 'Ron Campbell'}, technology: 'Rails')

user.post_ids = [1, 2, 3]

Timesheet.delete(1)
Timesheet.destroy([2, 3])
delete_all # skips callbacks (like dependent: :destroy)
destroy_all

user.save(touch: false)

user.touch # => sets updated_at to now. user.touch(:viewed_at) #  sets viewed_at and updated_at to now.

class User < ApplicationRecord
  belongs_to :client, touch: true
end
user.touch #  also calls user.client.touch

Timesheet.transaction do
  t = Timesheet.lock.first
  t.approved = true
  t.save!
end

Foo.active.lock("FOR UPDATE OF pa_requests NOWAIT")

User.where('preferences @> ?', { newsletter: true }.to_json)

Message.where("subject LIKE :foo OR body LIKE :foo", foo: '%woah%')

Timesheet.take(10).skip(10)

b = BillableWeek.select('*', "mon_hrs + tues_hrs as two_day_total").first
b.two_day_total # => 16

Topic.select('title').from(Topic.approved).to_sql
# => "SELECT title FROM (SELECT * FROM topics WHERE approved = 't')"

class User < ApplicationRecord
  self.ignored_columns = %w(some_stupid_bs_column)
end

users = Account.select('name, SUM(cash) as money').group('name').to_a

Dealer.joins(:quotes).group("dealers.id").having('count(quotes.id) > 1')

User.group("created_at").having(["created_at > ?", 2.days.ago])

Person.having('min(age) > 17').group(:last_name).minimum(:age)

User.includes(:auctions).where(auctions: { name: 'Lumina' })

User.create_with(active: true).find_or_create_by(first_name: 'Buster', ...)

User.find_or_create_by(first_name: 'Poppa') do |user|
  user.last_name = 'Smurf'
end

Asteroid::NearEarthObject.select("a.name").from(Asteroid::NearEarthObject.where(is_potentially_hazardous_asteroid: false), :a).explain

Member.where(name: "Fool", active: true).unscope(where: :name)
Member.unscope(:active)...

Timesheet.unscoped.where("created_at < ?", 1.year.ago)

User.find_by_sql("select * from users limit 1")

ActiveRecord::Base.connection.execute

ActiveRecord::Base.connectionconn.tables #  => an array of the table names

ActiveRecord::Base.connection.execute("select * from asteroid_near_earth_objects").values

def execute_sql_file(path)
  File.read(path). split(';').each do |sql|
    begin
      ActiveRecord::Base.connection.execute(#{sql}") unless sql.blank?
    rescue ActiveRecord::StatementInvalid
        $stderr.puts "warning: #{$!}"
    end
  end
end

Activity.joins("LEFT JOIN users ON activities.owner_type = 'User' AND activities.owner_id = users.id")
Activity.joins("LEFT JOIN managers ON activities.owner_type = 'Manager' AND activities.owner_id = managers.id")

belongs_to :record, polymorphic: true
has_one :self_ref, class_name: 'ActiveStorage::Attachment', foreign_key: :id
has_one :rich_text, through: :self_ref, source: :record, source_type: 'ActionText::RichText'

SELECT "active_storage_attachments".* FROM "active_storage_attachments"
INNER JOIN "active_storage_attachments" "self_refs_active_storage_attachments_join"
    ON "self_refs_active_storage_attachments_join"."record_type" = 'ActionText::RichText'
    AND "self_refs_active_storage_attachments_join"."id" = "active_storage_attachments"."id"
INNER JOIN "action_text_rich_texts"
    ON "action_text_rich_texts"."id" = "self_refs_active_storage_attachments_join"."record_id"

user.timesheets.select(:*, "calc_something(col1, col2) as delta").to_a

user.timesheets.closed.each(&:mark_for_destruction)

has_many :unchangable_posts, class_name: "Post", before_add: ->(owner, record) { raise "Can't do it!" }

has_many :pending_comments, -> { where( approved: true) }, class_name: 'Comment'

class Client < ActiveRecord::Base
  has_many :timesheets, -> { distinct }, through: :billable_weeks
end

class User < ActiveRecord::Base
  has_many :timesheets
  has_one :latest_sheet, -> { order(' created_at desc') }, class_name: 'Timesheet'
end

belongs_to :project, -> { readonly }
belongs_to :post, -> { includes(:author) }

has_many :people do
  def named(full_name)
    first_name, last_name = full_name.split(" ", 2)
    where(first_name: first_name, last_name: last_name).first_or_create
  end
end

has_many :people, -> { extending(ByNameExtension, ByRecentExtension) }

belongs_to :automatic_payment_method, class_name: 'PaymentMethod'

def automatic_payment_method
  super || NullAutomaticPaymentMethod.new
end

class MarkDeleted
  def self.before_destroy(model)
    model.update_attribute(:deleted_at, Time.current)
    throw(:abort)
  end
end

class Account < ActiveRecord::Base
  before_destroy MarkDeleted
end

class Person < ActiveRecord::Base
  def address
    @address || = Address.new(address_city, address_state)
  end

  def address=(address)
    self[:address_city] = address.city
    self[:address_state] = address.state
    @address = address
  end
end

class Address
  attr_reader :city, :state

  def initialize(city, state)
    @city, @state = city, state
  end

  def ==(other_address)
    city == other_address.city && state == other_address.state
  end
end

# config/application.rb
config.active_record.schema_format = :sql

module Hubble
  class Application < Rails::Application
    config.active_record.schema_format = :sql
    ActiveRecord::Tasks::DatabaseTasks.structure_dump_flags = ['--exclude-schema=rollback', '--if-exists', '--clean']
    ...
  end
end