Class: PLSQL::Type
- Inherits:
-
Object
- Object
- PLSQL::Type
- Extended by:
- TypeClassMethods
- Defined in:
- lib/plsql/type.rb
Defined Under Namespace
Classes: TypeProcedure
Instance Attribute Summary collapse
-
#attributes ⇒ Object
readonly
:nodoc:.
-
#schema_name ⇒ Object
readonly
:nodoc:.
-
#type_name ⇒ Object
readonly
:nodoc:.
-
#type_object_id ⇒ Object
readonly
:nodoc:.
-
#typecode ⇒ Object
readonly
:nodoc:.
Instance Method Summary collapse
-
#attribute_names ⇒ Object
list of object type attribute names.
-
#collection? ⇒ Boolean
is type collection?.
-
#find_procedure(new_or_procedure) ⇒ Object
:nodoc:.
-
#initialize(schema, type, override_schema_name = nil) ⇒ Type
constructor
:nodoc:.
-
#method_missing(method, *args, &block) ⇒ Object
:nodoc:.
-
#new(*args, &block) ⇒ Object
create new PL/SQL object instance.
Methods included from TypeClassMethods
Constructor Details
#initialize(schema, type, override_schema_name = nil) ⇒ Type
:nodoc:
39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 |
# File 'lib/plsql/type.rb', line 39 def initialize(schema, type, override_schema_name = nil) #:nodoc: @schema = schema @schema_name = override_schema_name || schema.schema_name @type_name = type.to_s.upcase @attributes = {} @type_procedures = {} @typecode, @type_object_id = @schema.select_first( "SELECT t.typecode, o.object_id FROM all_types t, all_objects o WHERE t.owner = :owner AND t.type_name = :type_name AND o.owner = t.owner AND o.object_name = t.type_name AND o.object_type = 'TYPE'", @schema_name, @type_name) @schema.select_all( "SELECT attr_name, attr_no, attr_type_name, length, precision, scale, attr_type_owner, attr_type_mod, (SELECT t.typecode FROM all_types t WHERE t.owner = attr_type_owner AND t.type_name = attr_type_name) typecode FROM all_type_attrs WHERE owner = :owner AND type_name = :type_name ORDER BY attr_no", @schema_name, @type_name ) do |r| attr_name, position, data_type, data_length, data_precision, data_scale, data_type_owner, data_type_mod, typecode = r @attributes[attr_name.downcase.to_sym] = { :position => position && position.to_i, :data_type => data_type_owner && (typecode == 'COLLECTION' ? 'TABLE' : 'OBJECT' ) || data_type, :data_length => data_type_owner ? nil : data_length && data_length.to_i, :data_precision => data_precision && data_precision.to_i, :data_scale => data_scale && data_scale.to_i, :type_owner => data_type_owner, :type_name => data_type_owner && data_type, :sql_type_name => data_type_owner && "#{data_type_owner}.#{data_type}" } end end |
Dynamic Method Handling
This class handles dynamic methods through the method_missing method
#method_missing(method, *args, &block) ⇒ Object
:nodoc:
111 112 113 114 115 116 117 |
# File 'lib/plsql/type.rb', line 111 def method_missing(method, *args, &block) #:nodoc: if procedure = find_procedure(method) procedure.(args, {}, &block) else raise ArgumentError, "No PL/SQL procedure '#{method.to_s.upcase}' found for type '#{@type_name}'" end end |
Instance Attribute Details
#attributes ⇒ Object (readonly)
:nodoc:
37 38 39 |
# File 'lib/plsql/type.rb', line 37 def attributes @attributes end |
#schema_name ⇒ Object (readonly)
:nodoc:
37 38 39 |
# File 'lib/plsql/type.rb', line 37 def schema_name @schema_name end |
#type_name ⇒ Object (readonly)
:nodoc:
37 38 39 |
# File 'lib/plsql/type.rb', line 37 def type_name @type_name end |
#type_object_id ⇒ Object (readonly)
:nodoc:
37 38 39 |
# File 'lib/plsql/type.rb', line 37 def type_object_id @type_object_id end |
#typecode ⇒ Object (readonly)
:nodoc:
37 38 39 |
# File 'lib/plsql/type.rb', line 37 def typecode @typecode end |
Instance Method Details
#attribute_names ⇒ Object
list of object type attribute names
90 91 92 |
# File 'lib/plsql/type.rb', line 90 def attribute_names @attribute_names ||= @attributes.keys.sort_by{|k| @attributes[k][:position]} end |
#collection? ⇒ Boolean
is type collection?
85 86 87 |
# File 'lib/plsql/type.rb', line 85 def collection? @is_collection ||= @typecode == 'COLLECTION' end |
#find_procedure(new_or_procedure) ⇒ Object
:nodoc:
119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 |
# File 'lib/plsql/type.rb', line 119 def find_procedure(new_or_procedure) #:nodoc: @type_procedures[new_or_procedure] ||= begin procedure_name = new_or_procedure == :new ? @type_name : new_or_procedure # find defined procedure for type if @schema.select_first( "SELECT procedure_name FROM all_procedures WHERE owner = :owner AND object_name = :object_name AND procedure_name = :procedure_name", @schema_name, @type_name, procedure_name.to_s.upcase) TypeProcedure.new(@schema, self, procedure_name) # call default constructor elsif new_or_procedure == :new TypeProcedure.new(@schema, self, :new) end end end |
#new(*args, &block) ⇒ Object
create new PL/SQL object instance
95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 |
# File 'lib/plsql/type.rb', line 95 def new(*args, &block) procedure = find_procedure(:new) # in case of collections pass array of elements as one argument for constructor if collection? && !(args.size == 1 && args[0].is_a?(Array)) args = [args] end result = procedure.(args, {:skip_self => true}, &block) # TODO: collection constructor should return Array of ObhjectInstance objects if collection? result else # TODO: what to do if block is passed to constructor? ObjectInstance.create(self, result) end end |