audrey 0.2 → 0.3

data/lib/audrey/engine/sqlite3/query/q0.rb

@@ -0,0 +1,342 @@
+#===============================================================================
+# Audrey::Engine::SQLite3::Query::Q0
+#
+class Audrey::Engine::SQLite3::Query::Q0
+	#---------------------------------------------------------------------------
+	# initialize
+	#
+	def initialize(p_engine, p_fquery)
+		@engine = p_engine
+		@dbh = @engine.dbh
+		@fquery = p_fquery
+		set_query_pk()
+	end
+	#
+	# initialize
+	#---------------------------------------------------------------------------
+	
+	
+	#---------------------------------------------------------------------------
+	# set_query_pk
+	#
+	def set_query_pk
+		@qpk = Audrey::Util.randstr(40)
+		sql = 'insert into queries(pk) values(:qpk)'
+		@dbh.execute sql, 'qpk'=>@qpk
+	end
+	#
+	# set_query_pk
+	#---------------------------------------------------------------------------
+	
+	
+	#---------------------------------------------------------------------------
+	# sub_query_pk
+	#
+	def sub_query_pk()
+		# $tm.hrm
+		rv = Audrey::Util.randstr(40)
+		sql = 'insert into subqueries(pk, query) values(:sqpk, :qpk)'
+		@dbh.execute sql, 'sqpk'=>rv, 'qpk'=>@qpk
+		return rv
+	end
+	#
+	# sub_query_pk
+	#---------------------------------------------------------------------------
+	
+	
+	#---------------------------------------------------------------------------
+	# iterator
+	#
+	def iterator(opts={})
+		# $tm.hrm
+		subqueries = prepare_subqueries()
+		exec_opts = {}
+		
+		# sql
+		sql = <<~'SQL'
+		select o.pk
+			from objects o, query_rows qr
+		where
+			o.pk = qr.parent and
+			qr.subquery = :sqpk
+		SQL
+		
+		# options
+		exec_opts['sqpk'] = subqueries['objects']
+		
+		# limit
+		if @fquery.limit
+			exec_opts['limit'] = @fquery.limit
+			sql += "limit :limit\n"
+		end
+		
+		# offset
+		if @fquery.offset
+			exec_opts['offset'] = @fquery.offset
+			sql += "offset :offset\n"
+		end
+		
+		# stmt and resultset
+		stmt = @dbh.prepare(sql)
+		return stmt.execute(exec_opts)
+	end
+	#
+	# iterator
+	#---------------------------------------------------------------------------
+	
+	
+	#---------------------------------------------------------------------------
+	# each
+	#
+	def each(opts={})
+		itr = iterator(opts)
+		
+		itr.each do |row|
+			yield row['pk']
+		end
+	ensure
+		itr and itr.close
+	end
+	#
+	# each
+	#---------------------------------------------------------------------------
+	
+	
+	#---------------------------------------------------------------------------
+	# select_objects
+	#
+	def select_objects(subqueries)
+		# $tm.hrm
+		
+		# query params
+		params = {}
+		subqueries['objects'] = params['sqpk'] = sub_query_pk()
+		
+		# initial sql
+		sql = <<~'SQL'
+		select
+			:sqpk as sqpk, pk
+		from
+			objects
+		where
+			(partition = :partition)
+		SQL
+		
+		# partition pk
+		params['partition'] = @engine.partition
+		
+		# fclasses
+		if (fclasses = @fquery.fclasses) and fclasses.any?
+			wheres = []
+			
+			fclasses.each do |fclass|
+				rs = Audrey::Util.randstr(40)
+				wheres.push ":#{rs}"
+				params[rs] = fclass
+			end
+			
+			# add wheres
+			sql += "	and\n" + '	(fclass in (' + wheres.join(', ') + '))'
+		end
+		
+		# limit to hashes
+		if subqueries['hash']
+			sql = <<~"SQL"
+			#{sql} and
+				(pk in (select parent from query_rows where subquery=:hashsqpk))
+			SQL
+			
+			params['hashsqpk'] = subqueries['hash']
+		end
+		
+		# prepend insert into
+		sql = <<~"SQL"
+		insert into
+			query_rows(subquery, parent)
+		#{sql}
+		SQL
+		
+		# execute
+		@dbh.execute sql, params
+	end
+	#
+	# select_objects
+	#---------------------------------------------------------------------------
+	
+	
+	#---------------------------------------------------------------------------
+	# select_hash_elements
+	#
+	def select_hash_elements(subqueries)
+		# $tm.hrm
+		
+		# early exit
+		@fquery.fields.any? or return
+		
+		# build sql and params
+		sql = "select distinct :sqpk as sqpk, hv.parent\nfrom hash_pairs hv\nwhere"
+		wheres = []
+		params = {}
+		
+		# sub_query_pk
+		subqueries['hash'] = params['sqpk'] = sub_query_pk()
+		
+		# hash values
+		hash_pairs wheres, params
+		
+		# add wheres
+		sql += "\n(" + wheres.join(") and\n(") + ')'
+		
+		# wrap in insert
+		sql = <<~"SQL"
+		insert into query_rows
+		#{sql}
+		SQL
+		
+		# execute
+		@engine.dbh.execute sql, params
+	end
+	#
+	# select_hash_elements
+	#---------------------------------------------------------------------------
+	
+	
+	#---------------------------------------------------------------------------
+	# count
+	#
+	def count
+		# $tm.hrm
+		subqueries = prepare_subqueries()
+		
+		# sql
+		sql = <<~'SQL'
+		select count(*) as count
+		from objects o, query_rows qr
+		where
+			o.pk = qr.parent and
+			qr.subquery = :sqpk
+		SQL
+		
+		# return count
+		return @dbh.get_first_value(sql, 'sqpk'=>subqueries['objects'])
+	end
+	#
+	# count
+	#---------------------------------------------------------------------------
+	
+	
+	#---------------------------------------------------------------------------
+	# fclasses
+	#
+	def fclasses(wheres, params)
+		fcs = @fquery.fclasses
+		fcs.any? or return
+		where = []
+		
+		# loop through fclasses
+		fcs.each do |fc|
+			rs = Audrey::Util.randstr(40)
+			params[rs] = fc
+			where.push ':' + rs
+		end
+		
+		# add to wheres
+		wheres.push 'fclass in (' + where.join(', ') + ')'
+	end
+	#
+	# fclasses
+	#---------------------------------------------------------------------------
+	
+	
+	#---------------------------------------------------------------------------
+	# hash_pairs
+	#
+	def hash_pairs(wheres, params)
+		# $tm.hrm
+		
+		# loop through fields
+		@fquery.fields.each do |k, vals|
+			# key
+			krs = Audrey::Util.randstr(40)
+			params[krs] = k
+			
+			# if we're looking for a null value
+			is_null = false
+			
+			# initialize clause
+			clause = '(hkey=:' + krs + ')'
+			
+			# if specific values are wanted
+			unless [*vals].include?(Audrey::Query::Q0::Defined)
+				send_vals = []
+				
+				# force to array
+				# Note: just using [*vals] doesn't work because if vals is nil
+				# then [*vals] is an empty array
+				if not vals.is_a?(Array)
+					vals = [vals]
+				end
+				
+				vals.each do |val|
+					if val.nil?
+						is_null = true
+					else
+						vrs = Audrey::Util.randstr(40)
+						params[vrs] = val
+						send_vals.push ':' + vrs
+					end
+				end
+				
+				# ors
+				ors = []
+				
+				# send_vals
+				if send_vals.any?
+					ors.push 'scalar in (' + send_vals.join(', ') + ')'
+				end
+				
+				# if null
+				if is_null
+					ors.push 'scalar is null'
+				end
+				
+				# add scalar conditions to clause
+				clause += ' and (' + ors.join(') or (') + ')'
+			end
+			
+			# if looking for a null value, add condition in which the parent
+			# element is selected if no such key/value pair exists
+			if is_null
+				null_clause = "((select count(*) from hash_pairs hp where parent=hv.parent and hkey=:#{krs} ) = 0)"
+				clause = "(#{clause}) or #{null_clause}"
+			end
+			
+			# add where clause
+			wheres.push clause
+		end
+	end
+	#
+	# hash_pairs
+	#---------------------------------------------------------------------------
+	
+	
+	# private
+	private
+
+	
+	#---------------------------------------------------------------------------
+	# prepare_subqueries
+	#
+	def prepare_subqueries
+		subqueries = {}
+		select_hash_elements subqueries
+		select_objects subqueries
+		return subqueries
+	end
+	#
+	# prepare_subqueries
+	#---------------------------------------------------------------------------
+end
+#
+# Audrey::Engine::SQLite3::Query::Q0
+#===============================================================================