og 0.16.0 → 0.17.0

data/lib/og/adapters/filesys.rb

@@ -1,117 +0,0 @@
-# * George Moschovitis  <gm@navel.gr>
-# (c) 2004-2005 Navel, all rights reserved.
-# $Id: filesys.rb 17 2005-04-14 16:03:40Z gmosx $
-
-require 'fileutils'
-
-require 'og/adapters/base'
-
-module Og
-
-# The Filesys adapter. This adapter stores Og objectes in
-# the filesystem. This adapter is a proof of concept and
-# at the moment severely limited. For extra documentation 
-# see lib/og/adapter.rb
-
-class FilesysAdapter < Adapter
-
-	# Creates the name of the database root dir.
-
-	def self.dir(database)
-		"#{database}_db"
-	end
-
-	def create_db(database, user = nil, password = nil)
-		begin
-			FileUtils.mkdir_p(self.class.dir(database))
-		rescue
-			Logger.error "Cannot create '#{database}'!"
-		end
-	end
-
-	def drop_db(database, user = nil, password = nil)
-		begin
-			FileUtils.rmdir(self.class.dir(database))	
-			super
-		rescue
-			Logger.error "Cannot drop '#{database}'!"
-		end
-	end
-
-	def insert_code(klass, db)
-		props = props_for_insert(klass)
-		values = props.collect { |p| write_prop(p) }.join(',') 
-		
-		sql = "INSERT INTO #{klass::DBTABLE} (#{props.collect {|p| p.name}.join(',')}) VALUES (#{values})"
-
-		%{
-			conn.store.query("#{sql}").close
-			@oid = conn.store.last_insert_row_id
-		}
-	end
-
-	def new_connection(db)
-		return FilesysConnection.new(db)
-	end
-
-	# A 'table' is emulated by using a directory to store
-	# one file per table row. Each file contains an object
-	# marshaled in YAML format. A special file called
-	# '_sequence' stores the sequence for this 'table'.
-	
-	def create_table(klass, db)
-		class_dir = File.join(self.class.dir(db.config[:database]), klass::DBTABLE)
-		FileUtils.mkdir_p(class_dir)
-		
-		seq_file = File.join(class_dir, 'seq')
-		File.open(seq_file, 'w') { |f| f << '1' }
-	rescue => ex
-		Logger.error "Cannot create directory to store '#{klass}' classes!"
-	end
-
-end
-
-# The Filesys adapter connection.
-
-class FilesysConnection < Connection
-
-	def initialize(db)
-		super
-		config = db.config
-
-		begin
-			raise unless File.directory?(FilesysAdapter.dir(config[:database]))
-		rescue => ex 
-			if true # ex.to_s =~ /database .* does not exist/i
-				Logger.info "Database '#{config[:database]}' not found!"
-				@db.adapter.create_db(config[:database], config[:user])
-				retry
-			end
-			raise
-		end
-	end
-
-	def save(obj)
-		seq = nil
-		class_dir = File.join(FilesysAdapter.dir(@db.config[:database]), obj.class::DBTABLE)
-		File.open(File.join(class_dir, 'seq'), 'r') { |f| seq = f.read.to_i }
-		obj.oid = seq
-		File.open(File.join(class_dir, "#{seq}.yml"), 'w') { |f| f << obj.to_yaml }
-		seq += 1
-		File.open(File.join(class_dir, 'seq'), 'w') { |f| f << seq }
-	end
-
-	def load(oid, klass)
-		obj = nil
-		class_dir = File.join(FilesysAdapter.dir(@db.config[:database]), klass::DBTABLE)
-		File.open(File.join(class_dir, "#{oid}.yml"), 'r') { |f| obj = YAML::load(f.read) }
-		return obj
-	end
-
-	def close
-		Logger.debug "Closed DB connection." if $DBG
-	end
-
-end
-
-end 

data/lib/og/adapters/mysql.rb

@@ -1,350 +0,0 @@
-# * George Moschovitis  <gm@navel.gr>
-# (c) 2004-2005 Navel, all rights reserved.
-# $Id: mysql.rb 17 2005-04-14 16:03:40Z gmosx $
-
-begin
-	require 'mysql'
-rescue Object => ex
-	Logger.error 'Ruby-Mysql bindings are not installed!'
-	Logger.error ex
-end
-
-require 'og/adapters/base'
-
-module Og
-
-# The MySQL adapter. This adapter communicates with 
-# an MySQL rdbms. For extra documentation see 
-# lib/og/adapter.rb
-
-class MysqlAdapter < Adapter
-
-	def initialize
-		super
-		@typemap.update(TrueClass => 'tinyint')
-		@typecast.update(TrueClass => "#\{:s: ? \"1\" : 'NULL' \}")
-	end
-	
-	def self.escape(str)
-		return nil unless str
-		return Mysql.quote(str)
-	end
-
-	def self.timestamp(time = Time.now)
-		return nil unless time
-		return time.strftime("%Y%m%d%H%M%S")
-	end
-	
-	def self.date(date)
-		return nil unless date
-		return "#{date.year}-#{date.month}-#{date.mday}" 
-	end
-	
-	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} ? 1 : 0 \}"
-		else 
-			# gmosx: keep the '' for nil symbols.
-			return %|#\{@#{p.symbol} ? "'#\{#{self.class}.escape(@#{p.symbol}.to_yaml)\}'" : "''"\}|
-		end
-	end		
-
-	def read_prop(p, idx)
-		if p.klass.ancestors.include?(Integer)
-			return "res[#{idx}].to_i"
-		elsif p.klass.ancestors.include?(Float)
-			return "res[#{idx}].to_f"
-		elsif p.klass.ancestors.include?(String)
-			return "res[#{idx}]"
-		elsif p.klass.ancestors.include?(Time)
-			return "#{self.class}.parse_timestamp(res[#{idx}])"
-		elsif p.klass.ancestors.include?(Date)
-			return "#{self.class}.parse_date(res[#{idx}])"
-		elsif p.klass.ancestors.include?(TrueClass)
-			return "('0' != res[#{idx}])"
-		else 
-			return "YAML::load(res[#{idx}])"
-		end				
-	end
-
-	def create_db(database, user = nil, password = nil)
-		# gmosx: system is used to avoid shell expansion.
-		system 'mysqladmin', '-f', "--user=#{user}", "--password=#{password}", 'create', database
-		super
-	end
-
-	def drop_db(database, user = nil, password = nil)
-		system 'mysqladmin', '-f', "--user=#{user}", "--password=#{password}", 'drop', database
-		super
-	end
-
-	def props_for_insert(klass)
-		klass.__props.reject { |p| :oid == p.symbol }
-	end
-
-	def insert_code(klass, db)
-		props = props_for_insert(klass)
-		values = props.collect { |p| write_prop(p) }.join(',') 
-		
-		sql = "INSERT INTO #{klass::DBTABLE} (#{props.collect {|p| p.name}.join(',')}) VALUES (#{values})"
-
-		%{
-			conn.store.query_with_result = false
-			conn.store.query "#{sql}"
-			@oid = conn.store.insert_id()
-		}
-	end
-
-	def new_connection(db)
-		return MysqlConnection.new(db)
-	end
-
-	def calc_field_index(klass, db)
-		res = db.query "SELECT * FROM #{klass::DBTABLE} LIMIT 1"
-		meta = db.managed_classes[klass]
-	
-		for idx in (0...res.num_fields)
-			meta.field_index[res.fetch_field.name] = idx
-		end
-
-	ensure
-		res.free if res
-	end
-
-	def create_fields(klass)
-		fields = []
-		
-		klass.__props.each do |p|
-			klass.sql_index(p.symbol) if p.meta[:sql_index]
-				
-			field = "#{p.symbol}"
-			
-			if p.meta and p.meta[:sql]
-				field << " #{p.meta[:sql]}"
-			else
-				field << " #{@typemap[p.klass]}"
-				
-				if p.meta
-					# set default value (gmosx: not that useful in the
-					# current implementation).
-					if default = p.meta[:default]
-						field << " DEFAULT #{default.inspect} NOT NULL"
-					end
-				
-					# set unique
-					# FIXME: correctly handle UNIQUE constrain.
-					# field << " UNIQUE" if p.meta[:unique]
-
-					# attach extra sql
-					if extra_sql = p.meta[:extra_sql]
-						field << " #{extra_sql}"
-					end
-				end
-			end
-			
-			fields << field 
-		end
-
-		return fields
-	end
-
-	def create_table(klass, db)
-		conn = db.get_connection
-
-		fields = create_fields(klass)
-
-		sql = "CREATE TABLE #{klass::DBTABLE} (#{fields.join(', ')}"
-		
-		conn.store.query_with_result = true 
-
-		# Create table constrains
-		
-		if klass.__meta and constrains = klass.__meta[:sql_constrain]
-			sql << ", #{constrains.join(', ')}"
-		end
-		
-		sql << ');'
-		
-		begin
-			conn.store.query(sql)
-			Logger.info "Created table '#{klass::DBTABLE}'."
-		rescue => ex
-			if ex.errno == 1050 # table already exists.
-				Logger.debug "Table already exists" if $DBG
-				return 
-			else
-				raise
-			end
-		end
-		
-		# Create indices
-		
-		if klass.__meta and indices = klass.__meta[:sql_index] 
-			for data in indices
-				idx, options = *data
-				idx = idx.to_s
-				pre_sql, post_sql = options[:pre], options[:post]
-				idxname = idx.gsub(/ /, "").gsub(/,/, "_").gsub(/\(.*\)/, "")
-				conn.store.query("CREATE #{pre_sql} INDEX #{klass::DBTABLE}_#{idxname}_idx #{post_sql} ON #{klass::DBTABLE} (#{idx})")
-			end
-		end
-
-		# Create join tables if needed. Join tables are used in
-		# 'many_to_many' relations.
-		
-		if klass.__meta and joins = klass.__meta[:sql_join] 
-			for data in joins
-				# the class to join to and some options.
-				join_name, join_class, options = *data
-				
-				# gmosx: dont use DBTABLE here, perhaps the join class
-				# is not managed yet.
-				join_table = "#{self.class.join_table(klass, join_class, join_name)}"
-				join_src = "#{self.class.encode(klass)}_oid"
-				join_dst = "#{self.class.encode(join_class)}_oid"
-				begin
-					conn.store.query("CREATE TABLE #{join_table} ( key1 integer NOT NULL, key2 integer NOT NULL )")
-					conn.store.query("CREATE INDEX #{join_table}_key1_idx ON #{join_table} (key1)")
-					conn.store.query("CREATE INDEX #{join_table}_key2_idx ON #{join_table} (key2)")
-				rescue => ex
-					if ex.errno == 1050 # table already exists.
-						Logger.debug "Join table already exists" if $DBG
-					else
-						raise
-					end
-				end
-			end
-		end		
-		
-	ensure
-		db.put_connection
-	end
-
-	def eval_og_oid(klass)
-		klass.class_eval %{
-			prop_accessor :oid, Fixnum, :sql => 'integer AUTO_INCREMENT PRIMARY KEY'
-		}
-	end
-end
-
-# The MySQL connection.
-
-class MysqlConnection < Connection
-
-	def initialize(db)
-		super
-
-		config = db.config
-
-		@store = Mysql.connect(
-			config[:address] || 'localhost', 
-			config[:user],
-			config[:password], 
-			config[:database]
-		)
-	rescue => ex
-		if ex.errno == 1049 # database does not exist.
-			Logger.info "Database '#{config[:database]}' not found!"
-			@db.adapter.create_db(config[:database], config[:user], config[:password])
-			retry
-		end
-		raise
-	end
-
-	def close
-		@store.close
-		super
-	end
-
-	def prepare(sql)
-		raise 'Not implemented!'
-	end
-
-	def query(sql)
-		Logger.debug sql if $DBG
-		begin
-			@store.query_with_result = true 
-			return @store.query(sql)
-		rescue => ex
-			handle_db_exception(ex, sql)
-		end
-	end
-
-	def exec(sql)
-		Logger.debug sql if $DBG
-		begin
-			@store.query_with_result = false
-			@store.query(sql) 
-		rescue => ex
-			handle_db_exception(ex, sql)
-		end
-	end
-
-	def start
-		#	@store.transaction
-	end
-	
-	def commit
-		# @store.commit
-	end
-
-	def rollback
-		# @store.rollback
-	end
-
-	def valid_res?(res)
-		return !(res.nil? or 0 == res.num_rows)
-	end
-
-	def read_one(res, klass)
-		return nil unless valid_res?(res)
-		
-		row = res.fetch_row
-		obj = klass.allocate
-		obj.og_read(row)
-		
-		res.free
-		return obj
-	end
-
-	def read_all(res, klass)
-		return [] unless valid_res?(res)
-
-		objects = []
-
-		for tuple in (0...res.num_rows)
-			row = res.fetch_row
-
-			obj = klass.allocate
-			obj.og_read(row)
-			
-			objects << obj
-		end
-	
-		res.free
-		return objects 
-	end
-
-	def read_int(res, idx = 0)
-		val =  res.fetch_row[idx].to_i
-		res.free
-		return val
-	end
-
-	def get_row(res)
-		res.fetch_row
-	end
-
-end
-
-end