lore 0.4.8 → 0.9.2

data/lib/lore.rb

@@ -3,11 +3,12 @@ require('logger')
 
 module Lore
   
-  VERSION='0.4.7'
+  VERSION='0.9.2'
 
   @logfile         = STDERR
-  @log_queries     = false
-  @logging_enabled = false
+  @query_logfile   = STDERR
+  @log_queries     = true
+  @logging_enabled = true
   @cache_entities  = false
   @pg_server = 'localhost'
   @pg_port   = 5432
@@ -17,13 +18,25 @@ module Lore
   def self.logfile
     @logfile
   end
+  def self.query_logfile
+    @query_logfile
+  end
   def self.logfile=(file)
-    @logger = Logger.new(file)
+    @logger       = Logger.new(file)
+    @query_logger = Logger.new(file)
+  end
+  def self.query_logfile=(file)
+    @query_logger = Logger.new(file)
   end
   def self.logger
     @logger
   end
+  def self.query_logger
+    @query_logger
+  end
+
   @logger = Logger.new(Lore.logfile)
+  @query_logger = Logger.new(Lore.query_logfile)
 
   def self.log(&log_block)
     return if Lore.logging_disabled?  
@@ -36,9 +49,11 @@ module Lore
 
   def self.disable_logging
     @logging_enabled = false
+    Lore.logger.level = Logger::ERROR
   end
   def self.enable_logging
     @logging_enabled = true
+    Lore.logger.level = Logger::DEBUG
   end
   def self.enable_query_log
     @log_queries = true
@@ -82,7 +97,7 @@ module Lore
     end
   end
   def self.pass_for(dbname)
-    @logins[dbname.to_s][1].to_s
+    @logins[dbname.to_s][1]
   end
 
   def self.disable_cache
@@ -103,7 +118,6 @@ module Lore
 
 end
 
+require('lore/adapters/postgres')
 require('lore/validation/parameter_validator')
-require('lore/exception/invalid_parameter')
-require('lore/exception/invalid_klass_parameters')
-require('lore/connection')
+

data/lib/lore/adapters/context.rb

@@ -0,0 +1,64 @@
+
+require('lore')
+
+module Lore
+
+class Connection_Error < ::Exception
+
+end
+
+class Context 
+  
+  @@context_stack = Array.new
+  
+  def self.get_connection()
+    if @@context_stack.empty? then
+      raise ::Exception.new('No context given. ')
+    end
+    return Connection_Pool.get_connection(@@context_stack.last)
+  end
+
+  def self.get_context
+    @@context_stack.last
+  end
+
+  def self.inspect
+    @@context_stack.inspect
+  end
+  
+  def self.enter(context_name)
+    Lore.logger.debug { "Entering context #{context_name}" }
+    @@context_stack.push(context_name.to_sym)
+  end
+  
+  def self.leave()
+    Lore.logger.debug { "Leaving context #{context_name}" } 
+    context_name = @@context_stack.pop
+  end
+  
+end
+  
+class Connection_Pool 
+
+  @@pool = Hash.new
+
+  def self.get_connection(db_name)
+    
+    db_name = db_name.to_sym
+    
+    # If requested connection is not in pool yet: 
+    if !@@pool.has_key? db_name then
+    # Try to establish connection
+      connection = Lore::Connection.establish(db_name)
+      connection.exec(Lore.on_connect_commands)
+      @@pool[db_name] = connection
+    end
+
+    # Return requested connection
+    return @@pool[db_name]
+
+  end
+
+end
+
+end # module Lore

data/lib/lore/adapters/postgres-pr.rb

@@ -0,0 +1,6 @@
+
+require('rubygems')
+require('lore/adapters/postgres-pr/connection')
+require('lore/adapters/postgres-pr/result')
+require('lore/adapters/postgres-pr/types')
+

data/lib/lore/adapters/postgres-pr/connection.rb

@@ -0,0 +1,93 @@
+
+$:.push('/opt/local/lib/ruby/1.8/postgres')
+
+require('postgres-pr/connection')
+require('lore')
+require('lore/exceptions/database_exception')
+require('lore/adapters/context')
+require('lore/adapters/postgres-pr/result')
+require('lore/adapters/postgres-pr/types')
+
+module PostgresPR
+  class Connection
+    alias exec query
+    alias exec_async query
+  end
+end
+
+module Lore
+
+class Connection 
+
+  @@query_count      = 0
+  @@result_row_count = 0
+  
+  def initialize
+  end
+  
+  def self.reset_query_count
+    @@query_count = 0
+  end
+  def self.reset_result_row_count
+    @@result_row_count = 0
+  end
+  def self.query_count
+    @@query_count
+  end
+  def self.result_row_count
+    @@result_row_count
+  end
+  
+  def self.perform_cacheable(query)
+    if Lore::Cache::Cached_Entities.include?(query) then
+        result = Lore::Cache::Cached_Entities[query]
+    else
+      result = perform(query)
+      Lore::Cache::Cached_Entities[query] = result
+    end
+    return result
+  end
+  
+  def self.perform(query)
+    begin
+      @@query_count += 1
+    # result = Context.get_connection.exec(query)
+      result = Context.get_connection.query(query)
+      @@result_row_count += result.rows.length
+      
+      if Lore.log_queries? then
+        query.split("\n").each { |line|
+          Lore.query_logger.debug { "  sql|#{Context.get_context}| #{line}" }
+        }
+      end
+    rescue ::Exception => pge
+      Lore.logger.error { pge.message }
+      Lore.logger.error { 'Context: ' << Context.inspect }
+      Lore.logger.error { 'Query:   ' << "\n" << query }
+      raise pge
+      raise Lore::Exceptions::Database_Exception.new(pge.message << "\n" << query.to_s)
+    end
+    
+    return Result.new(query, result)
+  end
+
+  def self.establish(db_name)
+    Lore.logger.info { "Establishing connection to #{db_name}" }
+    Lore.logger.info { "User: #{Lore.user_for(db_name.to_sym).inspect}"}
+    Lore.logger.info { "Pass: #{Lore.pass_for(db_name.to_sym).inspect}"}
+    Lore.logger.info { "Server: #{Lore.pg_server}" }
+    begin
+      PostgresPR::Connection.new(db_name.to_s, 
+                                 Lore.user_for(db_name.to_sym), 
+                                 Lore.pass_for(db_name.to_sym), 
+                                 # including port, example: 
+                                 # 'unix:/var/run/postgresql/.s.PGSQL.5432'
+                                 Lore.pg_server)
+    rescue ::Exception => e
+      raise Lore::Exceptions::Database_Exception.new(e.message)
+    end
+  end
+  
+end # class Connection
+
+end # module Lore

data/lib/lore/adapters/postgres-pr/result.rb

@@ -0,0 +1,63 @@
+
+require('postgres-pr/connection')
+
+module Lore
+
+class Result 
+
+  attr_reader :query_hashval, :field_names, :field_types
+
+  # expects PostgresPR::Result
+  def initialize(query, result) 
+    @result           = result
+    @field_types      = {}
+    @result.fields.each { |f| 
+      @field_types[f.name] = f.type_oid 
+    }
+    @num_fields       = @result.fields.length
+    @num_tuples       = @result.rows.length
+    @field_names      = @result.fields.map { |f| f.name }
+  end 
+  
+  def get_field_value(row_index, field_name)
+    # TODO: Optimize this! 
+    field_index = 0
+    @result.fields.each { |f| 
+      break if f.name == field_name 
+      field_index += 1
+    }
+    return @result.rows[row_index][field_index]
+  end 
+  
+  def get_field_types()
+    return @field_types
+  end
+  alias field_types get_field_types
+  alias get_field_names field_names
+  
+  def get_field_num()
+    @num_fields
+  end
+  
+  def get_tuple_num()
+    @num_tuples
+  end
+  
+  def get_row(row_num=0)
+    @result.rows[row_num]
+  end
+  def get_row_with_field_names(row_num=0)
+    return { :values => @result.rows, :fields => @result.fields }
+  end
+  
+  def get_rows()
+    return @result.rows
+  end
+  
+  def fieldname(index)
+    return @fields_names[index]
+  end
+  
+end # class Result
+
+end # module Lore

data/lib/lore/{types.rb → adapters/postgres-pr/types.rb}

@@ -7,6 +7,7 @@ module Lore
   PG_CHAR                = 18
   PG_INT                 = 23
   PG_TEXT                = 25
+  PG_FLOAT               = 701
   PG_CHARACTER           = 1042
   PG_VARCHAR             = 1043
   PG_TIME                = 1083
@@ -23,6 +24,7 @@ module Lore
     PG_CHAR                => 'char',
     PG_INT                 => 'integer',
     PG_TEXT                => 'text',
+    PG_FLOAT               => 'float', 
     PG_CHARACTER           => 'character',
     PG_VARCHAR             => 'character varying(1000)',
     PG_TIME                => 'time',
@@ -52,4 +54,38 @@ module Lore
 
   end
 
+  class Type_Filters
+
+    @@input_filters = { 
+      PG_VCHAR_LIST          => lambda { |v| "{#{v.join(',')}}" }, 
+      PG_BOOL                => lambda { |v| if (v && v != 'f' || v == 't') then 'f' elsif (v.instance_of?(FalseClass) || v == 'f') then 'f' else nil end }, 
+      PG_DATE                => lambda { |v| v.to_s }, 
+      PG_TIME                => lambda { |v| v.to_s }, 
+      PG_TIMESTAMP_TIMEZONE  => lambda { |v| v.to_s }, 
+      PG_TIMESTAMP           => lambda { |v| v.to_s }, 
+    }
+    @@output_filters = { 
+      PG_VCHAR_LIST          => lambda { |v| v[1..-2].split(',') }, 
+      PG_INT                 => lambda { |v| if v then v.to_i else nil end }, 
+      PG_SMALLINT            => lambda { |v| if v then v.to_i else nil end },
+      PG_FLOAT               => lambda { |v| if v && v.length > 0 then v.to_f else nil end }, 
+      PG_DECIMAL             => lambda { |v| if v && v.length > 0 then v.to_f else nil end }, 
+      PG_BOOL                => lambda { |v| if v == 't' then true elsif v == 'f' then false else nil end }
+# SLOW!
+#     PG_DATE                => lambda { |v| Date.parse(v) if v }, 
+#     PG_TIME                => lambda { |v| Time.parse(v) if v }, 
+#     PG_TIMESTAMP_TIMEZONE  => lambda { |v| DateTime.parse(v) if v }, 
+#     PG_TIMESTAMP           => lambda { |v| DateTime.parse(v) if v }
+    }
+
+    def self.in
+      @@input_filters
+    end
+
+    def self.out
+      @@output_filters
+    end
+
+  end
+
 end # module

data/lib/lore/adapters/postgres.rb

@@ -0,0 +1,24 @@
+
+require('rubygems')
+begin
+  require('postgres')
+  require('lore/adapters/postgres/connection')
+  require('lore/adapters/postgres/result')
+  require('lore/adapters/postgres/types')
+rescue LoadError
+  begin
+    Lore.pg_server = 'unix:/var/run/postgresql/.s.PGSQL.5432'
+    Lore.logger.info { "Defaulted PG server to #{Lore.pg_server}" }
+    Lore.logger.info { "Use Lore.pg_server = 'server uri' to set a different one" } 
+  # Bridges PostgresPR::Connection to PGConn
+  # require 'postgres-pr/postgres-compat'
+    require('postgres-pr/connection')
+    require('lore/adapters/postgres-pr/connection')
+    require('lore/adapters/postgres-pr/result')
+    require('lore/adapters/postgres-pr/types')
+  rescue LoadError
+    Lore.logger.error { "No binding for postgres found" }
+    Lore.logger.error { "Please install 'postgres' or 'postgres-pr'" }
+  end
+end
+

data/lib/lore/adapters/postgres/connection.rb

@@ -0,0 +1,81 @@
+
+$:.push('/opt/local/lib/ruby/1.8/postgres')
+
+require('postgres')
+require('lore')
+require('lore/exceptions/database_exception')
+require('lore/adapters/context')
+require('lore/adapters/postgres/result')
+
+module Lore
+
+class Connection 
+
+  @@query_count      = 0
+  @@result_row_count = 0
+  
+  def initialize
+  end
+  
+  def self.reset_query_count
+    @@query_count = 0
+  end
+  def self.reset_result_row_count
+    @@result_row_count = 0
+  end
+  def self.query_count
+    @@query_count
+  end
+  def self.result_row_count
+    @@result_row_count
+  end
+  
+  def self.perform_cacheable(query)
+    if Lore::Cache::Cached_Entities.include?(query) then
+        result = Lore::Cache::Cached_Entities[query]
+    else
+      result = perform(query)
+      Lore::Cache::Cached_Entities[query] = result
+    end
+    return result
+  end
+  
+  def self.perform(query)
+    begin
+      @@query_count += 1
+    # result = Context.get_connection.exec(query)
+      result = Context.get_connection.async_exec(query)
+      @@result_row_count += result.num_tuples
+      
+      if Lore.log_queries? then
+        query.split("\n").each { |line|
+          Lore.query_logger.debug { "  sql|#{Context.get_context}| #{line}" }
+        }
+      end
+    rescue ::Exception => pge
+      pge.message << "\n" << query.inspect
+      Lore.logger.error { pge.message }
+      Lore.logger.error { 'Context: ' << Context.inspect }
+      Lore.logger.error { 'Query: ' << "\n" << query }
+      raise Lore::Exceptions::Database_Exception.new(pge.message << "\n" << query.to_s)
+    end
+    
+    return Result.new(query, result)
+  end
+
+  def self.establish(db_name)
+    begin
+    PGconn.connect(Lore.pg_server, 
+                   Lore.pg_port, 
+                   '', '', 
+                   db_name.to_s, 
+                   Lore.user_for(db_name.to_sym), 
+                   Lore.pass_for(db_name.to_sym))
+    rescue ::Exception => e
+      raise Lore::Exceptions::Database_Exception.new(e.message)
+    end
+  end
+  
+end # class Connection
+
+end # module Lore