og 0.9.5 → 0.10.0

data/lib/og/adapters/sqlite.rb

@@ -0,0 +1,262 @@
+# * George Moschovitis  <gm@navel.gr>
+# (c) 2004-2005 Navel, all rights reserved.
+# $Id: sqlite.rb 259 2005-02-15 08:54:54Z gmosx $
+
+require 'sqlite3'
+require 'fileutils'
+
+require 'og/adapter'
+require 'og/connection'
+require 'glue/attribute'
+
+class 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, pre_cb, post_cb)
+		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})"
+
+		%{
+			#{pre_cb}
+			conn.store.query("#{sql}").close
+			@oid = conn.store.last_insert_row_id
+			#{post_cb}
+		}
+=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 Og::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_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_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
+			Logger.error "DB error #{ex}, [#{sql}]"
+			Logger.error ex.backtrace.join("\n")
+			return nil
+		end
+	end
+
+	def exec(sql)
+		Logger.debug sql if $DBG
+		begin
+			@store.query(sql).close 
+		rescue => ex
+			Logger.error "DB error #{ex}, [#{sql}]"
+			Logger.error ex.backtrace.join("\n")
+		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.new
+		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.new
+			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
+
+end
+
+end 

data/lib/og/backend.rb

@@ -1,6 +1,6 @@
 # * George Moschovitis  <gm@navel.gr>
 # (c) 2004-2005 Navel, all rights reserved.
-# $Id: backend.rb 202 2005-01-17 10:44:13Z gmosx $
+# $Id: backend.rb 249 2005-02-04 14:03:00Z gmosx $
 
 require 'yaml'
 

data/lib/og/connection.rb

@@ -1,6 +1,6 @@
 # * George Moschovitis  <gm@navel.gr>
 # (c) 2004-2005 Navel, all rights reserved.
-# $Id: connection.rb 248 2005-01-31 13:38:34Z gmosx $
+# $Id: connection.rb 254 2005-02-10 12:44:05Z gmosx $
 
 class Og; 
 
@@ -12,41 +12,138 @@ require 'glue/time'
 # functionality. A backend specific implementation file (driver) 
 # implements all methods.
 #
-# === Future 
+# == Future 
 #
 # - support caching.
 # - support prepared statements.
 
 class Connection
-	# The frontend (Og) contains useful strucutres.
-	
-	attr_reader :og
-	
-	# The backend
+
+	# The Og database object. 
 	
 	attr_reader :db
 
-	# If set to true, the select methods deserialize the 
-	# resultset to create entities.
+	# The actual connection to the backend store.
+
+	attr_accessor :store
+
+	# - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 
+	# :section: Backend connection methods.
+	# - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
 
-	attr_accessor :deserialize 
-		
 	# Initialize a connection to the database.
 	
-	def initialize(og)
-		@og = og
-		@db = @og.config[:backend].new(@og.config)
-		@deserialize = true
+	def initialize(db)
+		@db = db
 		Logger.debug "Created DB connection." if $DBG 
 	end
 	
 	# Close the connection to the database.
 	
-	def close()
-		@db.close()
+	def close
+		@store.close
 		Logger.debug "Closed DB connection." if $DBG
 	end
 
+	# Create the managed object table. The properties of the
+	# object are mapped to the table columns. Additional sql relations
+	# and constrains are created (indicices, sequences, etc).
+	
+	def create_table(klass)
+		raise 'Not implemented!'
+	end
+	
+	# Drop the managed object table.
+	
+	def drop_table(klass)
+		exec "DROP TABLE #{klass::DBTABLE}"
+	end
+
+	# Prepare an sql statement.
+
+	def prepare(sql)
+		raise 'Not implemented!'		
+	end
+	
+	# Execute an SQL query and return the result.
+	
+	def query(sql)
+		raise 'Not implemented!'
+	end
+	
+	# Execute an SQL query, no result returned.
+	
+	def exec(sql)
+		raise 'Not implemented!'
+	end
+	alias_method :execute, :exec
+
+	# Start a new transaction.
+	
+	def start
+		exec 'START TRANSACTION'
+	end
+	
+	# Commit a transaction.
+	
+	def commit
+		exec 'COMMIT'
+	end
+	
+	# Rollback a transaction.
+	
+	def rollback
+		exec 'ROLLBACK'
+	end
+	
+	# Transaction helper. In the transaction block use
+	# the db pointer to the backend.
+	
+	def transaction(&block)
+		begin
+			start
+			yield(self) 
+			commit
+		rescue => ex
+			Logger.error "DB Error: ERROR IN TRANSACTION"
+			Logger.error "#{ex}"
+			Logger.error "#{ex.backtrace}"
+			rollback
+		end
+	end
+		
+	# - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 
+	# :section: Deserialization methods.
+	# - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+
+	# Is the given resultset valid?
+
+	def valid_res?(res)
+		return !(res.nil?)
+	end
+	
+	# Read (deserialize) one row of the resultset.
+	
+	def read_one(res, klass)
+		raise 'Not implemented!'
+	end
+
+	# Read (deserialize) all rows of the resultset.
+
+	def read_all(res, klass)
+		raise 'Not implemented!'
+	end
+
+	# Read the first column of the resultset as an Integer.
+
+	def read_int(res, idx = 0)
+		raise 'Not implemented!'
+	end
+
+	# - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 
+	# :section: Managed object methods.
+	# - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+
 	# Save an object to the database. Insert if this is a new object or
 	# update if this is already stored in the database.
 		
@@ -110,7 +207,7 @@ class Connection
 	
 	def load_by_oid(oid, klass)
 		res = query "SELECT * FROM #{klass::DBTABLE} WHERE oid=#{oid}"
-		@deserialize? @db.deserialize_one(res, klass) : res
+		read_one(res, klass)
 	end
 	alias_method :get_by_oid, :load_by_oid
 	
@@ -118,7 +215,7 @@ class Connection
 	
 	def load_by_name(name, klass)
 		res = query "SELECT * FROM #{klass::DBTABLE} WHERE name='#{name}'"
-		@deserialize? @db.deserialize_one(res, klass) : res
+		read_one(res, klass)
 	end
 	alias_method :get_by_name, :load_by_name
 	
@@ -127,7 +224,7 @@ class Connection
 	
 	def load_all(klass, extrasql = nil)
 		res = query "SELECT * FROM #{klass::DBTABLE} #{extrasql}"
-		@deserialize? @db.deserialize_all(res, klass) : res
+		read_all(res, klass)
 	end
 	alias_method :get_all, :load_all
 	
@@ -139,8 +236,8 @@ class Connection
 			sql = "SELECT * FROM #{klass::DBTABLE} WHERE #{sql}"
 		end
 		
-		res = @db.safe_query(sql)
-		@deserialize? @db.deserialize_all(res, klass) : res
+		res = query(sql)
+		read_all(res, klass)
 	end
 	
 	# Optimized for one result.
@@ -150,8 +247,8 @@ class Connection
 			sql = "SELECT * FROM #{klass::DBTABLE} WHERE #{sql}"
 		end
 		
-		res = @db.safe_query(sql)
-		@deserialize? @db.deserialize_one(res, klass) : res
+		res = query(sql)
+		read_one(res, klass)
 	end	
 
 	# Perform a count query.
@@ -161,9 +258,8 @@ class Connection
 			sql = "SELECT COUNT(*) FROM #{klass::DBTABLE} WHERE #{sql}"
 		end
 		
-		res =	@db.safe_query(sql)
-		
-		return @db.get_int(res)
+		res =	query(sql)
+		return read_int(res)
 	end
 	
 	# Delete an object from the database. Allways perform a deep delete.
@@ -199,66 +295,6 @@ class Connection
 	end
 	alias_method :delete!, :delete
 		
-	# Create the managed object table. The properties of the
-	# object are mapped to the table columns. Additional sql relations
-	# and constrains are created (indicices, sequences, etc).
-	
-	def create_table(klass)
-		@db.create_table(klass)
-	end
-	
-	# Drop the managed object table.
-	
-	def drop_table(klass)
-		@db.drop_table(klass)
-	end
-
-	# Execute an SQL query and return the result 
-	
-	def query(sql)
-		@db.safe_query(sql)
-	end
-	
-	# Execute an SQL query, no result returned.
-	
-	def exec(sql)
-		@db.safe_exec(sql)
-	end
-
-	# Start a new transaction.
-	
-	def start
-		@db.start
-	end
-	
-	# Commit a transaction.
-	
-	def commit
-		@db.commit
-	end
-	
-	# Rollback transaction.
-	
-	def rollback
-		@db.rollback
-	end
-	
-	# Transaction helper. In the transaction block use
-	# the db pointer to the backend.
-	
-	def transaction(&block)
-		begin
-			@db.start
-			yield(@db) 
-			@db.commit
-		rescue => ex
-			Logger.error "DB Error: ERROR IN TRANSACTION"
-			Logger.error #{ex}
-			Logger.error #{ex.backtrace}
-			@db.rollback
-		end
-	end
-		
 end
 
 end