nitro 0.1.2

data/lib/n/db/make-release.sh

@@ -0,0 +1,26 @@
+rm -rf ndb
+mkdir ndb
+mkdir ndb/n
+mkdir ndb/n/utils
+cp ~/navel/n/utils/string.rb ndb/n/utils/.
+cp ~/navel/n/utils/array.rb ndb/n/utils/.
+cp ~/navel/n/utils/cache.rb ndb/n/utils/.
+cp ~/navel/n/utils/pool.rb ndb/n/utils/.
+cp ~/navel/n/utils/time.rb ndb/n/utils/.
+cp ~/navel/n/utils/hash.rb ndb/n/utils/.
+cp ~/navel/n/utils/number.rb ndb/n/utils/.
+cp -R ~/navel/n/db ndb/n/.
+cp ~/navel/n/properties.rb ndb/n/.
+cp ~/navel/n/db.rb ndb/n/.
+cp ~/navel/n/.tc-db.rb ndb/n/.
+cp ~/navel/n/logger.rb ndb/n/.
+cp ~/navel/n/properties.rb ndb/n/.
+cp ~/navel/n/std.rb ndb/n/.
+cp ~/navel/n/db/README ndb/README
+find . | grep "\.svn$" | xargs rm -rf
+find . | grep "\.\#" | xargs rm -rf
+find . | grep "\.swp$" | xargs rm -rf
+cd ndb
+rdoc -m README  -x '[t|l]c-*' -t 'n/Db Documentation'
+cd ..
+tar cvfz ndb-0.2.tar.gz ndb

data/lib/n/db/managed.rb

@@ -0,0 +1,235 @@
+# = Database Managed Objects
+#
+# Base Mixin for Managed Objects (Entities)
+#
+# === Design
+#
+# code:
+# George Moschovitis  <gm@navel.gr>
+#
+# (c) 2004 Navel, all rights reserved.
+# $Id: managed.rb 71 2004-10-18 10:50:22Z gmosx $
+
+
+# Extend the base Module class
+#
+# Implements the meta-language used to create/fine-tune
+# the generated sql.
+#
+class Module
+
+	# Create an sql index. Wrapper arrount meta :sql_index.
+	# This creates ONE sql index.
+	# The input parameter is a String (for many symbols) or 
+	# a Symvol
+	#
+	def	sql_index(symbols, pre_sql = nil, post_sql = nil)
+		# gmosx, TODO: meta[:sql_index] should store the full sql clause
+		# to allow for custom indices (for example partial indices,
+		# hash indices and more)
+		meta(:sql_index, [symbols.to_s, pre_sql, post_sql])
+	end
+
+	# Wrap prop/meta declarations.
+	# 
+	def manage(&block)
+		inherit_meta(superclass) if superclass
+		
+		yield
+		
+		N::Managed.eval_dbseq(self)
+		N::Managed.eval_dbtable(self)
+# 	gmosx: this is called from DbConnection
+#		N::Managed.eval_db_read_row(self)
+		N::Managed.eval_db_insert(self)
+		N::Managed.eval_db_update(self)
+	end
+	
+end
+
+module N; 
+
+require "n/properties"
+require "n/utils/array"
+require "n/utils/time"
+
+# The database interfaces automatically manages classes that 
+# include this interface.
+#
+module Managed
+	# Use this hash to store sql join query fields.
+	# DONT create this hash unless needed!
+	attr_accessor :join_fields
+	
+	#
+	#
+	def initialize(*args)
+	end
+	
+	# A list of potential ancestor classes
+	# Returns an array of classes.
+	#
+	def __ancestors_classes
+		return nil
+	end
+	
+	# A list of potential descendants classes
+	# Typically used in cascading deletes.
+	# Returns an array of classes.
+	#
+	def __descendants_classes
+		return nil
+	end
+	
+	# --------------------------------------------------------------------
+	# DB Hooks
+	
+	# Define the primary key as a string. 
+	#
+	def __db_pk
+		return nil
+	end	
+	
+	# Add code to be executed before the managed object is inserted.
+	# Typically creates the primary key.
+	#
+	def __db_pre_insert(conn)
+		# nop
+	end
+
+	# Add code to be executed before the managed object is deleted.
+	# Typically used for cascading deletes, executed in a transaction,
+	# do NOT error-check here!
+	#
+	def __db_pre_delete(conn)
+		# nop
+	end
+
+	# This method is called to deserialize a resultset from the
+	# database. This definition is ovveriden by the evaluated code from 
+	# eval_db_read_row.
+	#
+	def __db_insert(conn)
+		# nop
+	end
+	
+	# This method is called to insert a managed object in the database. 
+	# This definition is ovveriden by the evaluated code from 
+	# eval_db_update.
+	#
+	def __db_insert(conn)
+		# nop
+	end
+	
+	# This method is called to update a managed object in the database. 
+	# This definition is ovveriden by the evaluated code from 
+	# eval_db_update.
+	#
+	def __db_update(conn)
+		raise "No primary key defined, cannot update" 
+	end
+	
+	# --------------------------------------------------------------------
+
+	# Evaluate the DBSEQ constant for the given class.
+	# Classes that include the N::Sequenced marker have
+	# a custom sequence.
+	#
+	# INVESTIGATE: how to implement this for MySQL?
+	#
+	def self.eval_dbseq(klass)
+		if klass.include?(N::Sequenced)
+			klass.module_eval %{
+				DBSEQ = "#{N::DbUtils.sql_table(klass)}_oids_seq" 
+			}
+		else
+			klass.module_eval %{
+				DBSEQ = "oids_seq" 
+			}
+		end
+	end
+	
+	# Evaluate the DBTABLE constant for the given class.
+	#
+	def self.eval_dbtable(klass)
+		klass.module_eval %{
+			DBTABLE = "#{N::DbUtils.sql_table(klass)}"
+		}
+	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_db_read_row(klass)
+		props = klass.__props 
+		code = []
+		
+		props.each { |p|
+			if idx = $db.fields[klass][p.name]
+				# more fault tolerant if a new field is added and it 
+				# doesnt exist in the database.
+				code << "@#{p.name} = #{N::DbUtils.read_prop(p, idx)}"
+			end
+		}
+		klass.module_eval %{
+	 		def __db_read_row(rows, tuple)
+				#{code.join('; ')}
+			end
+		}
+	end				
+
+	# Precompile the insert code for the given class.
+	#
+	# gmosx: SET the oid when inserting!
+	#
+	def self.eval_db_insert(klass)
+		props = klass.__props
+		
+		values = props.collect { |p| 
+			N::DbUtils.write_prop(p)
+		} 
+
+		sql = "INSERT INTO #{N::DbUtils.sql_table(klass)} (#{props.collect {|p| p.name}.join(',')}) VALUES (#{values.join(',')})"
+
+		klass.module_eval %{
+			def __db_insert(conn)
+				__db_pre_insert(conn)
+				conn.retry_query("#{sql}", #{klass})
+			end
+		}
+	end
+
+	# Precompile the update code for the given class.
+	#
+	# gmosx: ignore the oid when updating!
+	#
+	def self.eval_db_update(klass)
+		props = klass.__props.reject { |p| :oid == p.symbol }
+		
+		updates = props.collect { |p|
+			"#{p.name}=#{N::DbUtils.write_prop(p)}"
+		}
+
+		# the primary key
+		
+		if pk = klass.new.__db_pk
+			# only evaluate the update code if the object
+			# defines a primary key.
+			
+			sql = "UPDATE #{klass::DBTABLE} SET #{updates.join(', ')} WHERE #{pk}=#\{@#{pk}\}"
+		
+			klass.module_eval %{
+				def __db_update(conn)
+					conn.retry_query("#{sql}", #{klass})
+				end
+			}
+		end
+	end
+	
+end
+	
+end # module
+

data/lib/n/db/mixins.rb

@@ -0,0 +1,282 @@
+# = Database Managed Mixins
+#
+# Useful mixins for managed objects.
+#
+# === Design
+#
+# All mixins should have at least initialize(*args) to be more chainable?
+#
+# code:
+# George Moschovitis  <gm@navel.gr>
+#
+# (c) 2004 Navel, all rights reserved.
+# $Id: mixins.rb 71 2004-10-18 10:50:22Z gmosx $
+
+module N; 
+
+# = Entity
+#
+# The default managed Object. Include this mixin to the
+# objects to be managed by Db.
+#
+module Entity
+	include Managed
+	
+	# The unique object id. PRIMARY KEY automatically creates an index.
+	prop_accessor Fixnum, "integer PRIMARY KEY", :oid
+
+	def initialize(*args)
+		super
+	end
+	
+	#
+	#
+	def __db_pk
+		return "oid"
+	end
+	
+	# Default implementation, calculates the oid primary key.
+	#	
+	def __db_pre_insert(conn)
+		# gmosx, INVESTIGATE: is this neeed?
+		super
+		@oid = conn.next_oid(self.class)		
+	end
+	
+	# Default implementation, cascading delete.
+	# Typically used for cascading deletes, executed in a transaction,
+	# do NOT error-check here!
+	#
+	def __db_pre_delete(conn)
+		conn.delete_descendants(@oid, self.class)
+	end
+	
+	def to_i()
+		return @oid
+	end
+end
+
+# An entity that uses a custom sequence.
+# This is a marker mixin. Entities tha include this mixin
+# do not participated in the unified id space
+#
+module Sequenced; 
+	def initialize(*args)
+		super
+	end
+end
+
+#
+#
+module CreateTime
+	prop_accessor Time, :create_time
+	
+	def initialize(*args)
+		super
+		@create_time = Time.now()
+	end
+	
+end
+
+# = Relation
+#
+# Relations between entities.
+#
+# gmosx: The oid is need in relations too, as a primary key.
+# Another pk could be (pid, pclass, tid, tclass) but this is too
+# big.
+#
+module Relation
+	include Entity
+	include CreateTime 
+	include Sequenced
+
+	# The parent id.
+	prop_accessor Fixnum, "integer NOT NULL", :pid
+
+	# The parent class
+	prop_accessor String, :pclass
+	
+	# The target oid
+	prop_accessor Fixnum, "integer NOT NULL", :tid
+	
+	# The target class
+	prop_accessor String, :tclass
+	
+	# combined index (tid, tclass)	
+	sql_index "tid, tclass"
+
+	def set_parent(parent, klass = nil)
+		if parent.is_a?(Fixnum)
+			@pid = parent
+			@pclass = klass.to_s if klass
+		else
+			@pid = parent.oid
+			@pclass = parent.class.to_s()
+		end
+	end
+
+	def set_target(target, klass = nil)
+		if target.is_a?(Fixnum)
+			@tid = target
+			@tclass = klass.to_s if klass
+		else
+			@tid = target.oid
+			@tclass = target.class.to_s()
+		end
+	end
+	
+end
+
+# = RelationUtils
+#
+# A collection of general Relation utilities. Extend this method in your
+# classes.
+#
+module RelationUtils
+
+	# Return the targets for the given parent.
+	#
+	def targets_for_parent(pid, pclass, tclass, extrasql = nil)
+		return $db.select("SELECT f.*, r.oid AS relid, r.create_time AS relct FROM #{tclass::DBTABLE} AS f, #{self::DBTABLE} AS r WHERE f.oid=r.tid #{extrasql}", tclass, [:relid, :relct])
+	end	
+	
+	# Count targets for the given parent
+	#
+	def count_targets_for_parent(pid, pclass, tclass, extrasql = nil)
+		return $db.count("SELECT COUNT(*) FROM #{tclass::DBTABLE} AS f, #{self::DBTABLE} AS r WHERE f.oid=r.tid #{extrasql}")		
+	end
+
+end
+
+# = Named
+#
+# Include this mixin to make an entity named. The Db interface
+# provides special lookup methods for Named entities.
+#
+module Named
+	# The object name, used in named lookups.
+	prop_accessor String, :name;	sql_index :name
+end
+
+# = Child
+#
+# Include this mixin to make and entity attachable to a parent
+# Entity.
+#
+module Child
+	# The parent oid
+	prop_accessor Fixnum, "integer NOT NULL", :pid
+	
+	# DONT use combined index (pid, pclass), this is seldom used in 
+	# queries, use only the pid as index!
+	sql_index :pid
+
+	def initialize(*args)
+		super
+	end
+	
+	def set_parent(parent)
+		@pid = parent.to_i
+	end	
+end	
+
+# = ParentClass
+#
+# Extends Child, allows multiple class parents.
+#
+module ParentClass
+	
+	# The parent class
+	#
+	# This is usually not used in queries, we add it so the database
+	# is 'complete'
+	# pclass stores the class name and NOT the actual class.
+	# this optimizes most of the code, and allows to pass the pclass
+	# parameter through standard URIs.
+	#
+	# Originally it stored the class hash but then we couldnt lookup
+	# the actual class (hashes are oneway transforms).
+	#
+	prop_accessor String, :pclass
+
+	def set_parent(parent, klass = nil)
+		if parent.is_a?(Fixnum)
+			@pid = parent
+			@pclass = klass.to_s() if klass
+		else
+			@pid = parent.oid
+			@pclass = parent.class.to_s()
+		end
+	end
+		
+end
+
+# = SqlTreeTraversable
+#
+# Implements the common Preorder Tree Traversal SQL pattern.
+# Usefull if you need to combine a Hierarchical view with 
+# an SQL LIMIT clause.
+#
+# The technique is further discussed here:
+# http://www.ibase.ru/devinfo/DBMSTrees/sqltrees.html
+#
+# depth is used in the limit scenarios.
+# This pattern works well with stored procedures.
+#
+# initialy depth = 0, lft = 0, rgt = 1
+#
+# Optimization: instead of lft,rgt it only stores tree_index, so it cannot
+# generate subtrees.
+#
+module SqlTreeTraversable
+	# SQL reserves left, right
+	prop_accessor Fixnum, "smallint", :lft, :rgt 
+	prop_accessor Fixnum, "smallint", :depth 
+
+	# If depth, lft, rgt are not initialized try to autocalculate
+	# from the parent.
+	#
+	def __db_pre_insert(conn)
+		super
+		unless @depth
+				@depth = 0
+				@lft = 0
+				@rgt = 1
+		end
+	end
+	
+	def insert_into_sql_tree(prgt, pdepth)
+		@depth = pdepth.to_i() + 1
+		@lft = prgt.to_i()
+		@rgt = @lft + 1
+	end
+	
+end
+
+# = ManagedChild
+#
+# A common type of non-entity
+#
+module ManagedChild
+	include N::Managed
+
+	# The parent oid
+	prop_accessor Fixnum, "integer PRIMARY KEY", :pid
+	
+	def initialize(parent = nil)
+		@pid = parent.to_i
+	end
+
+	def set_parent(parent)
+		@pid = parent.to_i
+	end	
+	
+	# pid is the primary key
+	def __db_pk
+		return "pid"
+	end	
+end
+
+end # module
+