audrey 0.3.1 → 0.3.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 951578466a2d64ec38969c2c6e32efa7eb350e1ecbc6653e4fad7d69173f3478
-  data.tar.gz: 86f5ca9e19f2d7ff50a73e2a175d8ce06ecc658b95b82b6a0043f6805cf37142
+  metadata.gz: 6b23e9b52a9288068ee7759f7801d2b7bf823039e175d605021a7e7f1ea3bf9a
+  data.tar.gz: c852e65ef1cc590c17604c7dafe448d884cc9d326e557dcfa9f8e748137cf050
 SHA512:
-  metadata.gz: 21db86bdd68b2a032544e282c558b5f62a25e5f31c68a86c7e22d3f08a3613bc291166eb0ec22426f23eb9b626424e5c831ae7e564443444af16bfcd46124afe
-  data.tar.gz: 6cc1daad93023639546096f1ea4664ab5f77d0bc1f99547396fa6f36e6ee96a1f261c1f12bb1b55ad8f8266234d083ad8465d1d91b6979cdaa7d4fd890f6007d
+  metadata.gz: b004dd3df3ac223f34ba0f08b957e8b9b2e3054d6151b3831cc5b44c9d8e6ef6770421afae09036692fed8678dcfeaf40d54a2703e5536c917d15aec314a632e
+  data.tar.gz: b1f2fcb49a1bbdebc4c8990d20956c92a621c7f72825d07ed30c22d4fd4b74dbd3db6b0615efa97ae17f3ae5d9606a1a15e83b2023413587488376bf1fbe09cb

data/README.md

@@ -16,7 +16,7 @@ gem install audrey
 
 By default, Audrey uses SQLite for storage, so the only dependencies are SQLite,
 which is standard on most Unixish systems, and this gem. To create and start
-using a Audrey database, all you have to do is open it with `Audrey.connect`,
+using an Audrey database, all you have to do is open it with `Audrey.connect`,
 giving a path to a database file and a read/write mode - `'rw'`, `'r'`, or
 `'w'`. The file doesn't need to already exist; it will be created automatically
 as needed.
@@ -471,7 +471,7 @@ on objects, searching for by class and by field value.
 
 ### Q0 will not be the only query language
 
-Before we go further, though, it's important to understand what Q0 is *not*: it
+Before we go further, it's important to understand what Q0 is *not*: it
 is not the only query language that Audrey will ever have. One of the problems
 that database systems often have is that their query languages becomes more and
 more convoluted as needs evolve. SQL is a good example. What started as a simple
@@ -493,7 +493,7 @@ Then we `each` through the results:
 ```text
 Audrey.connect(path, 'rw') do |db|
     query = db.q0
-    query.fclass = Person
+    query.aclass = Person
     
     query.each do |person|
         puts person.surname
@@ -504,7 +504,7 @@ end
 Note that to search by class we use `fclass` (for *Audrey class*), not just
 `class`. There are several reasons for this. First, the `class` property is
 already taken. Second, as Audrey grows and is implemented by languages besides
-Ruby, it will be necessary to distinguish because a Ruby class and a Audrey
+Ruby, it will be necessary to distinguish because a Ruby class and an Audrey
 class. Audrey classes have the same names as Ruby classes, but other languages,
 such as Python, use a different naming scheme for classes.
 
@@ -527,7 +527,7 @@ query to look for records in which the object's `first` field is "Mary".
 ```text
 Audrey.connect(path, 'rw') do |db|
     query = db.q0
-    query.fclass = Person
+    query.aclass = Person
     query.fields['first'] = 'Mary'
     
     query.each do |person|
@@ -588,9 +588,12 @@ in execution, but it allows you go from no project to working project faster
 than most database systems. Consider the tradeoff.
 
 
-## The name and logo
+## The name
 
-Audrey is named after the character Audrey in Shakespeare's `As You Like It`.
+Audrey is named after the character
+[Audrey](https://commons.wikimedia.org/wiki/File:Audrey_-_Philip_Richard_Morris.jpg)
+in Shakespeare's
+[As You Like It](https://en.wikipedia.org/wiki/As_You_Like_It).
 
 
 ## Author
@@ -600,7 +603,8 @@ mike@idocs.com
 
 ## History
 
-| version | date         | notes                        |
-|---------|--------------|------------------------------|
-| 0.3     | Feb 12, 2020 | Initial upload.              |
-| 0.3.1   | Feb 12, 2020 | Minor fixes to documentation |
+| version | date         | notes                                             |
+|---------|--------------|---------------------------------------------------|
+| 0.3     | Feb 12, 2020 | Initial upload.                                   |
+| 0.3.1   | Feb 12, 2020 | Minor fixes to documentation.                     |
+| 0.3.2   | Feb 14, 2020 | Minor fixes to documentation. Minor code cleanup. |

data/lib/audrey.rb

@@ -15,7 +15,7 @@ class Audrey
 	@@current_db = nil
 	
 	# version
-	VERSION = '0.3.1'
+	VERSION = '0.3.2'
 	
 	#---------------------------------------------------------------------------
 	# delegate
@@ -336,27 +336,27 @@ class Audrey
 		# $tm.hrm
 		
 		# scalar
-		if dfn = Audrey::AUDREY_SCALAR_TO_RUBY[row['fclass']]
+		if dfn = Audrey::AUDREY_SCALAR_TO_RUBY[row['aclass']]
 			return dfn.call(row['scalar'])
 		end
 		
 		# collection
-		if dfn = Audrey::AUDREY_COLLECTION_TO_RUBY[row['fclass']]
+		if dfn = Audrey::AUDREY_COLLECTION_TO_RUBY[row['aclass']]
 			return dfn['nclass'].create_object(self, 'row'=>row)
 		end
 		
 		# custom class
-		if Module.const_defined?(row['fclass'])
-			clss = Module.const_get(row['fclass'])
-			nclass = Audrey::AUDREY_COLLECTION_TO_RUBY[clss.bclass.to_s]['nclass']
+		if Module.const_defined?(row['aclass'])
+			clss = Module.const_get(row['aclass'])
+			nclass = Audrey::AUDREY_COLLECTION_TO_RUBY[clss.hsa]['nclass']
 			node = nclass.new(self, 'row'=>row)
 			rv = clss.new('db'=>self, 'node'=>node)
 			return rv
 		end
 		
-		# if we get this far then we don't know how to turn the row into a
+		# if we get this far then we don't know how to turn the row into an
 		# Audrey object
-		raise 'unknown-fclass: ' + row['fclass'].to_s
+		raise 'unknown-aclass: ' + row['aclass'].to_s
 	end
 	#
 	# object_from_row
@@ -408,9 +408,9 @@ class Audrey
 	#---------------------------------------------------------------------------
 	# import_csv
 	#
-	def import_csv(fclass, path, opts={})
+	def import_csv(aclass, path, opts={})
 		# $tm.hrm
-		return @engine.import_csv(fclass, path, opts)
+		return @engine.import_csv(aclass, path, opts)
 	end
 	#
 	# import_csv
@@ -420,9 +420,9 @@ class Audrey
 	#---------------------------------------------------------------------------
 	# checks_outside_transaction
 	#
-	def checks_outside_transaction(fclass)
-		if fclass.respond_to?('has_checks?')
-			if (not in_transaction?) and fclass.has_checks?
+	def checks_outside_transaction(aclass)
+		if aclass.respond_to?('has_checks?')
+			if (not in_transaction?) and aclass.has_checks?
 				raise 'cannot-create-or-modify-object-that-has-checks-when-not-in-a-transaction'
 			end
 		end
@@ -444,9 +444,6 @@ class Audrey
 				# yield
 				yield tr
 				
-				# run checks
-				# xeme = run_checks()
-				
 				# autocommit
 				if opts['autocommit']
 					tr.commit
@@ -496,10 +493,10 @@ class Audrey
 						end
 					
 					# wrong class
-					elsif dfn.fclass and (not val.is_a?(dfn.fclass))
-						xeme.error('wrong-fclass') do |msg|
+					elsif dfn.aclass and (not val.is_a?(dfn.aclass))
+						xeme.error('wrong-aclass') do |msg|
 							msg['field'] = fieldname
-							msg['fclass'] = dfn.fclass.to_s
+							msg['aclass'] = dfn.aclass.to_s
 						end
 					
 					# run checks
@@ -697,7 +694,7 @@ class Audrey::Node
 		@engine = @db.engine
 		
 		# hold on to flcass if one was sent
-		@fclass = opts['fclass']
+		@aclass = opts['aclass']
 		
 		# if a row was sent, cache it and set pk
 		if opts['row']
@@ -736,12 +733,12 @@ class Audrey::Node
 	#
 	def fco
 		# $tm.hrm
-		return Audrey::Util.fclass_fco(row['fclass'])
+		return Audrey::Util.aclass_fco(row['aclass'])
 	end
 	
 	def isolate
 		# $tm.hrm
-		return Audrey::Util.fclass_isolate(row['fclass'])
+		return Audrey::Util.aclass_isolate(row['aclass'])
 	end
 	#
 	# fco, isolate
@@ -943,7 +940,7 @@ class Audrey::Node::Hash < Audrey::Node::Collection
 		write_check()
 		
 		# test for checks outside of a transaction
-		@db.checks_outside_transaction @fclass
+		@db.checks_outside_transaction @aclass
 		
 		@engine.hash_element_delete @pk, key
 		save_child child, 'key'=>key.to_s
@@ -1425,56 +1422,56 @@ module Audrey::Util
 	
 	
 	#---------------------------------------------------------------------------
-	# rclass_from_fclass
+	# rclass_from_aclass
 	#
-	RCLASS_FROM_FCLASS_CACHE = {}
+	RCLASS_FROM_ACLASS_CACHE = {}
 	
-	def self.rclass_from_fclass(fclass)
-		if early = RCLASS_FROM_FCLASS_CACHE[fclass]
+	def self.rclass_from_aclass(aclass)
+		if early = RCLASS_FROM_ACLASS_CACHE[aclass]
 			return early
 		end
 		
-		if Module.const_defined?(fclass)
-			rclass = Module.const_get(fclass)
+		if Module.const_defined?(aclass)
+			rclass = Module.const_get(aclass)
 			
 			if rclass < Audrey::Object
-				RCLASS_FROM_FCLASS_CACHE[fclass] = rclass
+				RCLASS_FROM_ACLASS_CACHE[aclass] = rclass
 				return rclass
 			else
-				raise 'not-custom-class: ' + fclass.to_s
+				raise 'not-custom-class: ' + aclass.to_s
 			end
 		else
-			raise 'unknown-fclass: ' + fclass.to_s
+			raise 'unknown-aclass: ' + aclass.to_s
 		end
 	end
 	#
-	# rclass_from_fclass
+	# rclass_from_aclass
 	#---------------------------------------------------------------------------
 	
 	
 	#---------------------------------------------------------------------------
-	# fclass_fco, fclass_isolate
+	# aclass_fco, aclass_isolate
 	#
-	def self.fclass_fco(fclass)
-		return self.rclass_from_fclass(fclass).fco
+	def self.aclass_fco(aclass)
+		return self.rclass_from_aclass(aclass).fco
 	end
 	
-	def self.fclass_isolate(fclass)
-		return self.rclass_from_fclass(fclass).isolate
+	def self.aclass_isolate(aclass)
+		return self.rclass_from_aclass(aclass).isolate
 	end
 	#
-	# fclass_fco, fclass_isolate
+	# aclass_fco, aclass_isolate
 	#---------------------------------------------------------------------------
 	
 	
 	#---------------------------------------------------------------------------
 	# graph_field?
 	#
-	def self.graph_field?(fclass, hkey)
+	def self.graph_field?(aclass, hkey)
 		# $tm.hrm
 		
-		if fclass and Module.const_defined?(fclass)
-			clss = Module.const_get(fclass)
+		if aclass and Module.const_defined?(aclass)
+			clss = Module.const_get(aclass)
 			
 			if clss.respond_to?('fields')
 				if dfn = clss.fields[hkey]
@@ -1496,17 +1493,17 @@ module Audrey::Util
 	#
 	@@CUSTOM_CLASSES = {}
 	
-	def self.custom_class?(fclass)
+	def self.custom_class?(aclass)
 		# $tm.hrm
 		
 		# cache
-		if not @@CUSTOM_CLASSES.has_key?(fclass)
-			# puts fclass
-			@@CUSTOM_CLASSES[fclass] = rclass_from_fclass(fclass) < Audrey::Object::Custom
+		if not @@CUSTOM_CLASSES.has_key?(aclass)
+			# puts aclass
+			@@CUSTOM_CLASSES[aclass] = rclass_from_aclass(aclass) < Audrey::Object::Custom
 		end
 		
 		# return
-		return @@CUSTOM_CLASSES[fclass]
+		return @@CUSTOM_CLASSES[aclass]
 	end
 	#
 	# custom_class?
@@ -1522,7 +1519,7 @@ end
 #
 class Audrey::Object
 	#---------------------------------------------------------------------------
-	# inherited, descendants, fclasses
+	# inherited, descendants, aclasses
 	#
 	def self.inherited(desc)
 		if not instance_variable_defined?(:@children)
@@ -1545,7 +1542,7 @@ class Audrey::Object
 		return rv
 	end
 	
-	def self.fclasses
+	def self.aclasses
 		rv = [self.to_s]
 		
 		descendants.each do |desc|
@@ -1555,7 +1552,7 @@ class Audrey::Object
 		return rv
 	end
 	#
-	# inherited, descendants, fclasses
+	# inherited, descendants, aclasses
 	#---------------------------------------------------------------------------
 	
 	
@@ -1616,8 +1613,8 @@ end
 # scalar types
 #
 class Audrey::Object::Scalar < Audrey::Object
-	def self.bclass
-		return self
+	def self.hsa
+		return 's'
 	end
 end
 
@@ -1654,8 +1651,8 @@ end
 # Audrey::Object::Array
 #
 class Audrey::Object::Array < Audrey::Object::Collection
-	def self.bclass
-		return self
+	def self.hsa
+		return 'a'
 	end
 	
 	def self.node_class
@@ -1671,8 +1668,8 @@ end
 # Audrey::Object::Hash
 #
 class Audrey::Object::Hash < Audrey::Object::Collection
-	def self.bclass
-		return Audrey::Object::Hash
+	def self.hsa
+		return 'h'
 	end
 	
 	def self.node_class
@@ -1688,10 +1685,6 @@ end
 # Audrey::Object::Root
 #
 class Audrey::Object::Root < Audrey::Object::Hash
-	def self.bclass
-		return Audrey::Object::Hash
-	end
-	
 	def self.node_class
 		return Audrey::Node::Hash
 	end
@@ -1772,7 +1765,7 @@ module Audrey::Object::Searchable
 	def prepare_query(opts)
 		db = Audrey.explicit_or_current_db(opts['accessor'])
 		query = db.q0
-		query.fclass = self
+		query.aclass = self
 		return query
 	end
 	#
@@ -1946,7 +1939,7 @@ class Audrey::Object::Custom < Audrey::Object::Hash
 	#
 	def within_initialize(db, opts)
 		uuid = db.insert_object(self)
-		@node = Audrey::Node::Hash.new(db, 'fclass'=>self.class, 'pk'=>uuid)
+		@node = Audrey::Node::Hash.new(db, 'aclass'=>self.class, 'pk'=>uuid)
 		self.class.new_auto_fields self
 	end
 	#
@@ -1993,7 +1986,7 @@ class Audrey::Object::Custom < Audrey::Object::Hash
 		if idf = self.id_field
 			db = Audrey.explicit_or_current_db(nil)
 			q0 = db.q0
-			q0.fclass = self
+			q0.aclass = self
 			q0.fields[idf] = key
 			return q0.first
 		
@@ -2014,13 +2007,13 @@ class Audrey::Object::Custom < Audrey::Object::Hash
 		use_dfn = Audrey::Object::Custom::Field
 		
 		# get custom field definition class
-		if fclass = opts['fclass']
-			if Audrey::RUBY_OBJECT_TO_AUDREY[fclass]
-				fclass = Audrey::RUBY_OBJECT_TO_AUDREY[fclass]['fclass']
+		if aclass = opts['aclass']
+			if Audrey::RUBY_OBJECT_TO_AUDREY[aclass]
+				aclass = Audrey::RUBY_OBJECT_TO_AUDREY[aclass]['aclass']
 			end
 			
-			if fclass.respond_to?('field_definition')
-				use_dfn = fclass.field_definition
+			if aclass.respond_to?('field_definition')
+				use_dfn = aclass.field_definition
 			end
 		end
 		
@@ -2337,14 +2330,14 @@ class Audrey::Object::Scalar::String::Field < Audrey::Object::Custom::Field
 	attr_accessor :min_length
 	attr_accessor :max_length
 	attr_accessor :hascontent
-	attr_reader :fclass
+	attr_reader :aclass
 	
 	#---------------------------------------------------------------------------
 	# initialize
 	#
 	def initialize(*opts)
 		super(*opts)
-		@fclass = String
+		@aclass = String
 		
 		# normalize
 		@collapse = false
@@ -2449,7 +2442,7 @@ end
 
 
 #===============================================================================
-# build fclasses for collections
+# build aclasses for collections
 # This code needs to go at the bottom of this file because the classes being
 # referenced aren't defined until after the COLLECTIONS hash is used.
 #
@@ -2458,15 +2451,15 @@ class Audrey
 	# RUBY_OBJECT_TO_AUDREY
 	#
 	RUBY_OBJECT_TO_AUDREY = {}
-	RUBY_OBJECT_TO_AUDREY[String]      =  { 'fclass'=>Audrey::Object::Scalar::String}
-	RUBY_OBJECT_TO_AUDREY[Integer]     =  { 'fclass'=>Audrey::Object::Scalar::Number}
+	RUBY_OBJECT_TO_AUDREY[String]      =  { 'aclass'=>Audrey::Object::Scalar::String}
+	RUBY_OBJECT_TO_AUDREY[Integer]     =  { 'aclass'=>Audrey::Object::Scalar::Number}
 	RUBY_OBJECT_TO_AUDREY[Float]       =  RUBY_OBJECT_TO_AUDREY[Integer]
-	RUBY_OBJECT_TO_AUDREY[TrueClass]   =  { 'fclass'=>Audrey::Object::Scalar::Number}
+	RUBY_OBJECT_TO_AUDREY[TrueClass]   =  { 'aclass'=>Audrey::Object::Scalar::Number}
 	RUBY_OBJECT_TO_AUDREY[FalseClass]  =  RUBY_OBJECT_TO_AUDREY[TrueClass]
-	RUBY_OBJECT_TO_AUDREY[NilClass]    =  { 'fclass'=>Audrey::Object::Scalar::Null}
+	RUBY_OBJECT_TO_AUDREY[NilClass]    =  { 'aclass'=>Audrey::Object::Scalar::Null}
 
-	RUBY_OBJECT_TO_AUDREY[Hash]        =  {'fclass'=>Audrey::Object::Hash, 'nclass'=>Audrey::Node::Hash}
-	RUBY_OBJECT_TO_AUDREY[Array]       =  {'fclass'=>Audrey::Object::Array, 'nclass'=>Audrey::Node::Array}
+	RUBY_OBJECT_TO_AUDREY[Hash]        =  {'aclass'=>Audrey::Object::Hash, 'nclass'=>Audrey::Node::Hash}
+	RUBY_OBJECT_TO_AUDREY[Array]       =  {'aclass'=>Audrey::Object::Array, 'nclass'=>Audrey::Node::Array}
 	RUBY_OBJECT_TO_AUDREY.freeze
 	#
 	# RUBY_OBJECT_TO_AUDREY
@@ -2491,13 +2484,18 @@ class Audrey
 	# AUDREY_COLLECTION_TO_RUBY
 	#
 	AUDREY_COLLECTION_TO_RUBY = {}
+	
 	AUDREY_COLLECTION_TO_RUBY[Audrey::Object::Hash.to_s] = {'nclass'=>Audrey::Node::Hash}
 	AUDREY_COLLECTION_TO_RUBY[Audrey::Object::Array.to_s] = {'nclass'=>Audrey::Node::Array}
+
+	AUDREY_COLLECTION_TO_RUBY['h'] = {'nclass'=>Audrey::Node::Hash}
+	AUDREY_COLLECTION_TO_RUBY['a'] = {'nclass'=>Audrey::Node::Array}
+	
 	AUDREY_COLLECTION_TO_RUBY.freeze
 	#
 	# AUDREY_COLLECTION_TO_RUBY
 	#---------------------------------------------------------------------------
 end
 #
-# build fclasses for collections
+# build aclasses for collections
 #===============================================================================

data/lib/audrey/engine/sqlite3.rb

@@ -240,17 +240,17 @@ class Audrey::Engine::SQLite3 < Audrey::Engine
 		#-----------------------------------------------------------------------
 		# insert_object_journal
 		#
-		@dbh.create_function('insert_object_journal', 4 ) do |func, partition, root, fclass, scalar, xt|
+		@dbh.create_function('insert_object_journal', 4 ) do |func, partition, root, aclass, scalar, xt|
 			# $tm.hrm
 			
 			# translate scalars to objects for storage in JSON
-			if converter = Audrey::AUDREY_SCALAR_TO_RUBY[fclass]
+			if converter = Audrey::AUDREY_SCALAR_TO_RUBY[aclass]
 				scalar = converter.call(scalar)
 			end
 			
 			# initialize
 			rv = {}
-			rv['fc'] = fclass
+			rv['fc'] = aclass
 			rv['pt'] = partition
 			
 			# scalar
@@ -277,47 +277,36 @@ class Audrey::Engine::SQLite3 < Audrey::Engine
 		
 		
 		#-----------------------------------------------------------------------
-		# fclass_fco, fclass_isolate
+		# aclass_fco, aclass_isolate
 		#
-		@dbh.create_function('fclass_fco', 1) do |func, fclass|
-			func.result = Audrey::Util.fclass_fco(fclass) ? 1 : 0
+		@dbh.create_function('aclass_fco', 1) do |func, aclass|
+			func.result = Audrey::Util.aclass_fco(aclass) ? 1 : 0
 		end
 		
-		@dbh.create_function('fclass_isolate', 1) do |func, fclass|
-			func.result = Audrey::Util.fclass_isolate(fclass) ? 1 : 0
+		@dbh.create_function('aclass_isolate', 1) do |func, aclass|
+			func.result = Audrey::Util.aclass_isolate(aclass) ? 1 : 0
 		end
 		#
-		# fclass_fco, fclass_isolate
+		# aclass_fco, aclass_isolate
 		#-----------------------------------------------------------------------
 		
 		
 		#-----------------------------------------------------------------------
 		# graph_field
 		#
-		@dbh.create_function('graph_field', 2) do |func, fclass, hkey|
-			func.result = Audrey::Util.graph_field?(fclass, hkey) ? 1 : 0
+		@dbh.create_function('graph_field', 2) do |func, aclass, hkey|
+			func.result = Audrey::Util.graph_field?(aclass, hkey) ? 1 : 0
 		end
 		#
 		# graph_field
 		#-----------------------------------------------------------------------
 		
 		
-		#-----------------------------------------------------------------------
-		# change_to_true
-		#
-		# @dbh.create_function('change_to_true', 1) do |func, fclass|
-		# 	func.result = 1
-		# end
-		#
-		# change_to_true
-		#-----------------------------------------------------------------------
-		
-		
 		#-----------------------------------------------------------------------
 		# custom_class
 		#
-		@dbh.create_function('custom_class', 1) do |func, fclass|
-			func.result = Audrey::Util.custom_class?(fclass) ? 1 : 0
+		@dbh.create_function('custom_class', 1) do |func, aclass|
+			func.result = Audrey::Util.custom_class?(aclass) ? 1 : 0
 		end
 		#
 		# custom_class
@@ -381,8 +370,8 @@ class Audrey::Engine::SQLite3 < Audrey::Engine
 		if dfn = Audrey::Engine::SQLite3::RUBY_SCALAR_TO_SQLITE[object.class]
 			if not @preps['insert_scalar']
 				sql = <<~'SQL'
-				insert into objects(pk, partition, bclass, fclass, scalar)
-				values(:pk, :partition, :bclass, :fclass, :scalar)
+				insert into objects(pk, partition, hsa, aclass, scalar)
+				values(:pk, :partition, 's', :aclass, :scalar)
 				SQL
 				
 				@preps['insert_scalar'] = @dbh.prepare(sql)
@@ -393,8 +382,7 @@ class Audrey::Engine::SQLite3 < Audrey::Engine
 				@preps['insert_scalar'],
 				'pk' => pk,
 				'partition' => @partition,
-				'bclass' => dfn['fclass'].bclass.to_s,
-				'fclass' => dfn['fclass'].to_s,
+				'aclass' => dfn['aclass'].to_s,
 				'scalar' => dfn['to_db'].call(object)
 			);
 			
@@ -404,18 +392,20 @@ class Audrey::Engine::SQLite3 < Audrey::Engine
 				prepare_insert_collection(),
 				'pk' => pk,
 				'partition' => @partition,
-				'bclass' => dfn['fclass'].bclass.to_s,
-				'fclass' => dfn['fclass'].to_s
+				'hsa' => dfn['aclass'].hsa,
+				'aclass' => dfn['aclass'].to_s
 			);
 			
 		# if custom object
 		elsif object.is_a?(Audrey::Object::Custom)
+			oclass = object.class
+			
 			simple_exec(
 				prepare_insert_collection(),
 				'pk' => pk,
 				'partition' => @partition,
-				'bclass' => object.class.bclass.to_s,
-				'fclass' => object.class.to_s,
+				'hsa' => oclass.hsa,
+				'aclass' => oclass.to_s,
 			);
 			
 		# else unknown
@@ -464,8 +454,8 @@ class Audrey::Engine::SQLite3 < Audrey::Engine
 		# prepare insert statement if necessary
 		if not @preps['insert_xt']
 			sql = <<~SQL
-			insert into objects(pk, partition, bclass, fclass)
-			values(?, (select partition from objects where pk=?), 'Audrey::Object::Hash', 'xt')
+			insert into objects(pk, partition, hsa, aclass)
+			values(?, (select partition from objects where pk=?), 'h', 'xt')
 			SQL
 			
 			@preps['insert_xt'] ||= @dbh.prepare(sql)
@@ -1001,18 +991,6 @@ class Audrey::Engine::SQLite3 < Audrey::Engine
 	#---------------------------------------------------------------------------
 	
 	
-	#---------------------------------------------------------------------------
-	# import_csv
-	#
-	def import_csv(fclass, path, opts={})
-		# $tm.hrm
-		return Audrey::Engine::SQLite3::Importer::CSV.new(self, fclass, path, opts={})
-	end
-	#
-	# import_csv
-	#---------------------------------------------------------------------------
-	
-	
 	#---------------------------------------------------------------------------
 	# changed_objects
 	#
@@ -1026,7 +1004,7 @@ class Audrey::Engine::SQLite3 < Audrey::Engine
 				from objects
 			where
 				changed and
-				custom_class(fclass)
+				custom_class(aclass)
 			order by
 				changed
 			SQL
@@ -1071,26 +1049,26 @@ class Audrey::Engine::SQLite3 < Audrey::Engine
 	RUBY_SCALAR_TO_SQLITE = {}
 	
 	RUBY_SCALAR_TO_SQLITE[::String] = {
-		'fclass' => Audrey::Object::Scalar::String,
+		'aclass' => Audrey::Object::Scalar::String,
 		'to_db' => Proc.new {|obj| obj}
 	}
 	
 	RUBY_SCALAR_TO_SQLITE[::Integer] = {
-		'fclass' => Audrey::Object::Scalar::Number,
+		'aclass' => Audrey::Object::Scalar::Number,
 		'to_db' => Proc.new {|obj| obj.to_s}
 	}
 	
 	RUBY_SCALAR_TO_SQLITE[::Float] = RUBY_SCALAR_TO_SQLITE[::Integer]
 	
 	RUBY_SCALAR_TO_SQLITE[::TrueClass] = {
-		'fclass' => Audrey::Object::Scalar::Boolean,
+		'aclass' => Audrey::Object::Scalar::Boolean,
 		'to_db' => Proc.new {|obj| obj ? 1 : 0}
 	}
 	
 	RUBY_SCALAR_TO_SQLITE[::FalseClass] = RUBY_SCALAR_TO_SQLITE[::TrueClass]
 	
 	RUBY_SCALAR_TO_SQLITE[::NilClass] = {
-		'fclass' => Audrey::Object::Scalar::Null,
+		'aclass' => Audrey::Object::Scalar::Null,
 		'to_db' => Proc.new {|obj| nil}
 	}
 	
@@ -1106,8 +1084,8 @@ class Audrey::Engine::SQLite3 < Audrey::Engine
 	def prepare_insert_collection
 		if not @preps['insert_collection']
 			sql = <<~'SQL'
-			insert into objects(pk, partition, bclass, fclass)
-			values(:pk, :partition, :bclass, :fclass)
+			insert into objects(pk, partition, hsa, aclass)
+			values(:pk, :partition, :hsa, :aclass)
 			SQL
 			
 			@preps['insert_collection'] = @dbh.prepare(sql)
@@ -1125,7 +1103,7 @@ class Audrey::Engine::SQLite3 < Audrey::Engine
 	#
 	def self.set_row_scalar(row)
 		# fix scalar if necessary
-		if converter = Audrey::AUDREY_SCALAR_TO_RUBY[row['fclass']]
+		if converter = Audrey::AUDREY_SCALAR_TO_RUBY[row['aclass']]
 			row['scalar'] = converter.call(row['scalar'])
 		end
 		
@@ -1194,283 +1172,6 @@ end
 #===============================================================================
 
 
-#===============================================================================
-# Audrey::Engine::SQLite3::Importer
-#
-class Audrey::Engine::SQLite3::Importer
-end
-#
-# Audrey::Engine::SQLite3::Importer
-#===============================================================================
-
-
-#===============================================================================
-# Audrey::Engine::SQLite3::Importer::CSV
-#
-class Audrey::Engine::SQLite3::Importer::CSV < Audrey::Engine::SQLite3::Importer
-	attr_reader :fields
-	attr_accessor :verbose
-	
-	#---------------------------------------------------------------------------
-	# initialize
-	#
-	def initialize(engine, fclass, path, opts={})
-		# $tm.hrm
-		require 'csv'
-		@engine = engine
-		@dbh = @engine.dbh
-		@fclass = fclass.to_s
-		@path = path
-		@partition = 'm'
-		@fields = {}
-		@verbose = false
-	end
-	#
-	# initialize
-	#---------------------------------------------------------------------------
-	
-	
-	#---------------------------------------------------------------------------
-	# run
-	#
-	def run
-		# $tm.hrm
-		converters = {}
-		count = 0
-		
-		# set fclass primary keys
-		fclass_pks()
-		
-		# prepare statements
-		prepare_statements()
-		
-		# build converters
-		@fields.each do |k, dfn|
-			converters[k] = Audrey::AUDREY_SCALAR_TO_RUBY[dfn.to_s]
-		end
-		
-		# begin transaction
-		@dbh.execute 'begin transaction'
-		
-		# TESTING
-		$tm.timer('import') do
-			# loop through CSV
-			::CSV.foreach(@path, headers: true) do |row|
-				# verbosify
-				if @verbose
-					count += 1
-					puts count.to_s + ': ' + row.to_s
-				end
-				
-				# init collection ord
-				ord = 0
-				
-				# convert
-				converters.each do |k, converter|
-					if row.has_key?(k)
-						row[k] = converter.call(row[k])
-					end
-				end
-				
-				# object pk
-				obj_pk = Audrey::Util.uuid
-				
-				# add hash object
-				@insert_hash.execute(
-					'pk'=>obj_pk,
-					'partition'=>@partition,
-					'bclass'=>@obj_bclass_pk,
-					'fclass'=>@obj_fclass_pk
-				);
-				
-				# add scalars and relationships
-				row.each do |k,v|
-					ord += 1
-					scalar_uuid = Audrey::Util.uuid
-					
-					# add scalar object
-					@insert_scalar.execute(
-						'pk'=>scalar_uuid,
-						'partition'=>@partition,
-						'bclass'=>@scalar_bclass_pk,
-						'fclass'=>@bclasses[v.class],
-						'scalar'=>v
-					);
-					
-					# add relationship
-					@insert_relationship.execute(
-						'pk'=>Audrey::Util.uuid,
-						'parent'=>obj_pk,
-						'child'=>scalar_uuid,
-						'hkey'=>k,
-						'ord'=>ord
-					);
-				end
-			end
-		end
-		
-		# commit transaction
-		$tm.timer('commit') do
-			@dbh.execute 'commit'
-		end
-		
-	# close prepared statements
-	ensure
-		$tm.puts 'close prepared statements'
-		
-		$tm.timer('close prepared statements') do
-			@insert_hash and @insert_hash.close
-			@insert_scalar and @insert_scalar.close
-			@insert_relationship and @insert_relationship.close
-		end
-	end
-	#
-	# run
-	#---------------------------------------------------------------------------
-	
-	
-	#---------------------------------------------------------------------------
-	# prepare_statements
-	#
-	def prepare_statements
-		# $tm.hrm
-		
-		# hash
-		sql = <<~'SQL'
-		insert into
-			base_objects(
-				pk,
-				partition,
-				bclass_pk,
-				fclass_pk
-			)
-			
-			values(
-				:pk,
-				:partition,
-				:bclass,
-				:fclass
-			);
-		SQL
-		
-		# prepare
-		@insert_hash = @dbh.prepare(sql)
-		
-		# scalar
-		sql = <<~'SQL'
-		insert into
-			base_objects(
-				pk,
-				partition,
-				bclass_pk,
-				fclass_pk,
-				scalar
-			)
-			
-			values(
-				:pk,
-				:partition,
-				:bclass,
-				:fclass,
-				:scalar
-			);
-		SQL
-		
-		# prepare
-		@insert_scalar = @dbh.prepare(sql)
-		
-		# relationship
-		sql = <<~'SQL'
-		insert into relationships(
-			pk,
-			parent,
-			child,
-			hkey,
-			ord
-		)
-		
-		values(
-			:pk,
-			:parent,
-			:child,
-			:hkey,
-			:ord
-		)
-		SQL
-		
-		# prepare
-		@insert_relationship = @dbh.prepare(sql)
-	end
-	#
-	# prepare_statements
-	#---------------------------------------------------------------------------
-	
-	
-	#---------------------------------------------------------------------------
-	# fclass_pks
-	#
-	def fclass_pks
-		@bclasses = {}
-		
-		# object bclass primary key
-		@obj_bclass_pk = set_fclass_pk('Audrey::Object::Hash')
-		
-		# object fclass primary key
-		@obj_fclass_pk = set_fclass_pk(@fclass)
-		
-		# scalar base class
-		@scalar_bclass_pk = set_fclass_pk('Audrey::Object::Scalar')
-		
-		# loop through scalar classes
-		[String, Integer, Float, NilClass].each do |clss|
-			@bclasses[clss] = set_fclass_pk(Audrey::RUBY_OBJECT_TO_AUDREY[clss]['fclass'].to_s)
-		end
-	end
-	#
-	# fclass_pks
-	#---------------------------------------------------------------------------
-	
-	
-	#---------------------------------------------------------------------------
-	# set_fclass_pk
-	#
-	def set_fclass_pk(set_fclass)
-		# $tm.hrm
-		
-		# ensure fclass record
-		sql = <<~'SQL'
-		insert or ignore into
-		fclasses(name)
-		values(:fclass);
-		SQL
-		
-		# execute
-		@dbh.execute sql, 'fclass'=>set_fclass
-		
-		# get fclass pk
-		sql = 'select pk from fclasses where name=:fclass'
-		return @dbh.get_first_value(sql, 'fclass'=>set_fclass)
-	end
-	#
-	# set_fclass_pk
-	#---------------------------------------------------------------------------
-	
-	
-	#---------------------------------------------------------------------------
-	# set_bclass_pks
-	#
-	# def set_bclass_pks
-	#	$tm.hrm
-	# end
-	#
-	# set_bclass_pks
-	#---------------------------------------------------------------------------
-end
-#
-# Audrey::Engine::SQLite3::Importer::CSV
-#===============================================================================
-
-
 #===============================================================================
 # Audrey::Engine::SQLite3::Query
 #

data/lib/audrey/engine/sqlite3/init.rb

@@ -167,18 +167,18 @@ module Audrey::Engine::SQLite3::Init
 	def self.objects
 		# build
 		@dbh.execute_batch <<-SQL
-		-- fclasses table
-		create table fclasses(
+		-- aclasses table
+		create table aclasses(
 			pk integer primary key autoincrement,
 			name varchar(255) unique not null,
 			check (length(name)>0)
 		);
 		
-		-- cannot update fclasses
-		create trigger fclasses_bu
-		before update on fclasses
+		-- cannot update aclasses
+		create trigger aclasses_bu
+		before update on aclasses
 		begin
-			select raise(abort, 'cannot-update-fclasses');
+			select raise(abort, 'cannot-update-aclasses');
 		end;
 		
 		-- base_objects table
@@ -186,8 +186,8 @@ module Audrey::Engine::SQLite3::Init
 			pk varchar(36) primary key,
 			partition varchar(1) not null references partitions(pk),
 			root boolean,
-			bclass_pk integer not null references fclasses(pk) on delete restrict,
-			fclass_pk integer not null references fclasses(pk) on delete restrict,
+			hsa varchar(1) not null check(hsa in ('h', 's', 'a')),
+			aclass_pk integer not null references aclasses(pk) on delete restrict,
 			scalar text,
 			xt uuid references base_objects(pk) unique,
 			changed datetime default current_timestamp,
@@ -197,8 +197,8 @@ module Audrey::Engine::SQLite3::Init
 		-- indexes
 		create unique index base_objects_partition_root on base_objects(partition, root);
 		create index base_objects_partition  on base_objects(partition);
-		create index base_objects_bclass_pk  on base_objects(bclass_pk);
-		create index base_objects_fclass_pk  on base_objects(fclass_pk);
+		create index base_objects_hsa        on base_objects(hsa);
+		create index base_objects_aclass_pk  on base_objects(aclass_pk);
 		create index base_objects_scalar     on base_objects(scalar);
 		create index base_objects_changed    on base_objects(changed);
 		
@@ -206,8 +206,8 @@ module Audrey::Engine::SQLite3::Init
 		create trigger base_objects_bu_pk        before update of pk        on base_objects begin select raise(abort, 'cannot-update-object-pk');        end;
 		create trigger base_objects_bu_partition before update of partition on base_objects begin select raise(abort, 'cannot-update-object-partition'); end;
 		create trigger base_objects_bu_root      before update of root      on base_objects begin select raise(abort, 'cannot-update-object-root');      end;
-		create trigger base_objects_bu_bclass_pk before update of bclass_pk on base_objects begin select raise(abort, 'cannot-update-object-bclass_pk'); end;
-		create trigger base_objects_bu_fclass_pk before update of fclass_pk on base_objects begin select raise(abort, 'cannot-update-object-fclass_pk'); end;
+		create trigger base_objects_bu_hsa       before update of hsa       on base_objects begin select raise(abort, 'cannot-update-object-hsa');       end;
+		create trigger base_objects_bu_aclass_pk before update of aclass_pk on base_objects begin select raise(abort, 'cannot-update-object-aclass_pk'); end;
 		create trigger base_objects_bu_scalar    before update of scalar    on base_objects begin select raise(abort, 'cannot-update-object-scalar');    end;
 		
 		-- cannot update xt once it has been defined
@@ -235,7 +235,7 @@ module Audrey::Engine::SQLite3::Init
 				insert_object_journal(
 					new.partition,
 					new.root,
-					(select name from fclasses where pk=new.fclass_pk),
+					(select name from aclasses where pk=new.aclass_pk),
 					new.scalar,
 					new.xt
 				)
@@ -266,21 +266,20 @@ module Audrey::Engine::SQLite3::Init
 			insert into journal(tbl, fpk, action) values('o', old.pk, 'd');
 		end;
 		
-		-- initial fclass
-		insert into fclasses(name) values('Audrey::Object::Hash');
-		insert into fclasses(name) values('Audrey::Object::Root');
+		-- initial aclass
+		insert into aclasses(name) values('Audrey::Object::Hash');
+		insert into aclasses(name) values('Audrey::Object::Root');
 		
 		-- add root objects
-		insert into base_objects(pk, partition, bclass_pk, fclass_pk, root, changed) values('1', 'm', 1, 2, 1, null);
-		insert into base_objects(pk, partition, bclass_pk, fclass_pk, root, changed) values('2', 'r', 1, 2, 1, null);
-		insert into base_objects(pk, partition, bclass_pk, fclass_pk, root, changed) values('3', 'd', 1, 2, 1, null);
+		insert into base_objects(pk, partition, hsa, aclass_pk, root, changed) values('1', 'm', 'h', 2, 1, null);
+		insert into base_objects(pk, partition, hsa, aclass_pk, root, changed) values('2', 'r', 'h', 2, 1, null);
+		insert into base_objects(pk, partition, hsa, aclass_pk, root, changed) values('3', 'd', 'h', 2, 1, null);
 		
 		-- objects view
 		create view objects as
 			select
-				o.pk, o.partition, o.root, o.scalar, o.xt, o.changed,
-				(select name from fclasses where pk=o.bclass_pk) as bclass,
-				(select name from fclasses where pk=o.fclass_pk) as fclass
+				o.pk, o.partition, o.root, o.scalar, o.xt, o.changed, o.hsa,
+				(select name from aclasses where pk=o.aclass_pk) as aclass
 			from base_objects o
 			where o.partition = current_partition();
 			
@@ -289,17 +288,12 @@ module Audrey::Engine::SQLite3::Init
 			instead of insert on objects
 		begin
 			-- notify database of change
-			-- select change_to_true(new.fclass);
+			-- select change_to_true(new.aclass);
 			
-			-- ensure bclass record
+			-- ensure aclass record
 			insert or ignore into
-			fclasses(name)
-			values(new.bclass);
-			
-			-- ensure fclass record
-			insert or ignore into
-			fclasses(name)
-			values(new.fclass);
+			aclasses(name)
+			values(new.aclass);
 			
 			-- insert
 			insert into
@@ -307,8 +301,8 @@ module Audrey::Engine::SQLite3::Init
 					pk,
 					partition,
 					root,
-					bclass_pk,
-					fclass_pk,
+					hsa,
+					aclass_pk,
 					scalar,
 					xt
 				)
@@ -317,8 +311,8 @@ module Audrey::Engine::SQLite3::Init
 					new.pk,
 					current_partition(),
 					new.root,
-					(select pk from fclasses where name=new.bclass),
-					(select pk from fclasses where name=new.fclass),
+					new.hsa,
+					(select pk from aclasses where name=new.aclass),
 					new.scalar,
 					new.xt
 				);
@@ -384,12 +378,12 @@ module Audrey::Engine::SQLite3::Init
 		end;
 		
 		-- parent must be array or hash
-		create trigger relationships_bi_bclass
+		create trigger relationships_bi_hsa
 			before insert on relationships
 		begin
 			select case
-			when (select bclass from objects where pk=new.parent) not in ('Audrey::Object::Array', 'Audrey::Object::Hash') then
-				raise(abort, 'relationship-parent-base-class-does-not-support-relatonships')
+				when (select hsa from objects where pk=new.parent) not in ('h', 'a') then
+					raise(abort, 'relationship-parent-base-class-does-not-support-relatonships')
 			end;
 		end;
 		
@@ -451,7 +445,7 @@ module Audrey::Engine::SQLite3::Init
 		-- from objects view, the delete never happens. So deleting directly
 		-- from base_objects.
 		create trigger relationships_ad_graph
-			after delete on relationships when (select graph_field((select fclass from objects where pk=old.parent), old.hkey))
+			after delete on relationships when (select graph_field((select aclass from objects where pk=old.parent), old.hkey))
 		begin
 			delete from base_objects where pk=old.parent;
 		end;
@@ -483,7 +477,7 @@ module Audrey::Engine::SQLite3::Init
 		create view fcos as
 			select pk
 			from objects
-			where fclass_fco(fclass);
+			where aclass_fco(aclass);
 		
 		-- fco_descendants
 		create view fco_descendants as
@@ -498,7 +492,7 @@ module Audrey::Engine::SQLite3::Init
 		create view fco_traced as
 			select distinct pk
 			from objects
-			where fclass_fco(fclass) or (pk in (select child from fco_descendants));
+			where aclass_fco(aclass) or (pk in (select child from fco_descendants));
 		
 		-- fco_not_traced
 		create view fco_not_traced as

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

@@ -125,18 +125,18 @@ class Audrey::Engine::SQLite3::Query::Q0
 		# partition pk
 		params['partition'] = @engine.partition
 		
-		# fclasses
-		if (fclasses = @fquery.fclasses) and fclasses.any?
+		# aclasses
+		if (aclasses = @fquery.aclasses) and aclasses.any?
 			wheres = []
 			
-			fclasses.each do |fclass|
+			aclasses.each do |aclass|
 				rs = Audrey::Util.randstr(40)
 				wheres.push ":#{rs}"
-				params[rs] = fclass
+				params[rs] = aclass
 			end
 			
 			# add wheres
-			sql += "	and\n" + '	(fclass in (' + wheres.join(', ') + '))'
+			sql += "	and\n" + '	(aclass in (' + wheres.join(', ') + '))'
 		end
 		
 		# limit to hashes
@@ -226,14 +226,14 @@ class Audrey::Engine::SQLite3::Query::Q0
 	
 	
 	#---------------------------------------------------------------------------
-	# fclasses
+	# aclasses
 	#
-	def fclasses(wheres, params)
-		fcs = @fquery.fclasses
+	def aclasses(wheres, params)
+		fcs = @fquery.aclasses
 		fcs.any? or return
 		where = []
 		
-		# loop through fclasses
+		# loop through aclasses
 		fcs.each do |fc|
 			rs = Audrey::Util.randstr(40)
 			params[rs] = fc
@@ -241,10 +241,10 @@ class Audrey::Engine::SQLite3::Query::Q0
 		end
 		
 		# add to wheres
-		wheres.push 'fclass in (' + where.join(', ') + ')'
+		wheres.push 'aclass in (' + where.join(', ') + ')'
 	end
 	#
-	# fclasses
+	# aclasses
 	#---------------------------------------------------------------------------
 	
 	

data/lib/audrey/query/q0.rb

@@ -4,7 +4,7 @@
 class Audrey::Query::Q0 < Audrey::Query
 	attr_reader :db
 	attr_accessor :fields
-	attr_accessor :fclass
+	attr_accessor :aclass
 	attr_accessor :limit
 	attr_accessor :offset
 	
@@ -19,7 +19,7 @@ class Audrey::Query::Q0 < Audrey::Query
 		
 		@db = p_db
 		@engine = @db.engine
-		@fclass = nil
+		@aclass = nil
 		@fields = Audrey::Query::Q0::Fields.new()
 	end
 	#
@@ -152,20 +152,20 @@ class Audrey::Query::Q0 < Audrey::Query
 	
 	
 	#---------------------------------------------------------------------------
-	# fclasses
+	# aclasses
 	#
-	def fclasses
+	def aclasses
 		# $tm.hrm
 		
-		# early exit: no fclass
-		if not @fclass
+		# early exit: no aclass
+		if not @aclass
 			return nil
 		end
 		
 		# initialize
-		fcs = [*@fclass]
+		fcs = [*@aclass]
 		
-		# early exit: fclass is an empty array
+		# early exit: aclass 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?
@@ -175,9 +175,9 @@ class Audrey::Query::Q0 < Audrey::Query
 		# initialize
 		rv = {}
 		
-		# build fclasses
-		fcs.each do |fclass|
-			fclass.fclasses.each do |desc|
+		# build aclasses
+		fcs.each do |aclass|
+			aclass.aclasses.each do |desc|
 				rv[desc] = nil
 			end
 		end
@@ -186,7 +186,7 @@ class Audrey::Query::Q0 < Audrey::Query
 		return rv.keys
 	end
 	#
-	# fclasses
+	# aclasses
 	#---------------------------------------------------------------------------
 	
 	
@@ -197,11 +197,11 @@ class Audrey::Query::Q0 < Audrey::Query
 		# $tm.hrm
 		rv = self.class.new(@db)
 		
-		# fclass
-		if @fclass.is_a?(Array)
-			rv.fclass = @fclass.clone
+		# aclass
+		if @aclass.is_a?(Array)
+			rv.aclass = @aclass.clone
 		else
-			rv.fclass = @fclass
+			rv.aclass = @aclass
 		end
 		
 		# fields

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: audrey
 version: !ruby/object:Gem::Version
-  version: 0.3.1
+  version: 0.3.2
 platform: ruby
 authors:
 - Mike O'Sullivan
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2020-02-12 00:00:00.000000000 Z
+date: 2020-02-14 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: sqlite3
@@ -38,8 +38,7 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
-description: A lighweight DBMS that you can start using in a few minutes and master
-  in a few hours
+description: The world's easiest database
 email: mike@idocs.com
 executables: []
 extensions: []