activerecord-oracle_enhanced-adapter 1.4.3 → 5.2.0

data/spec/active_record/oracle_enhanced/type/raw_spec.rb

@@ -0,0 +1,122 @@
+# frozen_string_literal: true
+
+describe "OracleEnhancedAdapter handling of RAW columns" do
+  include SchemaSpecHelper
+
+  before(:all) do
+    ActiveRecord::Base.establish_connection(CONNECTION_PARAMS)
+    schema_define do
+      create_table :test_employees, force: true do |t|
+        t.string    :first_name,    limit: 20
+        t.string    :last_name,     limit: 25
+        t.raw       :binary_data,   limit: 1024
+      end
+    end
+    @binary_data = "\0\1\2\3\4\5\6\7\8\9" * 100
+    @binary_data2 = "\1\2\3\4\5\6\7\8\9\0" * 100
+  end
+
+  after(:all) do
+    schema_define do
+      drop_table :test_employees
+    end
+  end
+
+  before(:each) do
+    class ::TestEmployee < ActiveRecord::Base
+    end
+  end
+
+  after(:each) do
+    Object.send(:remove_const, "TestEmployee")
+    ActiveRecord::Base.clear_cache!
+  end
+
+  it "should create record with RAW data" do
+    @employee = TestEmployee.create!(
+      first_name: "First",
+      last_name: "Last",
+      binary_data: @binary_data
+    )
+    @employee.reload
+    expect(@employee.binary_data).to eq(@binary_data)
+  end
+
+  it "should update record with RAW data" do
+    @employee = TestEmployee.create!(
+      first_name: "First",
+      last_name: "Last"
+    )
+    @employee.reload
+    expect(@employee.binary_data).to be_nil
+    @employee.binary_data = @binary_data
+    @employee.save!
+    @employee.reload
+    expect(@employee.binary_data).to eq(@binary_data)
+  end
+
+  it "should update record with zero-length RAW data" do
+    @employee = TestEmployee.create!(
+      first_name: "First",
+      last_name: "Last"
+    )
+    @employee.reload
+    expect(@employee.binary_data).to be_nil
+    @employee.binary_data = ""
+    @employee.save!
+    @employee.reload
+    expect(@employee.binary_data).to be_nil
+  end
+
+  it "should update record that has existing RAW data with different RAW data" do
+    @employee = TestEmployee.create!(
+      first_name: "First",
+      last_name: "Last",
+      binary_data: @binary_data
+    )
+    @employee.reload
+    @employee.binary_data = @binary_data2
+    @employee.save!
+    @employee.reload
+    expect(@employee.binary_data).to eq(@binary_data2)
+  end
+
+  it "should update record that has existing RAW data with nil" do
+    @employee = TestEmployee.create!(
+      first_name: "First",
+      last_name: "Last",
+      binary_data: @binary_data
+    )
+    @employee.reload
+    @employee.binary_data = nil
+    @employee.save!
+    @employee.reload
+    expect(@employee.binary_data).to be_nil
+  end
+
+  it "should update record that has existing RAW data with zero-length RAW data" do
+    @employee = TestEmployee.create!(
+      first_name: "First",
+      last_name: "Last",
+      binary_data: @binary_data
+    )
+    @employee.reload
+    @employee.binary_data = ""
+    @employee.save!
+    @employee.reload
+    expect(@employee.binary_data).to be_nil
+  end
+
+  it "should update record that has zero-length BLOB data with non-empty RAW data" do
+    @employee = TestEmployee.create!(
+      first_name: "First",
+      last_name: "Last",
+      binary_data: ""
+    )
+    @employee.reload
+    @employee.binary_data = @binary_data
+    @employee.save!
+    @employee.reload
+    expect(@employee.binary_data).to eq(@binary_data)
+  end
+end

data/spec/active_record/oracle_enhanced/type/text_spec.rb

@@ -0,0 +1,229 @@
+# frozen_string_literal: true
+
+describe "OracleEnhancedAdapter handling of CLOB columns" do
+  include SchemaSpecHelper
+
+  before(:all) do
+    ActiveRecord::Base.establish_connection(CONNECTION_PARAMS)
+    @conn = ActiveRecord::Base.connection
+    schema_define do
+      create_table :test_employees, force: true do |t|
+        t.string  :first_name, limit: 20
+        t.string  :last_name, limit: 25
+        t.text    :comments
+      end
+      create_table :test2_employees, force: true do |t|
+        t.string  :first_name, limit: 20
+        t.string  :last_name, limit: 25
+        t.text    :comments
+      end
+      create_table :test_serialize_employees, force: true do |t|
+        t.string  :first_name, limit: 20
+        t.string  :last_name, limit: 25
+      end
+      add_column :test_serialize_employees, :comments, :text
+    end
+
+    @char_data = (0..127).to_a.pack("C*") * 800
+    @char_data2 = ((1..127).to_a.pack("C*") + "\0") * 800
+
+    class ::TestEmployee < ActiveRecord::Base; end
+    class ::Test2Employee < ActiveRecord::Base
+      serialize :comments
+    end
+    class ::TestEmployeeReadOnlyClob < ActiveRecord::Base
+      self.table_name = "test_employees"
+      attr_readonly :comments
+    end
+    class ::TestSerializeEmployee < ActiveRecord::Base
+      serialize :comments
+      attr_readonly :comments
+    end
+  end
+
+  after(:all) do
+    @conn.drop_table :test_employees, if_exists: true
+    @conn.drop_table :test2_employees, if_exists: true
+    @conn.drop_table :test_serialize_employees, if_exists: true
+    Object.send(:remove_const, "TestEmployee")
+    Object.send(:remove_const, "Test2Employee")
+    Object.send(:remove_const, "TestEmployeeReadOnlyClob")
+    Object.send(:remove_const, "TestSerializeEmployee")
+    ActiveRecord::Base.clear_cache!
+  end
+
+  it "should create record without CLOB data when attribute is serialized" do
+    @employee = Test2Employee.create!(
+      first_name: "First",
+      last_name: "Last"
+    )
+    expect(@employee).to be_valid
+    @employee.reload
+    expect(@employee.comments).to be_nil
+  end
+
+  it "should accept Symbol value for CLOB column" do
+    @employee = TestEmployee.create!(
+      comments: :test_comment
+    )
+    expect(@employee).to be_valid
+  end
+
+  it "should respect attr_readonly setting for CLOB column" do
+    @employee = TestEmployeeReadOnlyClob.create!(
+      first_name: "First",
+      comments: "initial"
+    )
+    expect(@employee).to be_valid
+    @employee.reload
+    expect(@employee.comments).to eq("initial")
+    @employee.comments = "changed"
+    expect(@employee.save).to eq(true)
+    @employee.reload
+    expect(@employee.comments).to eq("initial")
+  end
+
+  it "should work for serialized readonly CLOB columns", serialized: true do
+    @employee = TestSerializeEmployee.new(
+      first_name: "First",
+      comments: nil
+    )
+    expect(@employee.comments).to be_nil
+    expect(@employee.save).to eq(true)
+    expect(@employee).to be_valid
+    @employee.reload
+    expect(@employee.comments).to be_nil
+    @employee.comments = {}
+    expect(@employee.save).to eq(true)
+    @employee.reload
+    # should not set readonly
+    expect(@employee.comments).to be_nil
+  end
+
+  it "should create record with CLOB data" do
+    @employee = TestEmployee.create!(
+      first_name: "First",
+      last_name: "Last",
+      comments: @char_data
+    )
+    @employee.reload
+    expect(@employee.comments).to eq(@char_data)
+  end
+
+  it "should update record with CLOB data" do
+    @employee = TestEmployee.create!(
+      first_name: "First",
+      last_name: "Last"
+    )
+    @employee.reload
+    expect(@employee.comments).to be_nil
+    @employee.comments = @char_data
+    @employee.save!
+    @employee.reload
+    expect(@employee.comments).to eq(@char_data)
+  end
+
+  it "should update record with zero-length CLOB data" do
+    @employee = TestEmployee.create!(
+      first_name: "First",
+      last_name: "Last"
+    )
+    @employee.reload
+    expect(@employee.comments).to be_nil
+    @employee.comments = ""
+    @employee.save!
+    @employee.reload
+    expect(@employee.comments).to eq("")
+  end
+
+  it "should update record that has existing CLOB data with different CLOB data" do
+    @employee = TestEmployee.create!(
+      first_name: "First",
+      last_name: "Last",
+      comments: @char_data
+    )
+    @employee.reload
+    @employee.comments = @char_data2
+    @employee.save!
+    @employee.reload
+    expect(@employee.comments).to eq(@char_data2)
+  end
+
+  it "should update record that has existing CLOB data with nil" do
+    @employee = TestEmployee.create!(
+      first_name: "First",
+      last_name: "Last",
+      comments: @char_data
+    )
+    @employee.reload
+    @employee.comments = nil
+    @employee.save!
+    @employee.reload
+    expect(@employee.comments).to be_nil
+  end
+
+  it "should update record that has existing CLOB data with zero-length CLOB data" do
+    @employee = TestEmployee.create!(
+      first_name: "First",
+      last_name: "Last",
+      comments: @char_data
+    )
+    @employee.reload
+    @employee.comments = ""
+    @employee.save!
+    @employee.reload
+    expect(@employee.comments).to eq("")
+  end
+
+  it "should update record that has zero-length CLOB data with non-empty CLOB data" do
+    @employee = TestEmployee.create!(
+      first_name: "First",
+      last_name: "Last",
+      comments: ""
+    )
+    @employee.reload
+    expect(@employee.comments).to eq("")
+    @employee.comments = @char_data
+    @employee.save!
+    @employee.reload
+    expect(@employee.comments).to eq(@char_data)
+  end
+
+  it "should store serializable ruby data structures" do
+    ruby_data1 = { "arbitrary1" => ["ruby", :data, 123] }
+    ruby_data2 = { "arbitrary2" => ["ruby", :data, 123] }
+    @employee = Test2Employee.create!(
+      comments: ruby_data1
+    )
+    @employee.reload
+    expect(@employee.comments).to eq(ruby_data1)
+    @employee.comments = ruby_data2
+    @employee.save
+    @employee.reload
+    expect(@employee.comments).to eq(ruby_data2)
+  end
+
+  it "should keep unchanged serialized data when other columns changed" do
+    @employee = Test2Employee.create!(
+      first_name: "First",
+      last_name: "Last",
+      comments: "initial serialized data"
+    )
+    @employee.first_name = "Steve"
+    @employee.save
+    @employee.reload
+    expect(@employee.comments).to eq("initial serialized data")
+  end
+
+  it "should keep serialized data after save" do
+    @employee = Test2Employee.new
+    @employee.comments = { length: { is: 1 } }
+    @employee.save
+    @employee.reload
+    expect(@employee.comments).to eq(length: { is: 1 })
+    @employee.comments = { length: { is: 2 } }
+    @employee.save
+    @employee.reload
+    expect(@employee.comments).to eq(length: { is: 2 })
+  end
+end

data/spec/active_record/oracle_enhanced/type/timestamp_spec.rb

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+describe "OracleEnhancedAdapter timestamp with timezone support" do
+  include SchemaSpecHelper
+
+  before(:all) do
+    ActiveRecord::Base.default_timezone = :local
+    ActiveRecord::Base.establish_connection(CONNECTION_WITH_TIMEZONE_PARAMS)
+    @conn = ActiveRecord::Base.connection
+    schema_define do
+      create_table :test_employees, force: true do |t|
+        t.string        :first_name,  limit: 20
+        t.string        :last_name,  limit: 25
+        t.string        :email, limit: 25
+        t.string        :phone_number, limit: 20
+        t.date          :hire_date
+        t.decimal       :job_id, scale: 0, precision: 6
+        t.decimal       :salary, scale: 2, precision: 8
+        t.decimal       :commission_pct, scale: 2, precision: 2
+        t.decimal       :manager_id, scale: 0, precision: 6
+        t.decimal       :department_id, scale: 0, precision: 4
+        t.timestamp     :created_at
+        t.timestamptz   :created_at_tz
+        t.timestampltz  :created_at_ltz
+      end
+    end
+  end
+
+  after(:all) do
+    @conn.drop_table :test_employees, if_exists: true
+    ActiveRecord::Base.default_timezone = :utc
+  end
+
+  describe "/ TIMESTAMP WITH TIME ZONE values from ActiveRecord model" do
+    before(:all) do
+      class ::TestEmployee < ActiveRecord::Base
+      end
+    end
+
+    after(:all) do
+      Object.send(:remove_const, "TestEmployee")
+      ActiveRecord::Base.clear_cache!
+    end
+
+    it "should return Time value from TIMESTAMP columns" do
+      @now = Time.local(2008, 5, 26, 23, 11, 11, 0)
+      @employee = TestEmployee.create(
+        created_at: @now,
+        created_at_tz: @now,
+        created_at_ltz: @now
+      )
+      @employee.reload
+      [:created_at, :created_at_tz, :created_at_ltz].each do |c|
+        expect(@employee.send(c).class).to eq(Time)
+        expect(@employee.send(c).to_f).to eq(@now.to_f)
+      end
+    end
+
+    it "should return Time value with fractional seconds from TIMESTAMP columns" do
+      @now = Time.local(2008, 5, 26, 23, 11, 11, 10)
+      @employee = TestEmployee.create(
+        created_at: @now,
+        created_at_tz: @now,
+        created_at_ltz: @now
+      )
+      @employee.reload
+      [:created_at, :created_at_tz, :created_at_ltz].each do |c|
+        expect(@employee.send(c).class).to eq(Time)
+        expect(@employee.send(c).to_f).to eq(@now.to_f)
+      end
+    end
+
+  end
+
+end

data/spec/spec_config.yaml.template

@@ -0,0 +1,11 @@
+# copy this file to spec/config.yaml and set appropriate values
+# you can also use environment variables, see spec_helper.rb
+database:
+  name:         'orcl'
+  host:         '127.0.0.1'
+  port:         1521
+  user:         'oracle_enhanced'
+  password:     'oracle_enhanced'
+  sys_password: 'admin'
+  non_default_tablespace: 'SYSTEM'
+timezone: 'Europe/Riga'

data/spec/spec_helper.rb

@@ -1,80 +1,61 @@
-require 'rubygems'
+# frozen_string_literal: true
+
+require "simplecov"
+SimpleCov.start
+require "rubygems"
 require "bundler"
+require "yaml"
 Bundler.setup(:default, :development)
 
-$:.unshift(File.expand_path('../../lib', __FILE__))
+$:.unshift(File.expand_path("../../lib", __FILE__))
+config_path = File.expand_path("../spec_config.yaml", __FILE__)
+if File.exist?(config_path)
+  puts "==> Loading config from #{config_path}"
+  config = YAML.load_file(config_path)
+else
+  puts "==> Loading config from ENV or use default"
+  config = { "rails" => {}, "database" => {} }
+end
 
-require 'rspec'
+require "rspec"
 
-if !defined?(RUBY_ENGINE) || RUBY_ENGINE == 'ruby'
+if !defined?(RUBY_ENGINE) || RUBY_ENGINE == "ruby"
   puts "==> Running specs with MRI version #{RUBY_VERSION}"
-  require 'oci8'
-elsif RUBY_ENGINE == 'jruby'
+  require "oci8"
+elsif RUBY_ENGINE == "jruby"
   puts "==> Running specs with JRuby version #{JRUBY_VERSION}"
 end
 
-ENV['RAILS_GEM_VERSION'] ||= '3.2-master'
-NO_COMPOSITE_PRIMARY_KEYS = true if ENV['RAILS_GEM_VERSION'] >= '2.3.5' || ENV['RAILS_GEM_VERSION'] =~ /^2\.3\.1\d$/
-
-puts "==> Running specs with Rails version #{ENV['RAILS_GEM_VERSION']}"
+require "active_record"
 
-require 'active_record'
+require "active_support/core_ext/module/attribute_accessors"
+require "active_support/core_ext/class/attribute_accessors"
 
-if ENV['RAILS_GEM_VERSION'] >= '3.0'
-  require 'action_dispatch'
-  require 'active_support/core_ext/module/attribute_accessors'
-  require 'active_support/core_ext/class/attribute_accessors'
+require "active_support/log_subscriber"
+require "active_record/log_subscriber"
 
-  if ENV['RAILS_GEM_VERSION'] =~ /^3.0.0.beta/
-    require "rails/log_subscriber"
-    require 'active_record/railties/log_subscriber'
-  else
-    require "active_support/log_subscriber"
-    require 'active_record/log_subscriber'
-  end
+require "logger"
 
-  require 'logger'
-elsif ENV['RAILS_GEM_VERSION'] =~ /^2.3/
-  require 'action_pack'
-  require 'action_controller/session/abstract_store'
-  require 'active_record/session_store'
-elsif ENV['RAILS_GEM_VERSION'] <= '2.3'
-  require 'action_pack'
-  require 'action_controller/session/active_record_store'
-end
+require "active_record/connection_adapters/oracle_enhanced_adapter"
+require "ruby-plsql"
 
-require 'active_record/connection_adapters/oracle_enhanced_adapter'
-require 'ruby-plsql'
+puts "==> Effective ActiveRecord version #{ActiveRecord::VERSION::STRING}"
 
 module LoggerSpecHelper
   def set_logger
     @logger = MockLogger.new
     @old_logger = ActiveRecord::Base.logger
 
-    if ENV['RAILS_GEM_VERSION'] >= '3.0'
-      @notifier = ActiveSupport::Notifications::Fanout.new
+    @notifier = ActiveSupport::Notifications::Fanout.new
 
-      ActiveSupport::LogSubscriber.colorize_logging = false
+    ActiveSupport::LogSubscriber.colorize_logging = false
 
-      ActiveRecord::Base.logger = @logger
-      @old_notifier = ActiveSupport::Notifications.notifier
-      ActiveSupport::Notifications.notifier = @notifier
-
-      ActiveRecord::LogSubscriber.attach_to(:active_record)
-      if ENV['RAILS_GEM_VERSION'] >= '3.2'
-        ActiveSupport::Notifications.subscribe("sql.active_record", ActiveRecord::ExplainSubscriber.new)
-      end
-    else # ActiveRecord 2.x
-      if ActiveRecord::Base.respond_to?(:connection_pool)
-        ActiveRecord::Base.connection_pool.clear_reloadable_connections!
-      else
-        ActiveRecord::Base.clear_active_connections!
-      end
-      ActiveRecord::Base.logger = @logger
-      ActiveRecord::Base.colorize_logging = false
-      # ActiveRecord::Base.logger.level = Logger::DEBUG
-    end
+    ActiveRecord::Base.logger = @logger
+    @old_notifier = ActiveSupport::Notifications.notifier
+    ActiveSupport::Notifications.notifier = @notifier
 
+    ActiveRecord::LogSubscriber.attach_to(:active_record)
+    ActiveSupport::Notifications.subscribe("sql.active_record", ActiveRecord::ExplainSubscriber.new)
   end
 
   class MockLogger
@@ -82,7 +63,7 @@ module LoggerSpecHelper
 
     def initialize
       @flush_count = 0
-      @logged = Hash.new { |h,k| h[k] = [] }
+      @logged = Hash.new { |h, k| h[k] = [] }
     end
 
     # used in AtiveRecord 2.x
@@ -115,11 +96,8 @@ module LoggerSpecHelper
     ActiveRecord::Base.logger = @old_logger
     @logger = nil
 
-    if ENV['RAILS_GEM_VERSION'] >= '3.0'
-      ActiveSupport::Notifications.notifier = @old_notifier
-      @notifier = nil
-    end
-
+    ActiveSupport::Notifications.notifier = @old_notifier
+    @notifier = nil
   end
 
   # Wait notifications to be published (for Rails 3.0)
@@ -127,7 +105,6 @@ module LoggerSpecHelper
   def wait
     @notifier.wait if @notifier
   end
-
 end
 
 module SchemaSpecHelper
@@ -140,48 +117,78 @@ module SchemaSpecHelper
   end
 end
 
-DATABASE_NAME = ENV['DATABASE_NAME'] || 'orcl'
-DATABASE_HOST = ENV['DATABASE_HOST']
-DATABASE_PORT = ENV['DATABASE_PORT']
-DATABASE_USER = ENV['DATABASE_USER'] || 'oracle_enhanced'
-DATABASE_PASSWORD = ENV['DATABASE_PASSWORD'] || 'oracle_enhanced'
-DATABASE_SYS_PASSWORD = ENV['DATABASE_SYS_PASSWORD'] || 'admin'
+module SchemaDumpingHelper
+  def dump_table_schema(table, connection = ActiveRecord::Base.connection)
+    old_ignore_tables = ActiveRecord::SchemaDumper.ignore_tables
+    ActiveRecord::SchemaDumper.ignore_tables = connection.data_sources - [table]
+    stream = StringIO.new
+    ActiveRecord::SchemaDumper.dump(ActiveRecord::Base.connection, stream)
+    stream.string
+  ensure
+    ActiveRecord::SchemaDumper.ignore_tables = old_ignore_tables
+  end
+end
+
+DATABASE_NAME         = config["database"]["name"]         || ENV["DATABASE_NAME"]         || "orcl"
+DATABASE_HOST         = config["database"]["host"]         || ENV["DATABASE_HOST"]         || "127.0.0.1"
+DATABASE_PORT         = config["database"]["port"]         || ENV["DATABASE_PORT"]         || 1521
+DATABASE_USER         = config["database"]["user"]         || ENV["DATABASE_USER"]         || "oracle_enhanced"
+DATABASE_PASSWORD     = config["database"]["password"]     || ENV["DATABASE_PASSWORD"]     || "oracle_enhanced"
+DATABASE_SCHEMA       = config["database"]["schema"]       || ENV["DATABASE_SCHEMA"]       || "oracle_enhanced_schema"
+DATABASE_SYS_PASSWORD = config["database"]["sys_password"] || ENV["DATABASE_SYS_PASSWORD"] || "admin"
 
 CONNECTION_PARAMS = {
-  :adapter => "oracle_enhanced",
-  :database => DATABASE_NAME,
-  :host => DATABASE_HOST,
-  :port => DATABASE_PORT,
-  :username => DATABASE_USER,
-  :password => DATABASE_PASSWORD
+  adapter: "oracle_enhanced",
+  database: DATABASE_NAME,
+  host: DATABASE_HOST,
+  port: DATABASE_PORT,
+  username: DATABASE_USER,
+  password: DATABASE_PASSWORD
+}
+
+CONNECTION_WITH_SCHEMA_PARAMS = {
+  adapter: "oracle_enhanced",
+  database: DATABASE_NAME,
+  host: DATABASE_HOST,
+  port: DATABASE_PORT,
+  username: DATABASE_USER,
+  password: DATABASE_PASSWORD,
+  schema: DATABASE_SCHEMA
+}
+
+CONNECTION_WITH_TIMEZONE_PARAMS = {
+  adapter: "oracle_enhanced",
+  database: DATABASE_NAME,
+  host: DATABASE_HOST,
+  port: DATABASE_PORT,
+  username: DATABASE_USER,
+  password: DATABASE_PASSWORD,
+  time_zone: "Europe/Riga"
 }
 
 SYS_CONNECTION_PARAMS = {
-  :adapter => "oracle_enhanced",
-  :database => DATABASE_NAME,
-  :host => DATABASE_HOST,
-  :port => DATABASE_PORT,
-  :username => "sys",
-  :password => DATABASE_SYS_PASSWORD,
-  :privilege => "SYSDBA"
+  adapter: "oracle_enhanced",
+  database: DATABASE_NAME,
+  host: DATABASE_HOST,
+  port: DATABASE_PORT,
+  username: "sys",
+  password: DATABASE_SYS_PASSWORD,
+  privilege: "SYSDBA"
 }
 
 SYSTEM_CONNECTION_PARAMS = {
-  :adapter => "oracle_enhanced",
-  :database => DATABASE_NAME,
-  :host => DATABASE_HOST,
-  :port => DATABASE_PORT,
-  :username => "system",
-  :password => DATABASE_SYS_PASSWORD
+  adapter: "oracle_enhanced",
+  database: DATABASE_NAME,
+  host: DATABASE_HOST,
+  port: DATABASE_PORT,
+  username: "system",
+  password: DATABASE_SYS_PASSWORD
 }
 
-DATABASE_NON_DEFAULT_TABLESPACE = ENV['DATABASE_NON_DEFAULT_TABLESPACE'] || "SYSTEM"
-
-# Set default $KCODE to UTF8
-if RUBY_VERSION < "1.9"
-  $KCODE = "UTF8"
-end
+DATABASE_NON_DEFAULT_TABLESPACE = config["database"]["non_default_tablespace"] || ENV["DATABASE_NON_DEFAULT_TABLESPACE"] || "SYSTEM"
 
 # set default time zone in TZ environment variable
 # which will be used to set session time zone
-ENV['TZ'] ||= 'Europe/Riga'
+ENV["TZ"] ||= config["timezone"] || "Europe/Riga"
+
+ActiveRecord::Base.logger = ActiveSupport::Logger.new("debug.log", 0, 100 * 1024 * 1024)