og 0.16.0 → 0.17.0

data/lib/og/adapters/sqlite.rb

@@ -1,265 +0,0 @@
-# * George Moschovitis  <gm@navel.gr>
-# (c) 2004-2005 Navel, all rights reserved.
-# $Id: sqlite.rb 17 2005-04-14 16:03:40Z gmosx $
-
-begin
-	require 'sqlite3'
-rescue Object => ex
-	Logger.error 'Ruby-Sqlite3 bindings are not installed!'
-	Logger.error ex
-end
-
-require 'fileutils'
-
-require 'og/adapters/base'
-
-module Og
-
-# The SQLite adapter. This adapter communicates with 
-# an SQLite3 rdbms. For extra documentation see 
-# lib/og/adapter.rb
-
-class SqliteAdapter < Adapter
-
-	def drop_db(database, user = nil, password = nil)
-		begin
-			FileUtils.rm("#{database}.db")	
-			super
-		rescue
-			Logger.error "Cannot drop '#{database}'!"
-		end
-	end
-=begin
-	def write_prop(p)
-		if p.klass.ancestors.include?(Integer)
-			return "@#{p.symbol}"
-		elsif p.klass.ancestors.include?(Float)
-			return "@#{p.symbol}"
-		elsif p.klass.ancestors.include?(String)
-			return "#{self.class}.escape(@#{p.symbol})"
-		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 
-			return %|#\{@#{p.symbol} ? "'#\{#{self.class}.escape(@#{p.symbol}.to_yaml)\}'" : "''"\}|
-		end
-	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
-		}
-=begin		
-		props = props_for_insert(klass)
-		
-		placeholders = Array.new(props.size, '?').join(',')
-		values = props.collect { |p| write_prop(p) }.join(',') 
-		
-		sql = "INSERT INTO #{klass::DBTABLE} (#{props.collect {|p| p.name}.join(',')}) VALUES (#{placeholders})"
-		klass.class_eval %{
-			cattr_accessor :og_insert_statement
-		}
-
-		klass.og_insert_statement = db.prepare(sql) 
-
-		%{
-			#{pre_cb}
-			@@og_insert_statement.execute(#{values})
-			@oid = conn.store.last_insert_row_id
-			#{post_cb}
-		}
-=end
-	end
-
-	def new_connection(db)
-		return SqliteConnection.new(db)
-	end
-
-	def calc_field_index(klass, db)
-		res = db.query "SELECT * FROM #{klass::DBTABLE} LIMIT 1"
-		meta = db.managed_classes[klass]
-
-		columns = res.columns
-
-		for idx in (0...columns.size)
-			meta.field_index[columns[idx]] = idx
-		end
-  
-	ensure
-		res.close
-	end
-
-	def create_table(klass, db)
-		conn = db.get_connection
-
-		fields = create_fields(klass)
-
-		sql = "CREATE TABLE #{klass::DBTABLE} (#{fields.join(', ')}"
-		
-		# Create table constrains
-		
-		if klass.__meta and constrains = klass.__meta[:sql_constrain]
-			sql << ", #{constrains.join(', ')}"
-		end
-		
-		sql << ");"
-		
-		# 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(/\(.*\)/, "")
-				sql << " CREATE #{pre_sql} INDEX #{klass::DBTABLE}_#{idxname}_idx #{post_sql} ON #{klass::DBTABLE} (#{idx});"  
-			end
-		end
-
-		begin
-			conn.store.query(sql).close
-			Logger.info "Created table '#{klass::DBTABLE}'."
-		rescue Exception => ex
-			# gmosx: any idea how to better test this?
-			if ex.to_s =~ /table .* already exists/i
-				Logger.debug "Table already exists" if $DBG
-				return
-			else
-			  raise
-			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 )").close
-					conn.store.query("CREATE INDEX #{join_table}_key1_idx ON #{join_table} (key1)").close
-					conn.store.query("CREATE INDEX #{join_table}_key2_idx ON #{join_table} (key2)").close
-				rescue Exception => ex
-					# gmosx: any idea how to better test this?
-					if ex.to_s =~ /table .* already exists/i
-						Logger.debug "Join table already exists" if $DBG
-					else
-					  raise
-					end
-				end
-			end
-		end
-
-	ensure
-		db.put_connection
-	end
-
-end
-
-# The SQLite connection.
-
-class SqliteConnection < Connection
-
-	def initialize(db)
-		@store = SQLite3::Database.new("#{db.config[:database]}.db")
-		super
-	end
-
-	def close
-		@store.close
-		super
-	end
-
-	def prepare(sql)
-		@store.prepare(sql)
-	end
-
-	def query(sql)
-		Logger.debug sql if $DBG
-		begin
-			return @store.query(sql)
-		rescue => ex
-			handle_db_exception(ex, sql)
-		end
-	end
-
-	def exec(sql)
-		Logger.debug sql if $DBG
-		begin
-			@store.query(sql).close 
-		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?)
-	end
-
-	def read_one(res, klass)
-		return nil unless valid_res?(res)
-		row = res.next
-		return nil unless row
-
-		obj = klass.allocate
-		obj.og_read(row)
-	
-		res.close
-		return obj
-	end
-
-	def read_all(res, klass)
-		return [] unless valid_res?(res)
-		objects = []
-
-		res.each do |row|
-			obj = klass.allocate
-			obj.og_read(row)
-			objects << obj
-		end
-		
-		res.close
-		return objects
-	end
-
-	def read_int(res, idx = 0)
-		val = res.next[idx].to_i
-		res.close
-		return val
-	end
-
-	def get_row(res)
-		res.next
-	end
-
-end
-
-end 

data/lib/og/adapters/sqlserver.rb

@@ -1,356 +0,0 @@
-# * Anastasios Koutoumanos  <ak@navel.gr>
-# (c) 2004-2005 Navel, all rights reserved.
-# $Id: sqlserver.rb 17 2005-04-14 16:03:40Z gmosx $
-
-begin
-	require 'dbi'
-rescue Object => ex
-	Logger.error 'Ruby-DBI bindings not present or ADO support not available.'
-	Logger.error ex
-end
-
-require 'og/adapters/base'
-
-module Og
-
-# The Microsoft SQL Server Sql Server adapter. This adapter 
-# communicates with a Microsoft SQL Server sql server rdbms. 
-# This adapter will ONLY work on Windows systems, since it 
-# relies on Win32OLE is apparently only available on Windows.
-# It relies on the ADO support in the DBI module. If you are using the
-# one-click installer of Ruby, then you already have DBI installed, but
-# the ADO module is *NOT* installed. You will need to get the latest
-# source distribution of Ruby-DBI from http://ruby-dbi.sourceforge.net/
-# unzip it, and copy the file <tt>src/lib/dbd_ado/ADO.rb</tt> to
-# <tt>X:/Ruby/lib/ruby/site_ruby/1.8/DBD/ADO/ADO.rb</tt> 
-# (you will need to create the ADO directory). Once you've installed 
-# that file, you are ready to go.
-# Originally based on the  sqlserver_adapter.rb -- the ActiveRecord 
-# adapter for Microsoft SQL Server by Joey Gibson and DeLynn Berry.
-# Information related to the SQL Server datatypes: 
-# http://msdn.microsoft.com/library/default.asp?url=/library/en-us/architec/8_ar_da_4ucz.asp
-# For extra documentation see lib/og/adapter.rb
-
-class SqlserverAdapter < Adapter
-
-	def initialize
-		super
-		@typemap.update(
-				Integer => 'int',           # drak: maybe smallint?
-				Fixnum => 'int', 
-				Float => 'float',
-				String => 'varchar(1024)',  # drak: maybe nvarchar for unicode
-				Time => 'datetime',         # drak: maybe smalldatime?
-				Date => 'smalldatetime',
-				TrueClass => 'bit'
-		)
-		
-		@typecast.update(TrueClass => "#\{:s: ? \'1\' : '0' \}")
-	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 read_prop(p, idx)			
-		if p.klass.ancestors.include?(Integer)
-			return "res[tuple][#{idx}].to_i"
-		elsif p.klass.ancestors.include?(Float)
-			return "res[tuple][#{idx}].to_f"
-		elsif p.klass.ancestors.include?(String)
-			return "res[tuple][#{idx}]"
-		elsif p.klass.ancestors.include?(Time)
-			return "#{self.class}.parse_timestamp(res[tuple][#{idx}])"
-		elsif p.klass.ancestors.include?(Date)
-			return "#{self.class}.parse_date(res[tuple][#{idx}])"
-		elsif p.klass.ancestors.include?(TrueClass)
-			return "('0' != res[tuple][#{idx}])"
-		else 
-			return "YAML::load(res[tuple][#{idx}])"
-		end				
-	end
-
-	def create_db(database, user = nil, password = nil)
-		raise 'Not implemented!'
-		
-		### how can we get a valid connection when the database does not already exist?
-		begin
-			conn = DBI.connect("DBI:ADO:Provider=SQLOLEDB;Data Source=localhost;Initial Catalog=master;User Id=sa;Password=sa;")
-			conn["AutoCommit"] = true
-			conn.execute("CREATE DATABASE #{database}")
-			conn.commit
-			Logger.warn "Ignoring credentials for database creation (not implemented)" if user
-			Logger.info "Created database '#{database}'."
-			super
-		rescue Exception => ex
-      # gmosx: any idea how to better test this?
-      if ex.to_s =~ /0x80020009/i
-				Logger.warn "Cannot drop database '#{database}', it does not exist!"
-				super
-      else
-        raise
-      end
-		end
-	end
-
-	def drop_db(database, user = nil, password = nil)
-		raise 'Not implemented!'
-
-		begin
-			conn = DBI.connect("DBI:ADO:Provider=SQLOLEDB;Data Source=localhost;Initial Catalog=master;User Id=sa;Password=sa;")
-			conn["AutoCommit"] = true
-# FIXME: why no drop?
-#			conn.execute("DROP DATABASE #{database}")
-			Logger.warn "Ignoring credentials for database drop (not implemented)" if user
-			Logger.info "Dropped database '#{database}'."
-			super
-		rescue Exception => ex
-      # gmosx: any idea how to better test this?
-      if ex.to_s =~ /0x80020009/i
-				Logger.warn "Cannot drop database '#{database}', it does not exist!"
-				super
-      else
-        raise
-      end
-		end
-	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.exec "#{sql}"
-			conn.commit
-			res = conn.query("SELECT IDENT_CURRENT('#{klass::DBTABLE}')")
-			@oid = res[0][0].to_i
-			#res.finish
-		}
-	end
-
-	def new_connection(db)
-		return SqlserverConnection.new(db)
-	end
-
-	def calc_field_index(klass, db)
-		res = db.get_connection.store.execute("SELECT TOP 1 * FROM #{klass::DBTABLE}")
-		meta = db.managed_classes[klass]
-		columns = res.column_names
-
-		for idx in (0...columns.size)
-			meta.field_index[columns[idx]] = idx
-		end
-  
-	ensure
-		res.finish
-	end
-
-	def create_table(klass, db)
-		conn = db.get_connection
-
-		fields = create_fields(klass)
-
-		sql = "CREATE TABLE #{klass::DBTABLE} (#{fields.join(', ')}"
-		
-		# Create table constrains.
-		if klass.__meta and constrains = klass.__meta[:sql_constrain]
-			sql << ", #{constrains.join(', ')}"
-		end
-		sql << ");"
-		
-		begin
-			conn.store.execute(sql)
-			conn.commit
-			Logger.info "Created table '#{klass::DBTABLE}'."
-		rescue => ex
-			if ex.to_s =~ /80040E14/i
-				Logger.debug 'Table already exists' if $DBG
-			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(/\(.*\)/, "")
-				sql << " CREATE #{pre_sql} INDEX #{klass::DBTABLE}_#{idxname}_idx #{post_sql} ON #{klass::DBTABLE} (#{idx});"
-				begin
-					conn.store.execute(sql)
-					conn.commit
-				rescue => ex
-					if ex.to_s =~ /80040E14/i
-						Logger.debug 'Table already exists' if $DBG
-					else
-						raise
-					end
-				end
-			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.execute("CREATE TABLE #{join_table} ( key1 integer NOT NULL, key2 integer NOT NULL )").finish
-					conn.store.execute("CREATE INDEX #{join_table}_key1_idx ON #{join_table} (key1)").finish
-					conn.store.execute("CREATE INDEX #{join_table}_key2_idx ON #{join_table} (key2)").finish
-					conn.commit
-				rescue => ex
-					# gmosx: any idea how to better test this?
-					if ex.to_s =~ /80040E14/i
-						Logger.debug "Join table already exists" if $DBG
-					else
-						raise
-					end
-				end
-			end
-		end
-
-	ensure
-		db.put_connection
-	end
-
-	def drop_table(klass)
-		super
-		exec "DROP TABLE #{klass::DBTABLE}"		
-	end
-
-	# Generate the property for oid.
-
-	def eval_og_oid(klass)
-		klass.class_eval %{
-			prop_accessor :oid, Fixnum, :sql => 'int NOT NULL IDENTITY(1, 1) PRIMARY KEY'
-		}
-	end
-
-end
-
-# The SqlserverConnection connection.
-
-class SqlserverConnection < Connection
-
-	def initialize(db)
-		super
-		config = db.config
-
-		begin
-			@store = DBI.connect("DBI:ADO:Provider=SQLOLEDB;Data Source=#{config[:address]};Initial Catalog=#{config[:database]};User Id=#{config[:user].to_s};Password=#{config[:password].to_s};")
-		rescue => ex
-			# gmosx, FIXME: drak, fix this!
-			if 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 close
-		@store.disconnect
-		super
-	end
-
-	def prepare(sql)
-		@store.prepare(sql)
-	end
-
-	def query(sql)
-		Logger.debug sql if $DBG
-		begin
-			res = @store.select_all(sql)
-			return res
-		rescue => ex
-			handle_db_exception(ex, sql)
-		end
-	end
-
-	def exec(sql)
-		Logger.debug sql if $DBG
-		begin
-			@store.execute(sql).finish 
-		rescue => ex
-			handle_db_exception(ex, sql)
-		end
-	end
-
-	def start
-		# no need to do something.
-	end
-	
-	def commit
-		@store.commit
-	end
-
-	def rollback
-		@store.rollback
-	end
-
-	def valid_res?(res)
-		return !(res.nil?)
-	end
-
-	def read_one(res, klass)
-		return nil unless valid_res?(res)
-		return nil unless res
-
-		obj = klass.allocate
-		obj.og_read(res)
-	
-		return obj
-	end
-
-	def read_all(res, klass)
-		return [] unless valid_res?(res)
-		objects = []
-
-		for tuple in (0...res.size)
-			obj = klass.allocate
-			obj.og_read(res, tuple)
-			objects << obj
-		end
-
-		return objects
-	end
-
-	def read_int(res, idx = 0)
-		val = res.next[idx].to_i
-		res.finish
-		return val
-	end
-
-	def get_row(res)
-		res.next
-	end
-
-end
-
-end