og 0.16.0 → 0.17.0

data/lib/og/store/sql.rb

@@ -0,0 +1,599 @@
+require 'yaml'
+
+module Og
+
+module SqlUtils
+
+	# Escape an SQL string
+	
+	def escape(str)
+		return nil unless str
+		return str.gsub(/'/, "''")
+	end
+
+	# Convert a ruby time to an sql timestamp.
+	#--
+	# TODO: Optimize this
+	#++
+	 
+	def timestamp(time = Time.now)
+		return nil unless time
+		return time.strftime("%Y-%m-%d %H:%M:%S")
+	end
+	
+	# Output YYY-mm-dd
+	#--
+	# TODO: Optimize this.
+	#++
+	
+	def date(date)
+		return nil unless date
+		return "#{date.year}-#{date.month}-#{date.mday}" 
+	end
+	
+	# Parse sql datetime
+	#--
+	# TODO: Optimize this.
+	#++
+	
+	def parse_timestamp(str)
+		return nil unless str
+		return Time.parse(str)		
+	end
+	
+	# Input YYYY-mm-dd
+	#--
+	# TODO: Optimize this.
+	#++
+	
+	def parse_date(str)
+		return nil unless str
+		return Date.strptime(str)
+	end
+
+	def quote(val)
+		case val
+			when Fixnum, Integer, Float
+				val ? val.to_s : 'NULL'
+			when String
+				val ? "'#{escape(val)}'" : 'NULL'
+			when Time
+				val ? "'#{timestamp(val)}'" : 'NULL'
+			when Date
+				val ? "'#{date(val)}'" : 'NULL'
+			when TrueClass
+				val ? "'t'" : 'NULL'
+			else 
+				# gmosx: keep the '' for nil symbols.
+				val ? escape(val.to_yaml) : ''
+		end 
+	end
+
+	def table(klass)
+		"#{Og.table_prefix}#{klass.to_s.gsub(/::/, "_").downcase}"
+	end
+
+	def join_table(class1, class2, postfix = nil)
+		if class1.to_s < class2.to_s
+			return "j#{table(class1)}#{table(class2)}#{postfix}", 1, 2
+		else
+			return "j#{table(class2)}#{table(class1)}#{postfix}", 2, 1
+		end
+	end
+end
+
+# A Store that persists objects into a PostgreSQL database.
+
+class SqlStore < Store
+	extend SqlUtils
+	include SqlUtils
+
+	# The connection to the backend SQL RDBMS.
+
+	attr_accessor :conn
+
+	def initialize(options)
+		super
+
+		# The default Ruby <-> SQL type mappings, should be valid for most
+		# RDBM systems.
+		
+		@typemap = {
+			Integer => 'integer',
+			Fixnum => 'integer',
+			Float => 'float',
+			String => 'text',
+			Time => 'timestamp',
+			Date => 'date',
+			TrueClass => 'boolean',
+			Object => 'text',
+			Array => 'text',
+			Hash => 'text'
+		}
+	end
+
+	#--
+	# FIXME: not working.
+	#++
+
+	def enable_logging
+		require 'glue/aspects'
+		klass = self.class
+		klass.send :include, Glue::Aspects
+		klass.pre "Logger.info sql", :on => [:exec, :query]
+		Glue::Aspects.wrap(klass, [:exec, :query])
+	end
+
+	# Enchants a class. 
+
+	def enchant(klass, manager)
+		klass.const_set 'OGTABLE', table(klass)
+		klass.module_eval 'def self.table; OGTABLE; end'
+		
+		super
+	
+		create_table(klass) if Og.create_schema
+
+		eval_og_insert(klass)
+		eval_og_update(klass)
+		eval_og_read(klass)
+		eval_og_delete(klass)
+	end
+
+	# :section: Lifecycle methods.
+
+	# Loads an object from the store using the primary key.
+
+	def load(pk, klass)
+		res = query "SELECT * FROM #{klass::OGTABLE} WHERE #{klass.pk_symbol}=#{pk}"
+		read_one(res, klass)
+	end
+
+	# Reloads an object from the store.
+
+	def reload(obj, pk)
+		raise 'Cannot reload unmanaged object' unless obj.saved?
+		res = query "SELECT * FROM #{obj.class.table} WHERE #{obj.class.pk_symbol}=#{pk}"
+		obj.og_read(res.next, 0)
+	ensure
+		res.close if res
+	end
+
+	# If a properties collection is provided, only updates the 
+	# selected properties. Pass the required properties as symbols
+	# or strings.
+	
+	def update(obj, properties = nil)
+		if properties
+			if properties.is_a?(Array)
+				set = []
+				for p in properties
+					set << "#{p}=#{quote(obj.send(p))}"
+				end
+				set = set.join(',')
+			else
+				set = "#{properties}=#{quote(obj.send(properties))}"
+			end
+			exec "UPDATE #{obj.class.table} SET #{set} WHERE #{obj.class.pk_symbol}=#{obj.pk}"
+		else
+			obj.og_update(self)
+		end
+	end
+
+	# Update selected properties of an object or class of
+	# objects.
+	
+	def update_properties(target, set, options = nil)
+		set = set.gsub(/@/, '')
+		
+		if target.is_a?(Class)
+			sql = "UPDATE #{target.table} SET #{set} "
+			if options
+				if condition = options[:condition] || options[:where]
+					sql << " WHERE #{condition}"
+				end
+			end
+			exec sql
+		else
+			exec "UPDATE #{target.class.table} SET #{set} WHERE #{target.class.pk_symbol}=#{target.pk}"		
+		end			
+	end
+	alias_method :pupdate, :update_properties
+	alias_method :update_property, :update_properties
+
+	# Find a collection of objects.
+	#
+	# === Examples
+	#
+	# User.find(:condition  => 'age > 15', :order => 'score ASC', :offet => 10, :limit =>10)
+	# Comment.find(:include => :entry)
+	
+	def find(options)	
+		klass = options[:class]
+		sql = resolve_options(klass, options)
+		read_all(query(sql), klass, options[:include])
+	end
+
+	# Find one object.
+	
+	def find_one(options)
+		klass = options[:class]
+		options[:limit] ||= 1				
+		sql = resolve_options(klass, options)
+		read_one(query(sql), klass, options[:include])
+	end
+
+	def count(options)
+		if options.is_a?(String)
+			sql = options
+		else
+			sql = "SELECT COUNT(*) FROM #{options[:class]::OGTABLE}"
+			if condition = options[:condition]
+				sql << " WHERE #{condition}"
+			end
+		end		
+		
+		query(sql).first_value.to_i
+	end
+	
+	# Relate two objects through an intermediate join table.
+	# Typically used in joins_many and many_to_many relations.
+	
+	def join(obj1, obj2, table)
+		if obj1.class.to_s > obj2.class.to_s
+			obj1, obj2 = obj2, obj1
+		end		
+		
+		exec "INSERT INTO #{table} (key1, key2) VALUES (#{obj1.pk}, #{obj2.pk})"
+	end 
+	
+	# :section: Transaction methods.
+	
+	# Start a new transaction.
+	
+	def start	
+		exec('START TRANSACTION') if @transaction_nesting < 1
+		@transaction_nesting += 1
+	end
+	
+	# Commit a transaction.
+	
+	def commit
+		@transaction_nesting -= 1
+		exec('COMMIT') if @transaction_nesting < 1
+	end
+	
+	# Rollback a transaction.
+	
+	def rollback
+		@transaction_nesting -= 1
+		exec('ROLLBACK') if @transaction_nesting < 1
+	end
+
+private
+
+	def create_table(klass)
+		raise 'Not implemented'
+	end
+
+	def drop_table(klass)
+		exec "DROP TABLE #{klass.table}"
+	end
+
+	# Create the columns that correpsond to the klass properties.
+	# The generated columns array is used in create_table.
+	# If the property has an :sql metadata this overrides the 
+	# default mapping. If the property has an :extra_sql metadata 
+	# the extra sql is appended after the default mapping.
+	
+	def columns_for_class(klass)
+		columns = []
+	
+		klass.__props.each do |p|
+			klass.index(p.symbol) if p.meta[:index]
+				
+			column = p.symbol.to_s
+			
+			if p.meta and p.meta[:sql]
+				column << " #{p.meta[:sql]}"
+			else
+				column << " #{type_for_class(p.klass)}"
+				
+				if p.meta
+					if default = p.meta[:default]
+						column << " DEFAULT #{default.inspect} NOT NULL"
+					end
+				
+					column << " UNIQUE" if p.meta[:unique]
+
+					if extra_sql = p.meta[:extra_sql]
+						column << " #{extra_sql}"
+					end
+				end
+			end
+			
+			columns << column
+		end
+
+		return columns
+	end
+
+	def type_for_class(klass)
+		@typemap[klass]		
+	end
+
+	# Return an sql string evaluator for the property.
+	# No need to optimize this, used only to precalculate code.
+	# YAML is used to store general Ruby objects to be more 
+	# portable.
+	#--
+	# FIXME: add extra handling for float.
+	#++
+	
+	def write_prop(p)
+		if p.klass.ancestors.include?(Integer)
+			return "#\{@#{p.symbol} || 'NULL'\}"
+		elsif p.klass.ancestors.include?(Float)
+			return "#\{@#{p.symbol} || 'NULL'\}"		
+		elsif p.klass.ancestors.include?(String)
+			return %|#\{@#{p.symbol} ? "'#\{#{self.class}.escape(@#{p.symbol})\}'" : 'NULL'\}|
+		elsif p.klass.ancestors.include?(Time)
+			return %|#\{@#{p.symbol} ? "'#\{#{self.class}.timestamp(@#{p.symbol})\}'" : 'NULL'\}|
+		elsif p.klass.ancestors.include?(Date)
+			return %|#\{@#{p.symbol} ? "'#\{#{self.class}.date(@#{p.symbol})\}'" : 'NULL'\}|
+		elsif p.klass.ancestors.include?(TrueClass)
+			return "#\{@#{p.symbol} ? \"'t'\" : 'NULL' \}"
+		else 
+			# gmosx: keep the '' for nil symbols.
+			return %|#\{@#{p.symbol} ? "'#\{#{self.class}.escape(@#{p.symbol}.to_yaml)\}'" : "''"\}|
+		end
+	end		
+
+	# Return an evaluator for reading the property.
+	# No need to optimize this, used only to precalculate code.
+	
+	def read_prop(p, col)
+		if p.klass.ancestors.include?(Integer)
+			return "res[#{col} + offset].to_i"
+		elsif p.klass.ancestors.include?(Float)
+			return "res[#{col} + offset].to_f"
+		elsif p.klass.ancestors.include?(String)
+			return "res[#{col} + offset]"
+		elsif p.klass.ancestors.include?(Time)
+			return "#{self.class}.parse_timestamp(res[#{col} + offset])"
+		elsif p.klass.ancestors.include?(Date)
+			return "#{self.class}.parse_date(res[#{col} + offset])"
+		elsif p.klass.ancestors.include?(TrueClass)
+			return "('0' != res[#{col} + offset])"
+		else 
+			return "YAML::load(res[#{col} + offset])"
+		end				
+	end
+
+	# :section: Lifecycle method compilers.
+	
+	# Compile the og_update method for the class.
+
+	def eval_og_insert(klass)
+		pk = klass.pk_symbol
+		props = klass.properties
+		values = props.collect { |p| write_prop(p) }.join(',') 
+		
+		sql = "INSERT INTO #{klass.table} (#{props.collect {|p| p.symbol.to_s}.join(',')}) VALUES (#{values})"
+
+		klass.module_eval %{ 
+			def og_insert(store)
+				#{Aspects.gen_advice_code(:og_insert, klass.advices, :pre) if klass.respond_to?(:advices)}
+				store.exec "#{sql}"
+				#{Aspects.gen_advice_code(:og_insert, klass.advices, :post) if klass.respond_to?(:advices)}
+			end
+		}
+	end
+
+	# Compile the og_update method for the class.
+
+	def eval_og_update(klass)
+		pk = klass.pk_symbol
+		props = klass.properties.reject { |p| pk == p.symbol }
+		
+		updates = props.collect { |p|
+			"#{p.symbol}=#{write_prop(p)}"
+		}
+
+		sql = "UPDATE #{klass::OGTABLE} SET #{updates.join(', ')} WHERE #{pk}=#\{@#{pk}\}"
+
+		klass.module_eval %{
+			def og_update(store)
+				#{Aspects.gen_advice_code(:og_update, klass.advices, :pre) if klass.respond_to?(:advices)}
+				store.exec "#{sql}"
+				#{Aspects.gen_advice_code(:og_update, klass.advices, :post) if klass.respond_to?(:advices)}
+			end
+		}
+	end
+
+	# Compile the og_read method for the class. This method is 
+	# used to read (deserialize) the  given class from the store. 
+	# In order to allow for changing column/attribute orders a 
+	# column mapping hash is used.
+	
+	def eval_og_read(klass)
+		code = []
+		props = klass.properties 
+		column_map = create_column_map(klass)
+
+		props.each do |p|
+			if col = column_map[p.symbol]
+				code << "@#{p.symbol} = #{read_prop(p, col)}"
+			end
+		end
+		
+		code = code.join('; ')
+
+		klass.module_eval %{
+	 		def og_read(res, row = 0, offset = 0)
+				#{Aspects.gen_advice_code(:og_read, klass.advices, :pre) if klass.respond_to?(:advices)}
+				#{code}
+				#{Aspects.gen_advice_code(:og_read, klass.advices, :post) if klass.respond_to?(:advices)}
+			end
+		}
+	end				
+
+	#--
+	# FIXME: is pk needed as parameter?
+	#++
+	
+	def eval_og_delete(klass)
+		klass.module_eval %{
+	 		def og_delete(store, pk, cascade = true)
+				#{Aspects.gen_advice_code(:og_delete, klass.advices, :pre) if klass.respond_to?(:advices)}
+				pk ||= @#{klass.pk_symbol}
+				transaction do |tx|
+					tx.exec "DELETE FROM #{klass.table} WHERE #{klass.pk_symbol}=\#{pk}"
+					if cascade and #{klass}.__meta[:descendants]
+						#{klass}.__meta[:descendants].each do |dclass, foreign_key|
+							tx.exec "DELETE FROM \#{dclass::OGTABLE} WHERE \#{foreign_key}=\#{pk}"
+						end
+					end
+				end
+				#{Aspects.gen_advice_code(:og_delete, klass.advices, :post) if klass.respond_to?(:advices)}
+			end
+		}		
+	end
+
+	# :section: Misc methods.
+
+	def handle_sql_exception(ex, sql = nil)
+		Logger.error "DB error #{ex}, [#{sql}]"
+		Logger.error ex.backtrace.join("\n")
+		raise StoreException.new(ex, sql) if Og.raise_store_exceptions
+
+		# FIXME: should return :error or something.
+		return nil 
+	end
+
+	def resolve_options(klass, options)
+		tables = [klass::OGTABLE]
+
+		if included = options[:include]
+			join_conditions = []
+
+			for name in [included].flatten
+				if rel = klass.relation(name)
+					target_table = rel[:target_class]::OGTABLE
+					tables << target_table
+					join_conditions << "#{klass::OGTABLE}.#{rel[:foreign_key]}=#{target_table}.#{rel[:target_pk]}"
+				else
+					raise 'Unknown relation name'
+				end
+			end
+
+			columns = tables.collect { |t| "#{t}.*" }.join(',')
+
+			if options[:condition]
+				options[:condition] +=  " AND #{join_conditions.join(' AND ')}"
+			else
+				options[:condition] = join_conditions.join(' AND ')
+			end
+		else
+			columns = '*'
+		end
+
+		if join_table = options[:join_table]
+			tables << join_table
+			if options[:condition]
+				options[:condition] +=  " AND #{options[:join_condition]}"
+			else
+				options[:condition] = options[:join_condition]
+			end
+		end
+
+		sql = "SELECT #{columns} FROM #{tables.join(',')}"
+		
+		if condition = options[:condition] || options[:where]
+			sql << " WHERE #{condition}"
+		end
+		
+		if order = options[:order]
+			sql << " ORDER BY #{order}"
+		end
+
+		if offset = options[:offset]
+			sql << " OFFSET #{offset}"
+		end
+		
+		if limit = options[:limit]
+			sql << " LIMIT #{limit}"
+		end
+
+		if extra = options[:extra]
+			sql << " #{extra}"
+		end		
+		
+		return sql
+	end
+		
+	# :section: Deserialization methods.
+
+	# Deserialize the join relations.
+	
+	def read_join_relations(obj, res, row, join_relations)
+		offset = obj.class.properties.size 
+		
+		for rel in join_relations 
+			rel_obj = rel[:target_class].allocate
+			rel_obj.og_read(res, row, offset) 
+			offset += rel_obj.class.properties.size 
+			obj.instance_variable_set("@#{rel[:name]}", rel_obj)
+		end
+	end
+
+	# Deserialize one object from the ResultSet.
+		 
+	def read_one(res, klass, join_relations = nil)
+		return nil if res.blank?
+
+		if join_relations
+			join_relations = [join_relations].flatten.collect do |n| 
+				klass.relation(n) 
+			end
+		end
+		
+		row = res.next
+		
+		obj = klass.allocate
+		obj.og_read(row)
+		read_join_relations(obj, row, 0, join_relations) if join_relations
+
+		res.close
+
+		return obj
+	end
+
+	# Deserialize all objects from the ResultSet.
+
+	def read_all(res, klass, join_relations)
+		return [] if res.blank?
+
+		if join_relations
+			join_relations = [join_relations].flatten.collect do |n| 
+				klass.relation(n) 
+			end
+		end
+
+		objects = []
+
+		res.each_row do |res_row, row|		
+			obj = klass.allocate
+			obj.og_read(res_row, row)
+			read_join_relations(obj, res_row, row, join_relations) if join_relations
+			objects << obj
+		end
+		
+		res.close
+		
+		return objects
+	end
+
+end
+
+end