class GxG::Database::Database

# File lib/gxg/gxg_database.rb, line 97
def self.element_table_by_index(the_index=0)
  (::GxG::Database::Database::element_tables().keys[(the_index)] || :unspecified)
end

# File lib/gxg/gxg_database.rb, line 101
def self.element_table_for_instance(the_instance=nil)
  # Review : rewrite - in use
  result = :unspecified
  #
  table = ::GxG::Database::Database::element_tables()
  table.keys.each do |the_key| 
    unless the_key == :unspecified
      if the_instance.is_any?(table[(the_key)])
        result = the_key
        break
      end
    end
  end
  #
  result
end

# File lib/gxg/gxg_database.rb, line 93
def self.element_table_index(the_key=:unspecified)
  (::GxG::Database::Database::element_tables().keys.index(the_key.to_sym) || 0)
end

# File lib/gxg/gxg_database.rb, line 74
def self.element_tables()
  {
    :unspecified => nil,
    :element_boolean => [::TrueClass, ::FalseClass, ::NilClass],
    :element_integer => [::Integer],
    :element_float => [::Float],
    :element_bigdecimal => [::BigDecimal],
    :element_datetime => [::DateTime],
    :element_text => [::String],
    :element_binary => [::GxG::ByteArray],
    :element_array => [::Array],
    :element_hash => [::Hash]
  }
end

# File lib/gxg/gxg_database.rb, line 5111
def initialize(connection = nil, options={})
  # TODO: require :credential (access privs)
  super()
  @credential = nil
  @url = options[:url]
  @base_permissions = {:execute => false, :rename => false, :move => false, :destroy => false, :create => false, :write => false, :read => false}
  #
  if connection.is_a?(::Sequel::Database)
    @connector = connection
    #
    @active = false
    unless open?()
      raise Exception, "Unable to connect with the database"
    end
    #
    @scheme = @url.scheme.to_s.to_sym
    case @scheme
    when :sqlite, :sqlite3
      @connector.run("PRAGMA page_size=65536")
      @connector.run("PRAGMA max_page_count=281474976710656")
      @connector.run("PRAGMA encoding='UTF-8'")
    when :mysql, :mysql2
      @connector.run("SET GLOBAL max_allowed_packet=17825792;")
      @connector.run("SET NAMES 'utf8' COLLATE 'utf8_general_ci';")
      @connector.run("SET collation_connection = 'utf8_general_ci';")
    when :postgres
      # place holder
    end
  else
    raise Exception, "Invalid db connection"
  end
  # characterize basic effective permissions
  begin
    formatted = db_formatted?()
    @base_permissions[:read] = true
    @base_permissions[:execute] = true
  rescue Exception => the_error
    formatted = false
    raise Exception, "Lack read permissions to the database"
  end
  #
  unless options[:read_only]
    if formatted
      begin
        dbid = @connector[:text_page].insert()
      rescue Exception => the_error
        dbid = nil
      end
      if dbid.is_a?(::Integer)
        @connector[:text_page].filter({:dbid => (dbid)}).delete
        @base_permissions[:write] = true
        @base_permissions[:create] = true
        @base_permissions[:destroy] = true
        @base_permissions[:rename] = true
        @base_permissions[:move] = true
      end
    else
      begin
        test_table_name = ::GxG::uuid_generate().gsub("-","")
        while (@connector.table_exists?(test_table_name.to_sym)) do
          test_table_name = ::GxG::uuid_generate().gsub("-","")
        end
        @connector.create_table(test_table_name.to_sym) do
          primary_key :dbid
        end
        @connector.drop_table(test_table_name.to_sym)
        @base_permissions[:write] = true
        @base_permissions[:create] = true
        @base_permissions[:destroy] = true
        @base_permissions[:rename] = true
        @base_permissions[:move] = true
      rescue Exception => the_error
        # Read-only Database
      end
    end
  end
  #
  @base_permissions.freeze
  #
  unless formatted
    if @base_permissions[:write]
      db_format
      unless db_formatted?()
        @active = false
        raise Exception, "Unable to format the database for use"
      end
    else
      raise Exception, "Unable to format a read-only database"
    end
  end
  #
  @authority = nil
  @db_list = []
  if options[:authority].is_a?(::GxG::Database::Database)
    @authority = options[:authority]
    @authority.db_register(self)
  end
  #
  unless @authority
    unless self.group_exist?("Administrators")
      if @base_permissions[:write]
        if self.user_id_available?("root")
          self.user_create("root","password")
          temp_cred = self.user_credential("root","password")
          temp_group = self.group_create({:title => "Administrators", :default_role => {:title => "Members"}})
          self.role_add_user(temp_group[:default_role],temp_cred)
          #
          dev_group = self.group_create({:title => "Developers", :default_role => {:title => "Members"}})
          dsn_group = self.group_create({:title => "Designers", :default_role => {:title => "Members"}})
          #
          self[:system_credentials] = {:administrator => temp_cred, :administrators => temp_group[:default_role], :developers => dev_group[:default_role], :designers => dsn_group[:default_role]}
          self[:permission_policy] = [{:event => :extend, :credential => :any, :action => {:extend_permissions => temp_group[:default_role]}}]
          #
        end
        if self.user_id_available?("public")
          self.user_create("public","password", "00000000-0000-4000-0000-000000000000")
        end
      end
    end
  end
  #
  permission_policy_load
  self
end

# File lib/gxg/gxg_database.rb, line 89
def self.valid_field_classes()
  [::TrueClass, ::FalseClass, ::NilClass, ::Integer, ::Float, ::BigDecimal, ::DateTime, ::String, ::GxG::ByteArray]
end

# File lib/gxg/gxg_database.rb, line 3500
def [](setting_key=nil)
  result = nil
  begin
    if self.alive?()
      if self.open?()
        record = @connector[:settings].filter({:title => setting_key.to_s}).first
        if record
          content = ""
          @connector[:text_page].select(:content).where({:parent_uuid => record[:uuid].to_s}).order(:ordinal).each do |entry|
            content << entry[:content]
          end
          if content.size > 0
            result = content.unserialize()
          end
        end
      else
        raise Exception, "Database not available"
      end
    else
      raise Exception, "Attempted to access a defunct Database"
    end
  rescue Exception => the_error
    log_error({:error => the_error, :parameters => {:setting_key => setting_key}})
  end
  result
end

# File lib/gxg/gxg_database.rb, line 3527
def []=(setting_key=nil, object=nil)
  result = object
  begin
    if self.alive?()
      if self.open?()
        unless self.db_permissions()[:write]
          raise Exception, "Unable to write to database"
        end
        unless setting_key.is_a?(::Symbol)
          raise ArgumentError, "You must supply a setting key as a Symbol"
        end
        unless setting_key.to_s.size > 0
          raise ArgumentError, "You must supply a setting key whose length is greater than zero"
        end
        record = @connector[:settings].filter({:title => setting_key.to_s}).first
        unless record
          new_uuid = ::GxG::uuid_generate().to_s
          while (@connector[:settings].filter({:uuid => (new_uuid)}).count > 0 or @connector[:formats].filter({:uuid => (new_uuid)}).count > 0 or @connector[:element_text].filter({:uuid => (new_uuid)}).count > 0)
            new_uuid = ::GxG::uuid_generate().to_s
          end
          @connector[:settings].insert({:title => setting_key.to_s, :uuid => new_uuid.to_s})
          record = @connector[:settings].filter({:uuid => (new_uuid)}).first
        end
        if record
          @connector[:settings].filter({:dbid => (record[:dbid])}).update({:version => (record[:version] + 0.0001)})
          content = object.serialize()
          old_segments = []
          @connector[:text_page].select(:dbid).where({:parent_uuid => record[:uuid].to_s}).order(:ordinal).each do |entry|
            old_segments << entry[:dbid]
          end
          if content.size == 0
            if old_segments.size > 0
              @connector[:text_page].filter({:parent_uuid => record[:uuid].to_s}).delete
            end
          else
            new_segments = ::GxG::apportioned_ranges(content.size, 4096)
            if old_segments.size > new_segments.size
              the_count = old_segments.size
            else
              the_count = new_segments.size
            end
            manifest = []
            (0..(the_count - 1)).each do |the_ordinal|
              if new_segments[(the_ordinal)] and old_segments[(the_ordinal)]
                #overwrite with new segment range
                manifest << {:operation => :overwrite, :dbid => (old_segments[(the_ordinal)]), :ordinal => (the_ordinal), :portion => (new_segments[(the_ordinal)])}
              else
                if new_segments[(the_ordinal)]
                  # create new segment at this ordinal
                  manifest << {:operation => :create, :ordinal => (the_ordinal), :portion => (new_segments[(the_ordinal)])}
                else
                  # delete old segment
                  manifest << {:operation => :delete, :dbid => (old_segments[(the_ordinal)])}
                end
              end
            end
            manifest.each do |action|
              case action[:operation]
              when :overwrite
                @connector[:text_page].filter({:dbid => (action[:dbid])}).update({:ordinal => (action[:ordinal]), :length => (content[(action[:portion])].size), :content => (content[(action[:portion])])})
              when :create
                @connector[:text_page].insert({:parent_uuid => (record[:uuid]), :ordinal => (action[:ordinal]), :length => (content[(action[:portion])].size), :content => (content[(action[:portion])])})
              when :delete
                @connector[:text_page].filter({:dbid => (action[:dbid])}).delete
              end
            end
            #
          end
        else
          raise Exception, "Internal Error - could not retrieve setting record: #{setting_key.inspect}"
        end
      else
        raise Exception, "Database not available"
      end
    else
      raise Exception, "Attempted to access a defunct Database"
    end
  rescue Exception => the_error
    log_error({:error => the_error, :parameters => {:setting => setting_key, :object => object}})
  end
  result
end

# File lib/gxg/gxg_database.rb, line 1502
def assign_element_permission(table=:unspecified, dbid=0, credential=nil, permissions={})
  result = false
  begin
    unless self.alive?
      raise Exception, "Database inactive"
    end
    unless self.open?
      raise Exception, "Database not available"
    end
    unless dbid.is_a?(::Integer)
      raise ArgumentError, "dbid must be specified with a Integer"
    end
    unless permissions.is_a?(::Hash)
      raise ArgumentError, "permissions must be specified with a Hash"
    end
    unless ::GxG::valid_uuid?(credential)
      raise ArgumentError, "You must specify a valid credential UUID (as a String or Symbol)"
    end
    if table.is_a?(::Integer)
      table = ::GxG::Database::Database::element_table_by_index(table)
    end
    # Review : change in permission policy
    # if [:element_boolean, :element_integer, :element_float, :element_bigdecimal, :element_datetime, :element_text, :element_binary, :element_array, :element_hash].include?(table)
    if [:element_array, :element_hash].include?(table)
      record = @connector[:permissions].filter({:element_table => (table.to_s), :elementid => (dbid), :credential => (credential.to_s)}).first
      if record
        # update
        the_update = {:execute => 0, :rename => 0, :move => 0, :destroy => 0, :create => 0, :write => 0, :read => 0}
        [:execute, :rename, :move, :destroy, :create, :write, :read].each do |the_permission|
          if record[(the_permission)] == 1
            the_update[(the_permission)] = 1
          end
        end
        [:execute, :rename, :move, :destroy, :create, :write, :read].each do |the_permission|
          if permissions[(the_permission)].is_a?(::TrueClass)
            the_update[(the_permission)] = 1
          end
          if permissions[(the_permission)].is_a?(::FalseClass)
            the_update[(the_permission)] = 0
          end
        end
        the_update[:version] = record[:version] + 0.0001
        @connector[:permissions].filter({:dbid => (record[:dbid])}).update(the_update)
      else
        # create
        new_record = {:credential => (credential.to_s), :element_table => (table.to_s), :elementid => (dbid), :execute => 0, :rename => 0, :move => 0, :destroy => 0, :create => 0, :write => 0, :read => 0}
        [:execute, :rename, :move, :destroy, :create, :write, :read].each do |the_permission|
          if permissions[(the_permission)]
            new_record[(the_permission)] = 1
          end
        end
        @connector[:permissions].insert(new_record)
      end
      result = true
    else
      raise ArgumentError, "Invalid table specified"
    end
  rescue Exception => the_error
    log_error({:error => the_error, :parameters => {:table => (table), :dbid => (dbid), :credential => (credential), :permissions => (permissions)}})
  end
  result
end

# File lib/gxg/gxg_database.rb, line 2514
def byte_size_by_uuid(the_uuid=nil)
  result = 0
  begin
    if self.alive?
      if self.open?
        found = @connector[:element_hash].select(:dbid, :uuid).filter({:uuid => the_uuid.to_s}).first
        if found
          result += self.element_byte_size(:element_hash,(found[:dbid]))
        else
          found = @connector[:element_array].select(:dbid, :uuid).filter({:uuid => the_uuid.to_s}).first
          if found
            result += self.element_byte_size(:element_array,(found[:dbid]))
          end
        end
      end
    end
  rescue Exception => the_error
    log_error({:error => the_error, :parameters => {:uuid => (the_uuid)}})
  end
  result
end

# File lib/gxg/gxg_database.rb, line 5086
def clear_all_element_locks()
  # for when boo-boos happen
  if self.open?()
    if self.db_permissions()[:write]
      @connector[:element_locks].filter({}).delete
    end
  end
end

# File lib/gxg/gxg_database.rb, line 5107
def clone()
  initialize_clone
end

# File lib/gxg/gxg_database.rb, line 415
def close()
  # place holder for now.
  if @authority
    @authority.db_unregister(self)
  end
end

# File lib/gxg/gxg_database.rb, line 422
def connector()
  @connector
end

# File lib/gxg/gxg_database.rb, line 1767
def create_vfs_permission(file_id=nil, credential=nil, permission={:execute => false, :rename => false, :move => false, :destroy => false, :create => false, :write => false, :read => false})
  result = false
  begin
    unless self.alive?
      raise Exception, "Database inactive"
    end
    unless self.open?
      raise Exception, "Database not available"
    end
    unless file_id.is_a?(::String)
      raise ArgumentError, "file_id must be specified with a String"
    end
    unless permission.is_a?(::Hash)
      raise ArgumentError, "permission must be specified with a Hash"
    end
    unless ::GxG::valid_uuid?(credential)
      raise ArgumentError, "You must specify a valid credential UUID (as a String or Symbol)"
    end
    #
    record = @connector[:file_permissions].filter({:file_id => file_id.to_s, :credential => credential.to_s}).first
    if record
      update = true
      dbid = record.delete(:dbid)
    else
      update = false
      dbid = nil
      record = {:file_id => file_id.to_s, :credential => credential.to_s, :execute => 0, :rename => 0, :move => 0, :destroy => 0, :create => 0, :write => 0, :read => 0}
    end
    permission.keys.each do |the_permission_key|
      if permission[(the_permission_key)] == true
        record[(the_permission_key)] = 1
      else
        record[(the_permission_key)] = 0
      end
    end
    if update == true
      @connector[:file_permissions].filter({:dbid => dbid}).update(record)
    else
      @connector[:file_permissions].insert(record)
    end
    result = true
  rescue Exception => the_error
    log_error({:error => the_error, :parameters => {:file_id => (file_id), :credential => (credential)}})
  end
  result
end

# File lib/gxg/gxg_database.rb, line 297
def db_format(format_options={})
  # MySql stuff:
  # ALTER TABLE tbl_name MAX_ROWS=1000000000 AVG_ROW_LENGTH=nnn;
  # See: https://dev.mysql.com/doc/refman/5.0/en/table-size-limit.html
  result = true
  #
  begin
    if @connector.is_a?(::Sequel::Database)
      case @scheme
      when :sqlite
        @connector.run("PRAGMA page_size=65536")
        @connector.run("PRAGMA max_page_count=281474976710656")
        @connector.run("PRAGMA encoding='UTF-8'")
      when :mysql, :mysql2
        @connector.run("SET GLOBAL max_allowed_packet = 17825792;")
        @connector.run("SET NAMES 'utf8' COLLATE 'utf8_general_ci';")
        @connector.run("SET collation_connection = 'utf8_general_ci';")
      when :postgres
        # place holder
      end
      migration = db_migration()
      migration.keys.each do |the_table|
        unless @connector.table_exists?(the_table)
            @connector.create_table(the_table) do
            primary_key :dbid
          end
        end
        used_bytes = 0
        #
        existing_columns = @connector[(the_table)].columns
        migration[(the_table)].keys.each do |the_column|
          used_bytes += (migration[(the_table)][(the_column)][:bytes]).to_i
          if existing_columns.include?(the_column)
            # TODO: figure out a way to inspect columns for attributes -> detailed verification
          else
            # collation for mysql
            if @scheme == :mysql
              # Note: might have to specify :collate first, use -> {:collate => ""}.merge(migration[(the_table)][(the_column)][:options])
              if migration[(the_table)][(the_column)][:type] == :varchar
                # migration[(the_table)][(the_column)][:options] = {:collate => "utf8_general_ci"}.merge(migration[(the_table)][(the_column)][:options])
                migration[(the_table)][(the_column)][:options][:collate] = "utf8_general_ci"
              end
              if migration[(the_table)][(the_column)][:type] == :blob
                # migration[(the_table)][(the_column)][:options] = {:collate => "binary"}.merge(migration[(the_table)][(the_column)][:options])
                # Note: MySQL 5 doesn't like putting collation on blobs! (blows up)
                # migration[(the_table)][(the_column)][:options][:collate] = "binary"
              end
            else
            end
            # do the deed
            @connector.add_column((the_table), (the_column), (migration[(the_table)][(the_column)][:type]), (migration[(the_table)][(the_column)][:options]))
            #
          end
        end
        #
        if @scheme == :mysql
          @connector.run("ALTER TABLE #{the_table.to_s} MAX_ROWS=18446744073709551616 AVG_ROW_LENGTH=#{used_bytes.to_s};")
        end
        #
      end
    else
      raise Exception, "Invalid db connection"
    end
  rescue Exception => the_error
    result = false
    log_error({:error => the_error, :parameters => format_options})
  end
  #
  result
end

# File lib/gxg/gxg_database.rb, line 368
def db_formatted?()
  result = true
  #
  begin
    if @connector.is_a?(::Sequel::Database)
      migration = db_migration()
      migration.keys.each do |the_table|
        unless @connector.table_exists?(the_table)
          result = false
          break
        end
        #columns
        existing_columns = @connector[(the_table)].columns
        migration[(the_table)].keys.each do |the_column|
          unless existing_columns.include?(the_column)
            result = false
            break
          end
        end
        #
        unless (result)
          break
        end
      end
    else
      raise Exception, "Invalid db connection"
    end
  rescue Exception => the_error
    result = false
    log_error({:error => the_error, :parameters => nil})
  end
  #
  result
end

# File lib/gxg/gxg_database.rb, line 455
def db_list()
  result = []
  @db_list.each do |the_db|
    result << the_db
  end
  result
end

# File lib/gxg/gxg_database.rb, line 118
def db_migration()
  # Review : Consider adding support for a ::Symbol class as well. (ease-of-use implications later)
  # Internal mapping of the database format
  # Datatypes - See: http://sequel.jeremyevans.net/rdoc/files/doc/schema_modification_rdoc.html
  # Column Options - See: http://sequel.jeremyevans.net/rdoc/classes/Sequel/Database.html#method-i-add_column
  # See also : http://ruby-doc.org/core-2.2.0/Array.html#method-i-pack
  {
    :element_text => {
      :dbid => {:type => :integer, :options => {:unique => true, :primary_key => true, :auto_increment => true}, :bytes => ([ -1 ].pack('l!').length)},
      :uuid => {:type => :varchar, :options => {:size => 40, :default => "", :null => false}, :bytes => 40},
      :version => {:type => :float, :options => {:default => 0.0}, :bytes => ([ 0.1 ].pack('d').length)},
      :length => {:type => :integer, :options => {:default => 0}, :bytes => ([ -1 ].pack('l!').length)}
      },
    :text_page => {
      :dbid => {:type => :integer, :options => {:unique => true, :primary_key => true, :auto_increment => true}, :bytes => ([ -1 ].pack('l!').length)},
      :parent_uuid => {:type => :varchar, :options => {:size => 40, :default => "", :null => false}, :bytes => 40},
      :ordinal => {:type => :integer, :options => {:default => 0}, :bytes => ([ -1 ].pack('l!').length)},
      :length => {:type => :integer, :options => {:default => 0}, :bytes => ([ -1 ].pack('l!').length)},
      :content => {:type => :varchar, :options => {:size => 4099, :default => "", :null => false}, :bytes => 4099}
      },
    :element_binary => {
      :dbid => {:type => :integer, :options => {:unique => true, :primary_key => true, :auto_increment => true}, :bytes => ([ -1 ].pack('l!').length)},
      :uuid => {:type => :varchar, :options => {:size => 40, :default => "", :null => false}, :bytes => 40},
      :version => {:type => :float, :options => {:default => 0.0}, :bytes => ([ 0.1 ].pack('d').length)},
      :format => {:type => :varchar, :options => {:size => 40, :default => "", :null => false}, :bytes => 40},
      :length => {:type => :integer, :options => {:default => 0}, :bytes => ([ -1 ].pack('l!').length)}
      },
    :binary_page => {
      :dbid => {:type => :integer, :options => {:unique => true, :primary_key => true, :auto_increment => true}, :bytes => ([ -1 ].pack('l!').length)},
      :parent_uuid => {:type => :varchar, :options => {:size => 40, :default => "", :null => false}, :bytes => 40},
      :ordinal => {:type => :integer, :options => {:default => 0}, :bytes => ([ -1 ].pack('l!').length)},
      :length => {:type => :integer, :options => {:default => 0}, :bytes => ([ -1 ].pack('l!').length)},
      :content => {:type => :blob, :options => {:size => 65536}, :bytes => 65536}
      },
    :element_array => {
      :dbid => {:type => :integer, :options => {:unique => true, :primary_key => true, :auto_increment => true}, :bytes => ([ -1 ].pack('l!').length)},
      :uuid => {:type => :varchar, :options => {:size => 40, :default => "", :null => false}, :bytes => 40},
      :constraint => {:type => :varchar, :options => {:size => 40, :default => "", :null => false}, :bytes => 40},
      :title => {:type => :varchar, :options => {:size => 259, :null => false, :default => "Untitled"}, :bytes => 259},
      :version => {:type => :float, :options => {:default => 0.0}, :bytes => ([ 0.1 ].pack('d').length)}
      },
    :array_elements => {
      :dbid => {:type => :integer, :options => {:unique => true, :primary_key => true, :auto_increment => true}, :bytes => ([ -1 ].pack('l!').length)},
      :parent_uuid => {:type => :varchar, :options => {:size => 40, :default => "", :null => false}, :bytes => 40},
      :ordinal => {:type => :integer, :options => {:default => 0}, :bytes => ([ -1 ].pack('l!').length)},
      :version => {:type => :float, :options => {:default => 0.0}, :bytes => ([ 0.1 ].pack('d').length)},
      :element => {:type => :varchar, :options => {:size => 259, :default => "element_boolean", :null => false}, :bytes => 259},
      :element_boolean => {:type => :integer, :options => {:size => 1, :default => -1}, :bytes => ([ -1 ].pack('l!').length)},
      :element_integer => {:type => :integer, :options => {}, :bytes => ([ -1 ].pack('l!').length)},
      :element_float => {:type => :float, :options => {:default => 0.0}, :bytes => ([ 0.1 ].pack('d').length)},
      :element_bigdecimal => {:type => :numeric, :options => {:default => ::BigDecimal.new("0.0")}, :bytes => 256},
      :element_datetime => {:type => :datetime, :options => {}, :bytes => 16},
      :time_offset => {:type => :float, :options => {:default => 0.0}, :bytes => ([ 0.1 ].pack('d').length)},
      :time_prior => {:type => :float, :options => {:default => 0.0}, :bytes => ([ 0.1 ].pack('d').length)},
      :time_after => {:type => :float, :options => {:default => 0.0}, :bytes => ([ 0.1 ].pack('d').length)},
      :length => {:type => :integer, :options => {:default => 0}, :bytes => ([ -1 ].pack('l!').length)},
      :element_text => {:type => :varchar, :options => {:size => 259, :default => "", :null => false}, :bytes => 259},
      :element_text_uuid => {:type => :varchar, :options => {:size => 40, :default => "", :null => false}, :bytes => 40},
      :element_binary_uuid => {:type => :varchar, :options => {:size => 40, :default => "", :null => false}, :bytes => 40},
      :element_array_uuid => {:type => :varchar, :options => {:size => 40, :default => "", :null => false}, :bytes => 40},
      :element_hash_uuid => {:type => :varchar, :options => {:size => 40, :default => "", :null => false}, :bytes => 40}
    },
    :element_hash => {
      :dbid => {:type => :integer, :options => {:unique => true, :primary_key => true, :auto_increment => true}, :bytes => ([ -1 ].pack('l!').length)},
      :uuid => {:type => :varchar, :options => {:size => 40, :default => "", :null => false}, :bytes => 40},
      :format => {:type => :varchar, :options => {:size => 40, :default => "", :null => false}, :bytes => 40},
      :title => {:type => :varchar, :options => {:size => 259, :null => false, :default => "Untitled"}, :bytes => 259},
      :version => {:type => :float, :options => {:default => 0.0}, :bytes => ([ 0.1 ].pack('d').length)}
      },
    :hash_properties => {
      :dbid => {:type => :integer, :options => {:unique => true, :primary_key => true, :auto_increment => true}, :bytes => ([ -1 ].pack('l!').length)},
      :parent_uuid => {:type => :varchar, :options => {:size => 40, :default => "", :null => false}, :bytes => 40},
      :property => {:type => :varchar, :options => {:size => 259, :default => "", :null => false}, :bytes => 259},
      :ordinal => {:type => :integer, :options => {:default => 0}, :bytes => ([ -1 ].pack('l!').length)},
      :version => {:type => :float, :options => {:default => 0.0}, :bytes => ([ 0.1 ].pack('d').length)},
      :element => {:type => :varchar, :options => {:size => 259, :default => "element_boolean", :null => false}, :bytes => 259},
      :element_boolean => {:type => :integer, :options => {:size => 1, :default => -1}, :bytes => ([ -1 ].pack('l!').length)},
      :element_integer => {:type => :integer, :options => {}, :bytes => ([ -1 ].pack('l!').length)},
      :element_float => {:type => :float, :options => {:default => 0.0}, :bytes => ([ 0.1 ].pack('d').length)},
      :element_bigdecimal => {:type => :numeric, :options => {:default => ::BigDecimal.new("0.0")}, :bytes => 256},
      :element_datetime => {:type => :datetime, :options => {}, :bytes => 16},
      :time_offset => {:type => :float, :options => {:default => 0.0}, :bytes => ([ 0.1 ].pack('d').length)},
      :time_prior => {:type => :float, :options => {:default => 0.0}, :bytes => ([ 0.1 ].pack('d').length)},
      :time_after => {:type => :float, :options => {:default => 0.0}, :bytes => ([ 0.1 ].pack('d').length)},
      :length => {:type => :integer, :options => {:default => 0}, :bytes => ([ -1 ].pack('l!').length)},
      :element_text => {:type => :varchar, :options => {:size => 259, :default => "", :null => false}, :bytes => 259},
      :element_text_uuid => {:type => :varchar, :options => {:size => 40, :default => "", :null => false}, :bytes => 40},
      :element_binary_uuid => {:type => :varchar, :options => {:size => 40, :default => "", :null => false}, :bytes => 40},
      :element_array_uuid => {:type => :varchar, :options => {:size => 40, :default => "", :null => false}, :bytes => 40},
      :element_hash_uuid => {:type => :varchar, :options => {:size => 40, :default => "", :null => false}, :bytes => 40}
    },
    :element_locks => {
      :dbid => {:type => :integer, :options => {:unique => true, :primary_key => true, :auto_increment => true}, :bytes => ([ -1 ].pack('l!').length)},
      :type => {:type => :varchar, :options => {:size => 40,:default => "", :null => false}, :bytes => 40},
      :reservation => {:type => :varchar, :options => {:size => 40, :default => "", :null => false}, :bytes => 40},
      :credential => {:type => :varchar, :options => {:size => 40, :default => "", :null => false}, :bytes => 40},
      :element_table => {:type => :varchar, :options => {:size => 259, :default => "", :null => false}, :bytes => 259},
      :elementid => {:type => :integer, :options => {:default => 0}, :bytes => ([ -1 ].pack('l!').length)}
    },
    :trash => {
      :dbid => {:type => :integer, :options => {:unique => true, :primary_key => true, :auto_increment => true}, :bytes => ([ -1 ].pack('l!').length)},
      :element_table => {:type => :varchar, :options => {:size => 259, :default => "", :null => false}, :bytes => 259},
      :elementid => {:type => :integer, :options => {:default => 0}, :bytes => ([ -1 ].pack('l!').length)}
    },
    :users => {
      :dbid => {:type => :integer, :options => {:unique => true, :primary_key => true, :auto_increment => true}, :bytes => ([ -1 ].pack('l!').length)},
      :uuid => {:type => :varchar, :options => {:size => 40, :default => "", :null => false}, :bytes => 40},
      :user_id => {:type => :varchar, :options => {:size => 259, :null => false, :default => ""}, :bytes => 259},
      :password_hash => {:type => :varchar, :options => {:size => 259, :null => false, :default => ""}, :bytes => 259},
      :version => {:type => :float, :options => {:default => 0.0}, :bytes => ([ 0.1 ].pack('d').length)}
    },
    :roles => {
      :dbid => {:type => :integer, :options => {:unique => true, :primary_key => true, :auto_increment => true}, :bytes => ([ -1 ].pack('l!').length)},
      :uuid => {:type => :varchar, :options => {:size => 40, :default => "", :null => false}, :bytes => 40},
      :group_uuid => {:type => :varchar, :options => {:size => 40, :default => "", :null => false}, :bytes => 40},
      :seo => {:type => :varchar, :options => {:size => 259, :default => "", :null => false}, :bytes => 259},
      :title => {:type => :varchar, :options => {:size => 259, :default => "", :null => false}, :bytes => 259},
      :version => {:type => :float, :options => {:default => 0.0}, :bytes => ([ 0.1 ].pack('d').length)}
    },
    :user_roles => {
      :dbid => {:type => :integer, :options => {:unique => true, :primary_key => true, :auto_increment => true}, :bytes => ([ -1 ].pack('l!').length)},
      :user_uuid => {:type => :varchar, :options => {:size => 40, :default => "", :null => false}, :bytes => 40},
      :role_uuid => {:type => :varchar, :options => {:size => 40, :default => "", :null => false}, :bytes => 40},
      :version => {:type => :float, :options => {:default => 0.0}, :bytes => ([ 0.1 ].pack('d').length)}
    },
    :groups => {
      :dbid => {:type => :integer, :options => {:unique => true, :primary_key => true, :auto_increment => true}, :bytes => ([ -1 ].pack('l!').length)},
      :uuid => {:type => :varchar, :options => {:size => 40, :default => "", :null => false}, :bytes => 40},
      :parent_uuid => {:type => :varchar, :options => {:size => 40, :default => "", :null => false}, :bytes => 40},
      :default_role => {:type => :varchar, :options => {:size => 40, :default => "", :null => false}, :bytes => 40},
      :seo => {:type => :varchar, :options => {:size => 259, :default => "", :null => false}, :bytes => 259},
      :title => {:type => :varchar, :options => {:size => 259, :default => "", :null => false}, :bytes => 259},
      :version => {:type => :float, :options => {:default => 0.0}, :bytes => ([ 0.1 ].pack('d').length)}
    },
    :permissions => {
      :dbid => {:type => :integer, :options => {:unique => true, :primary_key => true, :auto_increment => true}, :bytes => ([ -1 ].pack('l!').length)},
      :credential => {:type => :varchar, :options => {:size => 40, :default => "", :null => false}, :bytes => 40},
      :execute => {:type => :integer, :options => {:default => 0}, :bytes => ([ -1 ].pack('l!').length)},
      :rename => {:type => :integer, :options => {:default => 0}, :bytes => ([ -1 ].pack('l!').length)},
      :move => {:type => :integer, :options => {:default => 0}, :bytes => ([ -1 ].pack('l!').length)},
      :destroy => {:type => :integer, :options => {:default => 0}, :bytes => ([ -1 ].pack('l!').length)},
      :create => {:type => :integer, :options => {:default => 0}, :bytes => ([ -1 ].pack('l!').length)},
      :write => {:type => :integer, :options => {:default => 0}, :bytes => ([ -1 ].pack('l!').length)},
      :read => {:type => :integer, :options => {:default => 0}, :bytes => ([ -1 ].pack('l!').length)},
      :element_table => {:type => :varchar, :options => {:size => 259, :default => "", :null => false}, :bytes => 259},
      :elementid => {:type => :integer, :options => {:default => 0}, :bytes => ([ -1 ].pack('l!').length)},
      :version => {:type => :float, :options => {:default => 0.0}, :bytes => ([ 0.1 ].pack('d').length)}
    },
    :file_permissions => {
      :dbid => {:type => :integer, :options => {:unique => true, :primary_key => true, :auto_increment => true}, :bytes => ([ -1 ].pack('l!').length)},
      :file_id => {:type => :varchar, :options => {:size => 40, :default => "", :null => false}, :bytes => 40},
      :credential => {:type => :varchar, :options => {:size => 40, :default => "", :null => false}, :bytes => 40},
      :execute => {:type => :integer, :options => {:default => 0}, :bytes => ([ -1 ].pack('l!').length)},
      :rename => {:type => :integer, :options => {:default => 0}, :bytes => ([ -1 ].pack('l!').length)},
      :move => {:type => :integer, :options => {:default => 0}, :bytes => ([ -1 ].pack('l!').length)},
      :destroy => {:type => :integer, :options => {:default => 0}, :bytes => ([ -1 ].pack('l!').length)},
      :create => {:type => :integer, :options => {:default => 0}, :bytes => ([ -1 ].pack('l!').length)},
      :write => {:type => :integer, :options => {:default => 0}, :bytes => ([ -1 ].pack('l!').length)},
      :read => {:type => :integer, :options => {:default => 0}, :bytes => ([ -1 ].pack('l!').length)},
      :version => {:type => :float, :options => {:default => 0.0}, :bytes => ([ 0.1 ].pack('d').length)}
    },
    :formats => {
      :dbid => {:type => :integer, :options => {:unique => true, :primary_key => true, :auto_increment => true}, :bytes => ([ -1 ].pack('l!').length)},
      :uuid => {:type => :varchar, :options => {:size => 40, :default => "", :null => false}, :bytes => 40},
      :type => {:type => :varchar, :options => {:size => 40, :null => false, :default => "structure"}, :bytes => 40},
      :ufs => {:type => :varchar, :options => {:size => 4099, :default => "", :null => false}, :bytes => 4099},
      :title => {:type => :varchar, :options => {:size => 259, :default => "", :null => false}, :bytes => 259},
      :version => {:type => :float, :options => {:default => 0.0}, :bytes => ([ 0.1 ].pack('d').length)},
      :mime_types => {:type => :varchar, :options => {:size => 4099, :default => "", :null => false}, :bytes => 4099}
    },
    :settings => {
      :dbid => {:type => :integer, :options => {:unique => true, :primary_key => true, :auto_increment => true}, :bytes => ([ -1 ].pack('l!').length)},
      :uuid => {:type => :varchar, :options => {:size => 40, :default => "", :null => false}, :bytes => 40},
      :title => {:type => :varchar, :options => {:size => 259, :default => "", :null => false}, :bytes => 259},
      :version => {:type => :float, :options => {:default => 0.0}, :bytes => ([ 0.1 ].pack('d').length)}
    }
  }
end

# File lib/gxg/gxg_database.rb, line 435
def db_permissions
  @base_permissions.clone
end

# File lib/gxg/gxg_database.rb, line 439
def db_register(the_db)
  if the_db.is_a?(::GxG::Database::Database)
    unless @db_list.find_index(the_db)
      @db_list << the_db
    end
  end
end

# File lib/gxg/gxg_database.rb, line 447
def db_unregister(the_db)
  if the_db.is_a?(::GxG::Database::Database)
    if @db_list.find_index(the_db)
      @db_list.delete_at(@db_list.find_index(the_db))
    end
  end
end

# File lib/gxg/gxg_database.rb, line 2457
def destroy_by_uuid(credential=nil, the_uuid=nil)
  # Review : rewrite - in use
  # element_destroy(credential=nil,table=:unspecified,dbid=0, options={})
  # .effective_uuid_permission(data["location"].to_s.to_sym,@credential)
  result = false
  begin
    if self.alive?
      if self.open?
        if self.db_permissions()[:destroy] == true
          if ::GxG::valid_uuid?(credential)
            found = @connector[:element_hash].select(:dbid, :uuid).filter({:uuid => the_uuid.to_s}).first
            if found
              self.element_destroy(credential, :element_hash,(found[:dbid]))
              result = true
            else
              found = @connector[:element_array].select(:dbid, :uuid).filter({:uuid => the_uuid.to_s}).first
              if found
                self.element_destroy(credential, :element_array,(found[:dbid]))
                result = true
              end
            end
          else
            raise ArgumentError, "You must supply a valid credential UUID (as a String or Symbol)"
          end
        end
      end
    end
  rescue Exception => the_error
    log_error({:error => the_error, :parameters => {:credential => (credential), :uuid => (the_uuid)}})
  end
  result
end

# File lib/gxg/gxg_database.rb, line 1861
def destroy_vfs_permission(file_id=nil, credential=nil)
  result = false
  begin
    unless self.alive?
      raise Exception, "Database inactive"
    end
    unless self.open?
      raise Exception, "Database not available"
    end
    unless file_id.is_a?(::String)
      raise ArgumentError, "file_id must be specified with a String"
    end
    # ### Review : make more efficient
    if credential
      unless ::GxG::valid_uuid?(credential)
        raise ArgumentError, "You must specify a valid credential UUID (as a String or Symbol)"
      end
      record = @connector[:file_permissions].filter({:file_id => file_id.to_s, :credential => credential.to_s}).first
      if record
        @connector[:file_permissions].filter({:file_id => file_id.to_s, :credential => credential.to_s}).delete
      end
    else
      record = @connector[:file_permissions].filter({:file_id => file_id.to_s}).first
      if record
        @connector[:file_permissions].filter({:file_id => file_id.to_s}).delete
      end
    end
    result = true
  rescue Exception => the_error
    log_error({:error => the_error, :parameters => {:file_id => (file_id), :credential => (credential)}})
  end
  result
end

# File lib/gxg/gxg_database.rb, line 1895
def effective_element_permission(table=:unspecified, dbid=0, credential=nil)
  result = {:execute => false, :rename => false, :move => false, :destroy => false, :create => false, :write => false, :read => false}
  begin
    unless self.alive?
      raise Exception, "Database inactive"
    end
    unless self.open?
      raise Exception, "Database not available"
    end
    unless dbid.is_a?(::Integer)
      raise ArgumentError, "dbid must be specified with a Integer"
    end
    unless ::GxG::valid_uuid?(credential)
      raise ArgumentError, "You must specify a valid credential UUID (as a String or Symbol)"
    end
    if table.is_a?(::Integer)
      table = ::GxG::Database::Database::element_table_by_index(table)
    end
    # Review : change in permission policy
    # if [:element_boolean, :element_integer, :element_float, :element_bigdecimal, :element_datetime, :element_text, :element_binary, :element_array, :element_hash].include?(table)
    if [:element_array, :element_hash].include?(table)
      # is credential a user or role?
      raw_permissions = []
      # Include PUBLIC credential
      credentials = ["00000000-0000-4000-0000-000000000000"]
      #
      if self.user_exist?(credential)
        credentials << credential
        role_list = self.user_roles(credential)
        role_list.each do |entry|
          credentials << entry[:credential]
        end
        #
      else
        if self.role_exist?(credential)
          credentials << credential
        else
          raise ArgumentError, "Invalid credential.  It is neither a user nor a role UUID"
        end
      end
      credentials.each do |entry|
        manifest = @connector[:permissions].filter({:credential => (entry.to_s), :element_table => (table.to_s), :elementid => (dbid)})
        manifest.each do |record|
          new_permission = {:execute => false, :rename => false, :move => false, :destroy => false, :create => false, :write => false, :read => false}
          [:execute, :rename, :move, :destroy, :create, :write, :read].each do |the_permission|
            if record[(the_permission)] == 1
              new_permission[(the_permission)] = true
            end
          end
          raw_permissions << new_permission
        end
      end
      permission = {:execute => false, :rename => false, :move => false, :destroy => false, :create => false, :write => false, :read => false}
      raw_permissions.each do |entry|
        [:execute, :rename, :move, :destroy, :create, :write, :read].each do |the_permission|
          if entry[(the_permission)]
            permission[(the_permission)] = true
          end
        end
      end
      db_limits = self.db_permissions()
      [:execute, :rename, :move, :destroy, :create, :write, :read].each do |the_permission|
        if db_limits[(the_permission)] and permission[(the_permission)]
          result[(the_permission)] = true
        end
      end
      #
    else
      raise ArgumentError, "Invalid table specified"
    end
  rescue Exception => the_error
    log_error({:error => the_error, :parameters => {:table => (table), :dbid => (dbid), :credential => (credential)}})
  end
  result
end

# File lib/gxg/gxg_database.rb, line 1971
def  effective_uuid_permission(uuid=nil, credential=nil)
  result = nil
  begin
    if self.alive?
      if self.open?
        address = nil
        record = @connector[:element_hash].filter({:uuid => (uuid.to_s)}).first
        if record
          address = {:database => self, :table => :element_hash, :dbid => (record[:dbid])}
        else
          record = @connector[:element_array].filter({:uuid => (uuid.to_s)}).first
          if record
            address = {:database => self, :table => :element_array, :dbid => (record[:dbid])}
          end
        end
        if address
          result = self.effective_element_permission(address[:table], address[:dbid], credential)
        else
          # ### Review : Experimental Code - attempt to seemlessly integrate dbs of different roles into in-memory structures.
          already_checked = [(self)]
          ::GxG::DB[:roles].each_pair do |the_db_role, the_database|
            unless already_checked.include?(the_database)
              record = the_database.connector[:element_hash].filter({:uuid => (uuid.to_s)}).first
              if record
                address = {:database => the_database, :table => :element_hash, :dbid => (record[:dbid])}
                result = the_database.effective_element_permission(address[:table], address[:dbid], credential)
                break
              else
                record = the_database.connector[:element_array].filter({:uuid => (uuid.to_s)}).first
                if record
                  address = {:database => the_database, :table => :element_array, :dbid => (record[:dbid])}
                  result = the_database.effective_element_permission(address[:table], address[:dbid], credential)
                  break
                end
              end
              already_checked << the_database
            end
          end
          #
        end
      else
        raise Exception, "Database not available"
      end
    else
      raise Exception, "Database not available (defunct)"
    end
  rescue Exception => the_error
    log_error({:error => the_error, :parameters => {:uuid => (uuid), :credential => (credential)}})
  end
  result
end

# File lib/gxg/gxg_database.rb, line 1710
def effective_vfs_permission(file_id=nil, credential=nil)
  result = {:execute => false, :rename => false, :move => false, :destroy => false, :create => false, :write => false, :read => false}
  begin
    unless self.alive?
      raise Exception, "Database inactive"
    end
    unless self.open?
      raise Exception, "Database not available"
    end
    unless file_id.is_a?(::String)
      raise ArgumentError, "file_id must be specified with a String"
    end
    unless ::GxG::valid_uuid?(credential)
      raise ArgumentError, "You must specify a valid credential UUID (as a String or Symbol)"
    end
    # ### VFS Permissions
    raw_permissions = []
    credentials = ["00000000-0000-4000-0000-000000000000"]
    if self.user_exist?(credential)
      credentials << credential
      role_list = self.user_roles(credential)
      role_list.each do |entry|
        credentials << entry[:credential]
      end
      #
    else
      if self.role_exist?(credential)
        credentials << credential
      else
        raise ArgumentError, "Invalid credential.  It is neither a user nor a role UUID"
      end
    end
    credentials.each do |entry|
      manifest = @connector[:file_permissions].filter({:file_id => file_id.to_s, :credential => (entry.to_s)})
      manifest.each do |record|
        new_permission = {:execute => false, :rename => false, :move => false, :destroy => false, :create => false, :write => false, :read => false}
        [:execute, :rename, :move, :destroy, :create, :write, :read].each do |the_permission|
          if record[(the_permission)] == 1
            new_permission[(the_permission)] = true
          end
        end
        raw_permissions << new_permission
      end
    end
    raw_permissions.each do |entry|
      [:execute, :rename, :move, :destroy, :create, :write, :read].each do |the_permission|
        if entry[(the_permission)]
          result[(the_permission)] = true
        end
      end
    end
  rescue Exception => the_error
    log_error({:error => the_error, :parameters => {:file_id => (file_id), :credential => (credential)}})
  end
  result
end

# File lib/gxg/gxg_database.rb, line 2490
def element_byte_size(table=:unspecified, dbid=0)
  #
  result = 0
  begin
    if self.alive?
      if self.open?
        migration = self.db_migration()
        elements = self.element_manifest(table, dbid, true)
        elements.each do |entry|
          table_definition = migration[(entry[:table])]
          if table_definition
            table_definition.keys.each do |the_field|
              result += table_definition[(the_field)][:bytes].to_i
            end
          end
        end
      end
    end
  rescue Exception => the_error
    log_error({:error => the_error, :parameters => {:table => (table), :dbid => (dbid)}})
  end
  result
end

# File lib/gxg/gxg_database.rb, line 2090
def element_create(the_table=:unspecified, the_record=nil)
  # Review : rewrite - in use
  result = nil
  begin
    unless the_table.is_a?(::Symbol)
      raise ArgumentError, "You MUST provide the table specifier as a Symbol."
    end
    unless the_record.is_a?(::Hash)
      raise ArgumentError, "You MUST provide a record in the form of a Hash."
    end
    if [:element_boolean, :element_integer, :element_float, :element_bigdecimal, :element_datetime, :element_text, :text_page, :element_binary, :binary_page, :element_array, :element_hash].include?(the_table)
      # Review : UTF8 fix
      begin
        result = @connector[(the_table)].insert(the_record)
      rescue Exception
        if the_table == :text_page
          the_record[:content] = the_record[:content].encode64
        end
        result = @connector[(the_table)].insert(the_record)
      end
    else
      raise ArgumentError, "The table specified is unknown - Check your code."
    end
  rescue Exception => the_error
    log_error({:error => the_error, :parameters => {:table => (the_table), :record => (the_record)}})
  end
  result
end

# File lib/gxg/gxg_database.rb, line 2401
def element_destroy(credential=nil,table=:unspecified,dbid=0, options={})
  # Review : rewrite for new arch.
  # Review : rewrite - in use
  result = false
  begin
    if self.alive?
      if self.open?
        if self.db_permissions()[:write]
          # if credential has :destroy permission on this element?
          if ::GxG::valid_uuid?(credential)
            if [:persisted_array, :persisted_hash].include?(table.to_s.to_sym)
              go_ahead = self.effective_element_permission(table, dbid, credential)[:destroy]
            else
              go_ahead = true
            end
            # xxx Quick fix : BETA: clean all this up!
            if go_ahead
              # Review : DB overhaul / rewrite - allow delete if object has write lock in place? I think not. (return false)
              # Note: BETA - bring back read-locks? it was 9x slower with them ... not sure.
              elements = self.element_manifest(table, dbid, false)
              elements.each do |entry|
                #
                unless self.element_in_trash?(entry[:table], entry[:dbid])
                  @connector[:trash].insert({:element_table => entry[:table].to_s, :elementid => entry[:dbid]})
                end
                #
                #if @connector[:element_locks].filter({:type => "read", :element_table => entry[:table].to_s, :elementid => entry[:dbid]}).count > 0
                  # put in trash
                  #unless self.element_in_trash?(entry[:table], entry[:dbid])
                    #@connector[:trash].insert({:element_table => entry[:table].to_s, :elementid => entry[:dbid]})
                  #end
                #else
                  # delete now
                  #manifest = self.element_manifest(entry[:table], entry[:dbid], true)
                  #manifest.each do |item|
                    #@connector[:permissions].filter({:element_table => (item[:table].to_s), :elementid => (item[:dbid])}).delete
                    #@connector[(item[:table])].filter({:dbid => item[:dbid]}).delete
                  #end
                #end
              end
              result = true
            else
              raise Exception, "You do not have permission to destory this element"
            end
          else
            raise ArgumentError, "You must supply a valid credential UUID (as a String or Symbol)"
          end
        end
      end
    end
  rescue Exception => the_error
    log_error({:error => the_error, :parameters => {:credential => (credential), :table => (table), :dbid => (dbid)}})
  end
  result
end

# File lib/gxg/gxg_database.rb, line 2024
def element_exists?(the_table=:unspecified, the_dbid=0)
  result = false
  if the_table.is_a?(::Integer)
    the_table = ::GxG::Database::Database::element_table_by_index(the_table)
  end
  if [:element_boolean, :element_integer, :element_float, :element_bigdecimal, :element_datetime, :element_text, :element_binary, :element_array, :element_hash].include?(the_table)
    begin
      record = @connector[(the_table)].select(:dbid).where({:dbid => (the_dbid)}).first
      if record
        result = true
      end
    rescue Exception => the_error
      log_error({:error => the_error, :parameters => {:table => (the_table), :dbid => (the_dbid)}})
    end
  end
  result
end

# File lib/gxg/gxg_database.rb, line 3021
def element_in_trash?(table=:unspecified, dbid=0)
  result = false
  begin
    if self.alive?
      if self.open?
        if @connector[:trash].filter({:element_table => table.to_s, :elementid => dbid}).count > 0
          result = true
        end
      end
    end
  rescue Exception => the_error
    log_error({:error => the_error, :parameters => {:table => (table), :dbid => (dbid)}})
  end
  result
end

# File lib/gxg/gxg_database.rb, line 2211
def element_in_use?(db_table=:unspecified, dbid = 0)
  # Review : rewrite - in use for now.
  # Review : rewrite - todo (alter to reflect the new architecture : perhaps limit to structures only)
  unless db_table.is_any?(::Integer, ::Symbol)
    raise ArgumentError, "Table needs to be specified as a Symbol, or a table code Integer"
  end
  unless dbid.is_a?(::Integer)
    raise ArgumentError, "Record ID needs to be specified with an Integer"
  end
  result = false
  begin
    if db_table == :element_hash || db_table == :element_array
      # Review : make more efficient in later revs of this.
      the_record = @connector[(db_table)].filter({:dbid => (dbid)}).select(:uuid).first
      if the_record
        if @connector[:hash_properties].filter({:element_hash_uuid => the_record[:uuid]}).count > 0 || @connector[:array_elements].filter({:element_array_uuid => the_record[:uuid]}).count > 0
          result = true
        end
      end
    end
  rescue Exception => the_error
    log_error({:error => the_error, :parameters => {:table_code => (db_table), :dbid => (dbid)}})
  end
  result
end

# File lib/gxg/gxg_database.rb, line 2263
def element_manifest(the_table=:unspecified, the_dbid=0, everything=false)
  # Review : rewrite - in use
  # returns an Array of tables and dbid pairs and sub-item pairs if they exist
  result = []
  #
  begin
    unless the_dbid > 0
      raise ArgumentError, "dbid specified must be greater than zero"
    end
    case the_table
    when :element_text
      the_record = @connector[:element_text].select(:uuid, :dbid).where({:dbid => (the_dbid)}).first
      if the_record
        result << {:table => :element_text, :dbid => the_record[:dbid]}
        if everything
          the_pages = @connector[:text_page].select(:dbid, :ordinal).where({:parent_uuid => (the_record[:uuid])}).order(:ordinal)
          the_pages.each do |entry|
            result << {:table => :text_page, :dbid => entry[:dbid]}
          end
        end
      end
    when :element_binary
      the_record = @connector[:element_binary].select(:uuid, :dbid).where({:dbid => (the_dbid)}).first
      if the_record
        result << {:table => :element_binary, :dbid => the_record[:dbid]}
        if everything
          the_pages = @connector[:binary_page].select(:dbid, :ordinal).where({:parent_uuid => (the_record[:uuid])}).order(:ordinal)
          the_pages.each do |entry|
            result << {:table => :binary_page, :dbid => entry[:dbid]}
          end
        end
      end
    when :element_array, :element_hash
      record_db = [{:table => the_table, :dbid => the_dbid}]
      while record_db.size > 0 do
        item = record_db.shift
        case item[:table]
        when :element_text
          the_record = @connector[:element_text].select(:uuid, :dbid).where({:dbid => item[:dbid]}).first
          if the_record
            result << {:table => :element_text, :dbid => the_record[:dbid]}
            if everything
              the_pages = @connector[:text_page].select(:dbid, :ordinal).where({:parent_uuid => (the_record[:uuid])}).order(:ordinal)
              the_pages.each do |entry|
                result << {:table => :text_page, :dbid => entry[:dbid]}
              end
            end
          end
        when :element_binary
          the_record = @connector[:element_binary].select(:uuid, :dbid).where({:dbid => item[:dbid]}).first
          if the_record
            result << {:table => :element_binary, :dbid => the_record[:dbid]}
            if everything
              the_pages = @connector[:binary_page].select(:dbid, :ordinal).where({:parent_uuid => (the_record[:uuid])}).order(:ordinal)
              the_pages.each do |entry|
                result << {:table => :binary_page, :dbid => entry[:dbid]}
              end
            end
          end
        when :element_array
          result << {:table => item[:table], :dbid => item[:dbid]}
          array_record = @connector[:element_array].select(:uuid).where({:dbid => item[:dbid]}).first
          if array_record
            @connector[:array_elements].filter({:parent_uuid => (array_record[:uuid])}).order(:ordinal).each do |entry|
              if entry[:element_text_uuid].size > 0
                the_temp_record = @connector[:element_text].select(:dbid).where({:uuid => entry[:element_text_uuid]}).first
                if the_temp_record
                  record_db << {:table => :element_text, :dbid => the_temp_record[:dbid]}
                end
              end
              if entry[:element_binary_uuid].size > 0
                the_temp_record = @connector[:element_binary].select(:dbid).where({:uuid => entry[:element_binary_uuid]}).first
                if the_temp_record
                  record_db << {:table => :element_binary, :dbid => the_temp_record[:dbid]}
                end
              end
              if entry[:element_array_uuid].size > 0
                the_temp_record = @connector[:element_array].select(:dbid).where({:uuid => entry[:element_array_uuid]}).first
                if the_temp_record
                  record_db << {:table => :element_array, :dbid => the_temp_record[:dbid]}
                end
              end
              if entry[:element_hash_uuid].size > 0
                the_temp_record = @connector[:element_hash].select(:dbid).where({:uuid => entry[:element_hash_uuid]}).first
                if the_temp_record
                  record_db << {:table => :element_hash, :dbid => the_temp_record[:dbid]}
                end
              end
              result << {:table => :array_elements, :dbid => entry[:dbid]}
            end
          end
        when :element_hash
          result << {:table => item[:table], :dbid => item[:dbid]}
          hash_record = @connector[:element_hash].select(:uuid).where({:dbid => item[:dbid]}).first
          if hash_record
            @connector[:hash_properties].filter({:parent_uuid => (hash_record[:uuid])}).order(:ordinal).each do |entry|
              if entry[:element_text_uuid].size > 0
                the_temp_record = @connector[:element_text].select(:dbid).where({:uuid => entry[:element_text_uuid]}).first
                if the_temp_record
                  record_db << {:table => :element_text, :dbid => the_temp_record[:dbid]}
                end
              end
              if entry[:element_binary_uuid].size > 0
                the_temp_record = @connector[:element_binary].select(:dbid).where({:uuid => entry[:element_binary_uuid]}).first
                if the_temp_record
                  record_db << {:table => :element_binary, :dbid => the_temp_record[:dbid]}
                end
              end
              if entry[:element_array_uuid].size > 0
                the_temp_record = @connector[:element_array].select(:dbid).where({:uuid => entry[:element_array_uuid]}).first
                if the_temp_record
                  record_db << {:table => :element_array, :dbid => the_temp_record[:dbid]}
                end
              end
              if entry[:element_hash_uuid].size > 0
                the_temp_record = @connector[:element_hash].select(:dbid).where({:uuid => entry[:element_hash_uuid]}).first
                if the_temp_record
                  record_db << {:table => :element_hash, :dbid => the_temp_record[:dbid]}
                end
              end
              result << {:table => :hash_properties, :dbid => entry[:dbid]}
            end
          end
        else
          the_record = @connector[(item[:table])].select(:dbid).where({:dbid => (item[:dbid])}).first
          if the_record
            result << {:table => item[:table], :dbid => item[:dbid]}
          end
        end
      end
      #
    end
  rescue Exception => the_error
    log_error({:error => the_error, :parameters => {:table => (the_table), :dbid => (the_dbid)}})
  end
  result
end

# File lib/gxg/gxg_database.rb, line 2237
def element_parent_address(the_table=:unspecified, the_dbid=0)
  result = nil
  if self.element_in_use?(the_table,the_dbid)
    begin
      link = @connector[:hash_links].select(:parent_uuid).where({:element => (::GxG::Database::Database::element_table_index(the_table)), :elementid => (the_dbid)}).first
      if link
        record = @connector[:element_hash].select(:dbid).where({:uuid => link[:parent_uuid]}).first
        if record
          result = {:table => :element_hash, :dbid => (record[:dbid])}
        end
      else
        link = @connector[:array_links].select(:parent_uuid).where({:element => (::GxG::Database::Database::element_table_index(the_table)), :elementid => (the_dbid)}).first
        if link
          record = @connector[:element_array].select(:dbid).where({:uuid => link[:parent_uuid]}).first
          if record
            result = {:table => :element_array, :dbid => (record[:dbid])}
          end
        end
      end
    rescue Exception => the_error
      log_error({:error => the_error, :parameters => {:table => (the_table), :dbid => (the_dbid)}})
    end
  end
  result
end

# File lib/gxg/gxg_database.rb, line 1345
def element_permissions(table=:unspecified, dbid=0, options={})
  result = []
  begin
    unless self.alive?
      raise Exception, "Database inactive"
    end
    unless self.open?
      raise Exception, "Database not available"
    end
    unless dbid.is_a?(::Integer)
      raise ArgumentError, "dbid must be specified with a Integer"
    end
    unless options.is_a?(::Hash)
      raise ArgumentError, "options must be specified with a Hash"
    end
    credential = options[:credential]
    if credential
      unless ::GxG::valid_uuid?(credential)
        raise ArgumentError, "This option requires a valid credential UUID (as a String or Symbol)"
      end
    end
    if table.is_a?(::Integer)
      table = ::GxG::Database::Database::element_table_by_index(table)
    end
    # Review : change in permission policy
    # if [:element_boolean, :element_integer, :element_float, :element_bigdecimal, :element_datetime, :element_text, :element_binary, :element_array, :element_hash].include?(table)
    if [:element_array, :element_hash].include?(table)
      if credential
        list = @connector[:permissions].filter({:element_table => (table.to_s), :elementid => (dbid), :credential => (credential.to_s)})
      else
        list = @connector[:permissions].filter({:element_table => (table.to_s), :elementid => (dbid)})
      end
      list.each do |record|
        # [:execute, :rename, :move, :destroy, :create, :write, :read]
        entry = {:credential => (record[:credential].to_sym), :table => (record[:element_table].to_sym), :dbid => (record[:elementid]), :permissions => {}}
        [:execute, :rename, :move, :destroy, :create, :write, :read].each do |the_permission|
          if record[(the_permission)] == 1
            entry[:permissions][(the_permission)] = true
          else
            entry[:permissions][(the_permission)] = false
          end
        end
        result << entry
      end
    else
      raise ArgumentError, "Invalid table specified"
    end
  rescue Exception => the_error
    log_error({:error => the_error, :parameters => {:table => (table), :dbid => (dbid), :options => (options)}})
  end
  result
end

# File lib/gxg/gxg_database.rb, line 1458
def element_permissions_by_uuid(the_uuid=nil,options={})
  result = []
  begin
    if self.alive?
      if self.open?
        found = @connector[:element_hash].select(:dbid, :uuid).filter({:uuid => the_uuid.to_s}).first
        if found
          result = self.element_permissions_manifest(:element_hash,(found[:dbid]),options)
        else
          found = @connector[:element_array].select(:dbid, :uuid).filter({:uuid => the_uuid.to_s}).first
          if found
            result = self.element_permissions_manifest(:element_array,(found[:dbid]),options)
          end
        end
      end
    end
  rescue Exception => the_error
    log_error({:error => the_error, :parameters => {:uuid => (the_uuid)}})
  end
  result
end

# File lib/gxg/gxg_database.rb, line 1431
def element_permissions_manifest(table=:unspecified, dbid=0, options={})
  result = []
  self.element_permissions(table,dbid,options).each do |entry|
    the_record = {:credential => nil, :permissions => {}, :details => {}}
    #
    the_record[:credential] = entry[:credential]
    the_record[:permissions] = entry[:permissions]
    if self.role_exist?(entry[:credential])
      role = self.role_fetch({:uuid => entry[:credential].to_s})
      group = self.group_fetch({:uuid => role[:group_uuid].to_s})
      the_record[:details][:role_title] = role[:title]
      the_record[:details][:group] = group[:uuid].to_s.to_sym
      the_record[:details][:group_title] = group[:title]
    else
      if self.user_exist?(entry[:credential])
        user = self.user_fetch({:uuid => entry[:credential].to_s})
        the_record[:details][:user_title] = user[:user_id]
      else
        log_warn("Invalid User Credential Detected: #{entry[:credential].to_s.to_sym.inspect}")
        the_record[:details][:user_title] = "Invalid User Credential #{entry[:credential].to_s.to_sym.inspect} !"
      end
    end
    result << the_record
  end
  result
end

# File lib/gxg/gxg_database.rb, line 3037
def element_recover(table=:unspecified, dbid=0)
  # recover an element from the trash
  result = false
  begin
    if self.alive?
      if self.open?
        if self.db_permissions()[:write]
          unless [:element_boolean, :element_integer, :element_float, :element_bigdecimal, :element_datetime, :element_text, :element_binary, :element_array, :element_hash].include?(table)
            raise ArgumentError, "Invalid table specified"
          end
          unless dbid > 0
            raise ArgumentError, "dbid must be greater than zero"
          end
          if self.element_in_trash?(table, dbid)
            scrub_list = []
            manifest = self.element_manifest(table, dbid)
            manifest.each do |entry|
              if @connector[:trash].filter({:element_table => (entry[:table].to_s), :elementid => (entry[:dbid])}).count > 0
                record = @connector[:trash].select(:dbid).where({:element_table => (entry[:table].to_s), :elementid => (entry[:dbid])}).first
                if record
                  scrub_list << record[:dbid]
                end
              end
            end
            scrub_list.each do |entry|
              @connector[:trash].filter({:dbid => entry}).delete
            end
            result = true
          else
            # it was never in the trash, so mission accomplished
            result = true
          end
        end
      end
    end
  rescue Exception => the_error
    log_error({:error => the_error, :parameters => {:table => (table), :dbid => (dbid)}})
  end
  result
end

# File lib/gxg/gxg_database.rb, line 2042
def element_retrieve(the_table=:unspecified, the_filter={}, options={})
  result = []
  begin
    if [:element_boolean, :element_integer, :element_float, :element_bigdecimal, :element_datetime, :element_text, :text_page, :element_binary,:binary_page, :element_array, :element_hash].include?(the_table)
      #
      if the_filter.is_a?(::Hash)
        if options[:order]
          raw_result = @connector[(the_table)].filter(the_filter).order(options[:order])
        else
          raw_result = @connector[(the_table)].filter(the_filter)
        end
        # Review : UTF-8 Encoding Error Fix
        if options[:single_record] == true
          result = raw_result.first
          # utf8 fix
          if the_table == :text_page
            if result[:content].is_a?(::String)
              if result[:content].base64?
                result[:content] = result[:content].decode64
              end
            end
          end
          #
        else
          # utf8 fix
          raw_result.each do |the_record|
            if the_record[:content].is_a?(::String)
              if the_record[:content].base64?
                the_record[:content] = the_record[:content].decode64
              end
            end
            result << the_record
          end
          # result = raw_result
        end
        #
      else
        raise ArguementError, "You MUST provide a record selection filter as a Hash. "
      end
    else
      raise ArgumentError, "The table specified is unknown - Check your code."
    end
  rescue Exception => the_error
    log_error({:error => the_error, :parameters => {:table => the_table, :filter => the_filter, :options => options}})
  end
  result
end

# File lib/gxg/gxg_database.rb, line 2119
def element_update(the_table=:unspecified, the_filter={}, the_record=nil)
  result = false
  begin
    unless the_table.is_a?(::Symbol)
      raise ArgumentError, "You MUST provide the table specifier as a Symbol."
    end
    unless the_filter.is_a?(::Hash)
      raise ArgumentError, "You MUST provide a selection filter in the form of a Hash."
    end
    unless the_record.is_a?(::Hash)
      raise ArgumentError, "You MUST provide a record in the form of a Hash."
    end
    if [:element_boolean, :element_integer, :element_float, :element_bigdecimal, :element_datetime, :element_text, :text_page, :element_binary, :binary_page, :element_array, :element_hash].include?(the_table)
      # Review : shim to eliminate UTF-8 encoding errors
      begin
        @connector[(the_table)].filter(the_filter).update(the_record)
      rescue Exception
        if the_table == :text_page
          the_record[:content] = the_record[:content].encode64
        end
        @connector[(the_table)].filter(the_filter).update(the_record)
      end
      result = true
    else
      raise ArgumentError, "The table specified is unknown - Check your code."
    end
  rescue Exception => the_error
    log_error({:error => the_error, :parameters => {:table => the_table, :filter => the_filter, :record => the_record}})
  end
  result
end

# File lib/gxg/gxg_database.rb, line 2986
def empty_trash()
  result = false
  begin
    if self.alive?
      if self.open?
        if self.db_permissions()[:write]
          scrub_list = []
          @connector[:trash].filter({}).each do |entry|
            the_table = entry[:element_table].to_sym
            the_dbid = entry[:elementid]
            if @connector[:element_locks].filter({:type => "write", :element_table => the_table.to_s, :elementid => the_dbid}).count == 0
              # delete full manifest
              manifest = self.element_manifest(the_table, the_dbid, true)
              manifest.each do |item|
                @connector[:permissions].filter({:element_table => (item[:table].to_s), :elementid => (item[:dbid])}).delete
                @connector[(item[:table])].filter({:dbid => item[:dbid]}).delete
              end
              scrub_list << entry[:dbid]
            end
          end
          scrub_list.each do |entry|
            @connector[:trash].filter({:dbid => entry}).delete
          end
          if @connector[:trash].filter({}).count == 0
            result = true
          end
        end
      end
    end
  rescue Exception => the_error
    log_error({:error => the_error})
  end
  result
end

# File lib/gxg/gxg_database.rb, line 3679
def enforce_permission_policy(event={})
  # Event format: enforce_permission_policy({:action => :extend, :credential => nil, :source => nil, :destination => nil})
  # Rule format: {:event => :create, :credential => :any, :action => {:extend_permissions => nil}}
  the_policy = self.permission_policy()
  result = false
  begin
    if self.alive?()
      if self.open?()
        actions = []
        the_policy.each do |rule|
          if event[:action] == rule[:event]
            if rule[:credential] == event[:credential] || rule[:credential] == :any
              actions << rule[:action]
            end
          end
        end
        actions.each do |action|
          case action.keys[0]
          when :extend_permissions
            if action[:use_permission].is_a?(::Hash)
              use_permission = action[:use_permission]
            else
              use_permission = nil
            end
            credential = event[:credential]
            unless ::GxG::valid_uuid?(credential)
              raise ArgumentError, "You MUST provide a valid UUID as :credential."
            end
            new_credential = action[:extend_permissions]
            source = event[:source]
            unless source.is_any?(::GxG::Database::PersistedHash, ::GxG::Database::PersistedArray)
              raise ArgumentError, "You MUST provide a persisted object as :source."
            end
            unless source.db_address
              raise Exception, "You provided a Deactivated object as :source."
            end
            destination = event[:destination]
            unless destination.is_any?(::GxG::Database::PersistedHash, ::GxG::Database::PersistedArray)
              raise ArgumentError, "You MUST provide a persisted object as :source."
            end
            unless destination.db_address
              raise Exception, "You provided a Deactivated object as :destination."
            end
            #
            permissions = self.element_permissions(source.db_address()[:table],source.db_address()[:dbid])
            permission_db = []
            if [:persisted_array, :persisted_hash].include?(destination.db_address()[:table])
              search_db = [{:table => destination.db_address()[:table], :dbid => destination.db_address()[:dbid]}]
              permission_db << {:table => destination.db_address()[:table], :dbid => destination.db_address()[:dbid]}
              while search_db.size > 0 do
                entry = search_db.shift
                self.element_manifest(entry[:table],entry[:dbid],false).each do |item|
                  if [:persisted_array, :persisted_hash].include?(item[:table])
                    search_db << item
                    permission_db << item
                  end
                end
              end
              permission_db.each do |the_reference|
                permissions.each do |record|
                  self.assign_element_permission(the_reference[:table],the_reference[:dbid], credential, record[:permissions])
                  if use_permission
                    self.assign_element_permission(the_reference[:table],the_reference[:dbid], new_credential, use_permission)
                  else
                    self.assign_element_permission(the_reference[:table],the_reference[:dbid], new_credential, record[:permissions])
                  end
                end
              end
              # destination.search do |the_value, the_selector, the_container|
              #   if [:persisted_array, :persisted_hash].include?(the_value.db_address()[:table])
              #     permission_db << {:table => the_value.db_address()[:table], :dbid => the_value.db_address()[:dbid]}
              #   end
              # end
              #
            end
            # permission_db << {:table => destination.db_address()[:table], :dbid => destination.db_address()[:dbid]}
            # if destination.is_any?(::GxG::Database::PersistedHash, ::GxG::Database::PersistedArray)
            #   destination.search do |the_value, the_selector, the_container|
            #     permission_db << {:table => the_value.db_address()[:table], :dbid => the_value.db_address()[:dbid]}
            #   end
            # end
            # permission_db.each do |item|
            #   self.element_manifest(item[:table],item[:dbid],false).each do |entry|
            #     permissions.each do |record|
            #       self.assign_element_permission(entry[:table],entry[:dbid], credential, record[:permissions])
            #       if use_permission
            #         self.assign_element_permission(entry[:table],entry[:dbid], new_credential, use_permission)
            #       else
            #         self.assign_element_permission(entry[:table],entry[:dbid], new_credential, record[:permissions])
            #       end
            #     end
            #   end
            # end
            #
          end
        end
        result = true
      else
        raise Exception, "Database not available"
      end
    else
      raise Exception, "Attempted to access a defunct Database"
    end
  rescue Exception => the_error
    log_error({:error => the_error, :parameters => {:event => event}})
  end
  result
end