audrey 0.2 → 0.3

data/lib/audrey/query/q0.rb

@@ -0,0 +1,373 @@
+#===============================================================================
+# Audrey::Query::Q0
+#
+class Audrey::Query::Q0 < Audrey::Query
+	attr_reader :db
+	attr_accessor :fields
+	attr_accessor :fclass
+	attr_accessor :limit
+	attr_accessor :offset
+	
+	#---------------------------------------------------------------------------
+	# initialize
+	#
+	def initialize(p_db)
+		# check that we got a Audrey object
+		if not p_db.is_a?(Audrey)
+			raise 'db-not-audrey: ' + pdb.class.to_s
+		end
+		
+		@db = p_db
+		@engine = @db.engine
+		@fclass = nil
+		@fields = Audrey::Query::Q0::Fields.new()
+	end
+	#
+	# initialize
+	#---------------------------------------------------------------------------
+	
+	
+	#---------------------------------------------------------------------------
+	# each
+	#
+	def each(opts={})
+		# $tm.hrm
+		equery = @engine.q0(self)
+		
+		# loop through equery results
+		equery.each(opts) do |pk|
+			yield @db.object_from_pk(pk)
+		end
+	end
+	#
+	# each
+	#---------------------------------------------------------------------------
+	
+	
+	#---------------------------------------------------------------------------
+	# sample
+	#
+	def sample
+		# $tm.hrm
+		cl = self.clone()
+		cl.limit = 1
+		cl.offset = rand(self.count)
+		return cl.first
+	end
+	#
+	# sample
+	#---------------------------------------------------------------------------
+	
+	
+	#---------------------------------------------------------------------------
+	# samples
+	# KLUDGE: This routine could be more efficient by not creating an object
+	# out of every sample until it's determined that we don't already have the
+	# object.
+	#
+	def samples(count)
+		rv = {}
+		
+		# loop until we get enough objects
+		while rv.length < count
+			obj = sample()
+			
+			if not rv[obj.audrey.pk]
+				rv[obj.audrey.pk] = obj
+			end
+		end
+		
+		# return
+		return rv.values
+	end
+	#
+	# sample
+	#---------------------------------------------------------------------------
+	
+	
+	#---------------------------------------------------------------------------
+	# count
+	#
+	def count
+		return @engine.q0(self).count
+	end
+	#
+	# count
+	#---------------------------------------------------------------------------
+	
+	
+	#---------------------------------------------------------------------------
+	# sum
+	#
+	def sum(fname)
+		total = 0
+		
+		# optimize the query by cloning and add Defined
+		qopt = self.clone
+		qopt.fields.add 'calls', qopt.defined
+		
+		# loop through records
+		qopt.run do |record|
+			field = record.audrey[fname]
+			
+			if field.is_a?(Numeric)
+				total += field
+			end
+		end
+		
+		# return
+		return total
+	end
+	#
+	# sum
+	#---------------------------------------------------------------------------
+	
+	
+	#---------------------------------------------------------------------------
+	# first
+	# returns the first record in the query, or nil if the query didn't find
+	# anything
+	#
+	def first
+		each() do |obj|
+			return obj
+		end
+		
+		return nil
+	end
+	#
+	# first
+	#---------------------------------------------------------------------------
+	
+	
+	#---------------------------------------------------------------------------
+	# defined
+	#
+	def defined
+		return Audrey::Query::Q0::Defined
+	end
+	#
+	# defined
+	#---------------------------------------------------------------------------
+	
+	
+	#---------------------------------------------------------------------------
+	# fclasses
+	#
+	def fclasses
+		# $tm.hrm
+		
+		# early exit: no fclass
+		if not @fclass
+			return nil
+		end
+		
+		# initialize
+		fcs = [*@fclass]
+		
+		# early exit: fclass is an empty array
+		# NOTE: An empty array would mean that not records are returned, so
+		# we'll interpret it to mean all records.
+		if not fcs.any?
+			return nil
+		end
+		
+		# initialize
+		rv = {}
+		
+		# build fclasses
+		fcs.each do |fclass|
+			fclass.fclasses.each do |desc|
+				rv[desc] = nil
+			end
+		end
+		
+		# return
+		return rv.keys
+	end
+	#
+	# fclasses
+	#---------------------------------------------------------------------------
+	
+	
+	#---------------------------------------------------------------------------
+	# clone
+	#
+	def clone
+		# $tm.hrm
+		rv = self.class.new(@db)
+		
+		# fclass
+		if @fclass.is_a?(Array)
+			rv.fclass = @fclass.clone
+		else
+			rv.fclass = @fclass
+		end
+		
+		# fields
+		rv.fields = @fields.clone
+		
+		# return
+		return rv
+	end
+	#
+	# clone
+	#---------------------------------------------------------------------------
+	
+	
+	#---------------------------------------------------------------------------
+	# iterator
+	#
+	def iterator
+		# $tm.hrm
+		return Audrey::Query::Q0::Iterator.new(self, @engine.q0(self).iterator)
+	end
+	#
+	# iterator
+	#---------------------------------------------------------------------------
+end
+#
+# Audrey::Query::Q0
+#===============================================================================
+
+
+#===============================================================================
+# Audrey::Query::Q0::Defined
+# This module doesn't do anything. It's just a way of inidicating in a query
+# that any defined hash value is acceptable.
+#
+module Audrey::Query::Q0::Defined
+end
+#
+# Audrey::Query::Q0::Defined
+#===============================================================================
+
+
+#===============================================================================
+# Audrey::Query::Q0::Fields
+#
+class Audrey::Query::Q0::Fields
+	extend Forwardable
+
+	#---------------------------------------------------------------------------
+	# delegate hash functions to @root
+	#
+	delegate(%w(
+	         [] []= each length keys values delete clear == <= >= ===
+	        has_key? any?
+	        ) => :@hsh);
+	#
+	# delegate hash functions to @root
+	#---------------------------------------------------------------------------
+	
+	
+	#---------------------------------------------------------------------------
+	# initialize
+	#
+	def initialize
+		@hsh = {}
+	end
+	#
+	# initialize
+	#---------------------------------------------------------------------------
+	
+	
+	#---------------------------------------------------------------------------
+	# add
+	#
+	def add(key, val)
+		if not @hsh[key].is_a?(Array)
+			@hsh[key] = [@hsh[key]]
+		end
+		
+		@hsh[key].push val
+	end
+	#
+	# add
+	#---------------------------------------------------------------------------
+	
+	
+	#---------------------------------------------------------------------------
+	# clone
+	#
+	def clone
+		rv = self.class.new()
+		
+		# fields
+		@hsh.each do |k,v|
+			if v.is_a?(Array)
+				rv[k] = v.clone
+			else
+				rv[k] = v
+			end
+		end
+		
+		# return
+		return rv
+	end
+	#
+	# clone
+	#---------------------------------------------------------------------------
+end
+#
+# Audrey::Query::Q0::Fields
+#===============================================================================
+
+
+#===============================================================================
+# Audrey::Query::Q0::Iterator
+#
+class Audrey::Query::Q0::Iterator
+	attr_reader :pk
+	attr_reader :eiterator
+	
+	#---------------------------------------------------------------------------
+	# initialize
+	#
+	def initialize(q0, eiterator)
+		@pk = Audrey::Util.randstr
+		@q0 = q0
+		@db = @q0.db
+		@eiterator = eiterator
+		@q0.db.closers[@pk] = self
+	end
+	#
+	# initialize
+	#---------------------------------------------------------------------------
+	
+	
+	#---------------------------------------------------------------------------
+	# next
+	#
+	def next
+		# $tm.hrm
+		
+		# if we get a next record
+		if row = @eiterator.next
+			return @db.object_from_pk(row['pk'])
+		
+		# else close
+		else
+			close()
+			return nil
+		end
+	end
+	#
+	# next
+	#---------------------------------------------------------------------------
+	
+	
+	#---------------------------------------------------------------------------
+	# close
+	#
+	def close
+		@eiterator.close
+		@q0.db.closers.delete(@pk)
+	end
+	#
+	# close
+	#---------------------------------------------------------------------------
+end
+#
+# Audrey::Query::Q0::Iterator
+#===============================================================================

data/lib/audrey.rb

@@ -15,7 +15,7 @@ class Audrey
 	@@current_db = nil
 	
 	# version
-	VERSION = '0.2'
+	VERSION = '0.3'
 	
 	#---------------------------------------------------------------------------
 	# delegate

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: audrey
 version: !ruby/object:Gem::Version
-  version: '0.2'
+  version: '0.3'
 platform: ruby
 authors:
 - Mike O'Sullivan
@@ -47,6 +47,10 @@ extra_rdoc_files: []
 files:
 - README.md
 - lib/audrey.rb
+- lib/audrey/engine/sqlite3.rb
+- lib/audrey/engine/sqlite3/init.rb
+- lib/audrey/engine/sqlite3/query/q0.rb
+- lib/audrey/query/q0.rb
 homepage: https://rubygems.org/gems/audrey
 licenses:
 - MIT