nitro 0.12.0 → 0.13.0

data/lib/og/adapters/sqlite.rb

@@ -1,262 +0,0 @@
-# * George Moschovitis  <gm@navel.gr>
-# (c) 2004-2005 Navel, all rights reserved.
-# $Id: sqlite.rb 270 2005-03-07 17:52:16Z gmosx $
-
-require 'sqlite3'
-require 'fileutils'
-
-require 'og/adapter'
-require 'og/connection'
-require 'glue/attribute'
-
-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, 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 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
-			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,297 +0,0 @@
-# * George Moschovitis  <gm@navel.gr>
-# (c) 2004-2005 Navel, all rights reserved.
-# $Id: backend.rb 263 2005-02-23 13:45:08Z gmosx $
-
-require 'yaml'
-
-require 'og/connection'
-
-module Og
-
-# Abstract backend. A backend communicates with the RDBMS.
-# This is the base class for the various backend implementations.
-
-class Backend
-	
-	# The actual connection to the database
-	attr_accessor :conn
-
-	# Intitialize the connection to the RDBMS.
-	 	
-	def initialize(config)
-		raise "Not implemented"
-	end
-
-	# Close the connection to the RDBMS.
-	 	
-	def close()
-		@conn.close()
-	end	
-
-	# - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 
-	# :section: Utilities
-	# - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
-
-	# Encode the name of the klass as an sql safe string.
-	# The Module separators are replaced with _ and NOT stripped 
-	# out so that we can convert back to the original notation if 
-	# needed. The leading module if available is removed.
-	
-	def self.encode(klass)
-		"#{klass.name.gsub(/^.*::/, "")}".gsub(/::/, "_").downcase
-	end
-
-	# The name of the SQL table where objects of this class 
-	# are stored.
-	
-	def self.table(klass)
-		"_#{Og.table_prefix}#{encode(klass)}"
-	end
-
-	# The name of the join table for the two given classes.
-	
-	def self.join_table(klass1, klass2)
-		"_#{Og.table_prefix}j_#{encode(klass1)}_#{encode(klass2)}"
-	end
-	
-	# Returns the props that will be included in the insert query.
-	# For some backends the oid should be stripped.
-	
-	def self.props_for_insert(klass)
-		klass.__props
-	end
-	
-	# Precompile the insert code for the given class.
-	# The generated code sets the oid when inserting!
-	
-	def self.eval_og_insert(klass)
-		props = props_for_insert(klass)
-		
-		values = props.collect { |p| write_prop(p) } 
-		
-		sql = "INSERT INTO #{table(klass)} (#{props.collect {|p| p.name}.join(',')}) VALUES (#{values.join(',')})"
-
-		if klass.instance_methods.include?("og_pre_insert")
-			pre_cb = "og_pre_insert(conn);"
-		else
-			pre_cb = ""
-		end
-
-		if klass.instance_methods.include?("og_post_insert")
-			post_cb = "og_post_insert(conn);"
-		else
-			post_cb = ""
-		end
-
-		if klass.instance_methods.include?("og_pre_insert_update")
-			pre_cb << "og_pre_insert_update(conn);"
-		end
-
-		if klass.instance_methods.include?("og_post_insert_update")
-			post_cb << "og_post_insert_update(conn);"
-		end
-		
-		klass.class_eval %{
-			def og_insert(conn)
-				#{insert_code(klass, sql, pre_cb, post_cb)}
-			end
-		}
-	end
-
-	# Precompile the update code for the given class.
-	# Ignore the oid when updating!
-	
-	def self.eval_og_update(klass)
-		props = klass.__props.reject { |p| :oid == p.symbol }
-		
-		updates = props.collect { |p|
-			"#{p.name}=#{write_prop(p)}"
-		}
-
-		sql = "UPDATE #{klass::DBTABLE} SET #{updates.join(', ')} WHERE oid=#\{@oid\}"
-
-		if klass.instance_methods.include?("og_pre_update")
-			pre_cb = "og_pre_update(conn);"
-		else
-			pre_cb = ""
-		end
-
-		if klass.instance_methods.include?("og_post_update")
-			post_cb = "og_post_update(conn);"
-		else
-			post_cb = ""
-		end
-
-		if klass.instance_methods.include?("og_pre_insert_update")
-			pre_cb << "og_pre_insert_update(conn);"
-		end
-
-		if klass.instance_methods.include?("og_post_insert_update")
-			post_cb << "og_post_insert_update(conn);"
-		end
-		
-		klass.class_eval %{
-			def og_update(conn)
-				#{pre_cb}
-				conn.exec "#{sql}"
-				#{post_cb}
-			end
-		}
-	end
-
-	# Precompile the code to read objects of the given class 
-	# from the backend. In order to allow for changing 
-	# field/attribute orders we have to use a field mapping hash.
-	
-	def self.eval_og_deserialize(klass, og)
-		calc_field_index(klass, og)
-		
-		props = klass.__props 
-		code = []
-		
-		props.each do |p|
-			if idx = og.managed_classes[klass].field_index[p.name]
-				# more fault tolerant if a new field is added and it 
-				# doesnt exist in the database.
-				code << "@#{p.name} = #{read_prop(p, idx)}"
-			end
-		end
-		
-		klass.class_eval %{
-	 		def og_deserialize(res, tuple = nil)
-				#{code.join('; ')}
-			end
-		}
-	end				
-	
-	# - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
-	# :section: Connection methods. 
-	# - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
-
-	# Create the database.
-	
-	def self.create_db(database, user = nil, password = nil)
-		Logger.info "Creating database '#{database}'."
-	end
-	
-	# Drop the database.
-	
-	def self.drop_db(database, user = nil, password = nil)
-		Logger.info "Dropping database '#{database}'."
-	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
-
-	# Execute an SQL query and return the result. Wrapped in a 
-	# rescue block. 
-	
-	def safe_query(sql)
-		raise "Not implemented"
-	end
-	
-	# Execute an SQL query, no result returned. Wrapped in a 
-	# rescue block.
-	
-	def safe_exec(sql)
-		raise "Not implemented"
-	end
-	
-	# Check if it is a valid resultset.
-	
-	def valid?(res)
-		raise "Not implemented"
-	end
-
-	# Start a new transaction.
-	
-	def start
-		exec "START TRANSACTION"
-	end
-	
-	# Commit a transaction.
-	
-	def commit
-		exec "COMMIT"
-	end
-	
-	# Rollback transaction.
-	
-	def rollback
-		exec "ROLLBACK"
-	end	
-
-	# Create the fields that correpsond to the klass properties.
-	# The generated fields 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 create_fields(klass, typemap)
-		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]}"
-				# attach extra sql
-				if p.meta and extra_sql = p.meta[:extra_sql]
-					field << " #{extra_sql}"
-				end
-			end
-			
-			fields << field 
-		end
-
-		return fields
-	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)
-		return if query("SELECT * FROM #{klass::DBTABLE} LIMIT 1")
-	end
-	
-	# Drop the managed object table
-	
-	def drop_table(klass)
-		exec "DROP TABLE #{klass::DBTABLE}"
-	end
-
-	# Deserialize one row of the resultset.
-	
-	def deserialize_one(res, klass)	
-		raise 'Not implemented'
-	end
-	
-	# Deserialize all rows of the resultset.
-	
-	def deserialize_all(res, klass)	
-		raise 'Not implemented'
-	end
-	
-	# Return a single integer value from the resultset.
-	
-	def get_int(res, idx = 0)
-		raise 'Not implemented'
-	end
-
-end
-
-end