ruby_volt 0.0.5

data/lib/ruby_volt/data_type/basic/fixed_size/integer_type/integer.rb

@@ -0,0 +1,9 @@
+module RubyVolt
+  class DataType
+    class Integer < IntegerType
+      DIRECTIVE = 'l>'
+      LENGTH = 4
+      NULL_INDICATOR = -2147483648 # SQL NULL indicator for object type serializations
+    end
+  end
+end

data/lib/ruby_volt/data_type/basic/fixed_size/integer_type/long.rb

@@ -0,0 +1,9 @@
+module RubyVolt
+  class DataType
+    class Long < IntegerType
+      DIRECTIVE = 'q>'
+      LENGTH = 8
+      NULL_INDICATOR = -9223372036854775808 # SQL NULL indicator for object type serializations
+    end
+  end
+end

data/lib/ruby_volt/data_type/basic/fixed_size/integer_type/short.rb

@@ -0,0 +1,9 @@
+module RubyVolt
+  class DataType
+    class Short < IntegerType
+      DIRECTIVE = 's>'
+      LENGTH = 2
+      NULL_INDICATOR = -32768 # SQL NULL indicator for object type serializations
+    end
+  end
+end

data/lib/ruby_volt/data_type/basic/fixed_size/integer_type/u_byte.rb

@@ -0,0 +1,9 @@
+module RubyVolt
+  class DataType
+    class UByte < IntegerType # Unsigned
+      DIRECTIVE = 'C'
+      LENGTH = 1
+      NULL_INDICATOR = 0 # SQL NULL indicator for object type serializations
+    end
+  end
+end

data/lib/ruby_volt/data_type/basic/fixed_size/integer_type/u_integer.rb

@@ -0,0 +1,9 @@
+module RubyVolt
+  class DataType
+    class UInteger < IntegerType # Unsigned
+      DIRECTIVE = 'L>'
+      LENGTH = 4
+      NULL_INDICATOR = 0 # SQL NULL indicator for object type serializations
+    end
+  end
+end

data/lib/ruby_volt/data_type/basic/fixed_size/integer_type/u_long.rb

@@ -0,0 +1,9 @@
+module RubyVolt
+  class DataType
+    class ULong < IntegerType # Unsigned
+      DIRECTIVE = 'Q>'
+      LENGTH = 8
+      NULL_INDICATOR = 0 # SQL NULL indicator for object type serializations
+    end
+  end
+end

data/lib/ruby_volt/data_type/basic/fixed_size/integer_type/u_short.rb

@@ -0,0 +1,9 @@
+module RubyVolt
+  class DataType
+    class UShort < IntegerType # Unsigned
+      DIRECTIVE = 'S>'
+      LENGTH = 2
+      NULL_INDICATOR = 0 # SQL NULL indicator for object type serializations
+    end
+  end
+end

data/lib/ruby_volt/data_type/basic/fixed_size/null.rb

@@ -0,0 +1,13 @@
+module RubyVolt
+  class DataType
+    class Null < Byte
+      
+      class << self
+        def pack(*)
+          super(Byte::NULL_INDICATOR)
+        end
+      end
+      
+    end
+  end
+end

data/lib/ruby_volt/data_type/basic/fixed_size/timestamp.rb

@@ -0,0 +1,24 @@
+module RubyVolt
+  class DataType
+    class Timestamp < Long
+      
+      class << self
+        def pack(val)
+          # All dates are represented on the wire as Long values. This signed number represents the number of microseconds before or after Jan. 1 1970 00:00:00 GMT, the Unix epoch. Note that the units are microseconds, not milliseconds.
+          val = case val
+          when ::Integer then val
+          when ::Time then val.to_i*1000000 + val.usec # Microseconds
+          end
+          super(val)
+        end
+      
+        def unpack(bytes)
+          if unpacked = super(bytes)
+            Time.at(unpacked/1000000.to_f) # Microseconds
+          end
+        end
+      end
+      
+    end
+  end
+end

data/lib/ruby_volt/data_type/basic/geography.rb

@@ -0,0 +1,61 @@
+module RubyVolt
+  class DataType
+    class Geography < Basic
+      DIRECTIVE = 'a'
+      NULL_INDICATOR = -1 # SQL NULL indicator for object type serializations
+      
+      class << self
+        def pack(polygon)
+          if polygon.nil?
+             # Like strings, GeographyValue begins with a 4-byte integer storing the number of bytes of raw data, followed by the raw data itself. The NULL GeographyValue has a length of -1 followed by 0 (zero) bytes of data. Unlike strings, there are no zero byte GeographyValue data values.
+            Integer.pack(self::NULL_INDICATOR)
+          else
+            raw_data =
+            Byte.pack(0) + # The first byte, byte0, is an encoding version, which tells whether certain fields need to be initialized by the Execution Engine. This is initially zero (0) and should be maintained on read.
+            Byte.pack(1) + # The next byte, byte 1, is internal. It should be initially 1, and should be maintained on read.
+            Byte.pack(polygon.has_holes? ? 1 : 0) + # The next byte, byte 2, is 1 if the polygon has holes and 0 if it does not.
+            Integer.pack(polygon.rings.size) + # The next four bytes, bytes 3, 4, 5 and 6, comprise a 32 bit integer which gives the number of rings. Call this value `NRINGS`
+            polygon.transform_rings.map do |ring| # NRINGS ring representations
+              Byte.pack(0) + # The first byte of a ring tells if the ring is initialized. It is initially zero (0) and should be maintained on read.
+              Integer.pack(ring.points.size) + # The next 4 bytes are a 32-bit integer containing the number of vertices in the ring. Call this number `NVERTS`.
+              ring.points.map do |point| #The next `NVERTS*3*8` bytes are `NVERTS` triples of double precision floating point numbers, in the order `X`, `Y` and `Z`.
+                xyz = point.to_XYZPoint
+                xyz.map {|double| Float.pack(double)}
+              end.join +
+              ([0]*38).pack('c38') # The next 38 bytes contain a bounding box and some internal fields. They should all be initially zero (0) and should be maintained on read.
+            end.join +
+            ([0]*33).pack('c33') # The next 33 bytes, after all the vertices, should be initially zero (0) and should be maintained on read.
+            raw_data.prepend(Integer.pack(raw_data.size))
+          end
+        end
+      
+        def unpack(bytes)
+          if (length = Integer.unpack(bytes)) && (length != self::NULL_INDICATOR)
+            Byte.unpack(bytes) # The first byte, byte 0, is an encoding version, which tells whether certain fields need to be initialized by the Execution Engine. This is initially zero (0) and should be maintained on read.
+            Byte.unpack(bytes) # The next byte, byte 1, is internal. It should be initially 1, and should be maintained on read
+            has_holes = Byte.unpack(bytes) # The next byte, byte 2, is 1 if the polygon has holes and 0 if it does not.
+            rings_size = Integer.unpack(bytes)
+            polygon = Meta::Geography::Polygon.new
+            rings_size.times do
+              ring = Meta::Geography::Ring.new
+              Byte.unpack(bytes) # Ring is initialized. It is initially zero (0) and should be maintained on read.
+              verticles_size = Integer.unpack(bytes)
+              verticles_size.times do
+                x = Float.unpack(bytes)
+                y = Float.unpack(bytes)
+                z = Float.unpack(bytes)
+                point = Meta::Geography::Point.from_XYZPoint(x, y, z)
+                ring.add_point(point)
+              end
+              bytes.read(38).unpack1('c38') # Blob of zeros. 38 bytes contain a bounding box and some internal fields. They should all be initially zero (0) and should be maintained on read.
+              polygon.add_ring(ring)
+            end
+            bytes.read(33).unpack1('c33') # Blob of zeros. The next 33 bytes, after all the vertices, should be initially zero (0) and should be maintained on read.
+            polygon.transform_rings! if has_holes == 1
+            polygon
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ruby_volt/data_type/basic/string.rb

@@ -0,0 +1,19 @@
+module RubyVolt
+  class DataType
+    class String < Varbinary
+      
+      class << self
+        def unpack(bytes)
+          if unpacked = super(bytes)
+            unpacked.force_encoding("utf-8")
+          end
+        end
+    
+        def convert_input(val)
+          val.to_s.encode("utf-8")
+        end
+      end
+    
+    end
+  end
+end

data/lib/ruby_volt/data_type/basic/varbinary.rb

@@ -0,0 +1,34 @@
+module RubyVolt
+  class DataType
+    class Varbinary < Basic
+      DIRECTIVE = 'a'
+      NULL_INDICATOR = -1 # SQL NULL indicator for object type serializations
+
+      class << self
+        def pack(val)
+          if val.nil?
+            Integer.pack(self::NULL_INDICATOR)
+          else
+            val = convert_input(val)
+            Integer.pack(val.bytesize) + val
+          end
+        end
+      
+        def unpack(bytes)
+          length = Integer.unpack(bytes)
+          case length
+          when self::NULL_INDICATOR then nil
+          when 0 then ::String.new
+          else
+            bytes.read(length).unpack1("#{self::DIRECTIVE}#{length}")
+          end
+        end
+      
+        def convert_input(val)
+          val.to_s.encode("ascii-8bit")
+        end
+      end
+      
+    end
+  end
+end

data/lib/ruby_volt/data_type/complex.rb

@@ -0,0 +1,11 @@
+module RubyVolt
+  class DataType
+    class Complex < self
+    end
+  end
+end
+
+require 'ruby_volt/data_type/complex/volt_table'
+require 'ruby_volt/data_type/complex/serializable_exception'
+require 'ruby_volt/data_type/complex/parameter_set'
+require 'ruby_volt/data_type/complex/parameter'

data/lib/ruby_volt/data_type/complex/parameter.rb

@@ -0,0 +1,20 @@
+module RubyVolt
+  class DataType
+    class Parameter < Complex
+      
+      class << self
+        def pack(val)
+          dataType = voltDataType(val)
+          WireTypeInfo.pack(dataType) + dataType.pack(val)
+        end
+      
+        def unpack(bytes)
+          if dataType = WireTypeInfo.unpack(bytes)
+            dataType.unpack(bytes)
+          end
+        end
+      end
+      
+    end
+  end
+end

data/lib/ruby_volt/data_type/complex/parameter_set.rb

@@ -0,0 +1,19 @@
+module RubyVolt
+  class DataType
+    class ParameterSet < Complex
+      
+      class << self
+        def pack(*vals)
+          params_count = vals.size
+          Short.pack(params_count) + vals.map {|val| Parameter.pack(val)}.join
+        end
+      
+        def unpack(bytes)
+          params_count = Short.unpack(bytes)
+          params_count.times.map {Parameter.unpack(bytes)}
+        end
+      end
+      
+    end
+  end
+end

data/lib/ruby_volt/data_type/complex/serializable_exception.rb

@@ -0,0 +1,43 @@
+module RubyVolt
+  class DataType
+    class SerializableException < Basic
+      extend Extensions::CodeValuesHash
+      hash_codes [1, EEException],
+                 [2, SQLException],
+                 [3, ConstraintFailureException]
+                 
+      DIRECTIVE = 'a'
+      NULL_INDICATOR = 0 # The ordinal will not be present if the exception's length is 0.
+
+      class << self
+        def pack(val, body = nil)
+          if val.nil?
+            Integer.pack(self::NULL_INDICATOR)
+          else
+            ordinal = val.is_a?(::Integer) ? val : code_values[val]
+            if body
+              Integer.pack(1 + body.bytesize) + Byte.pack(ordinal) + body # Exception ordinal (1 byte) + opaque length
+            else
+              Integer.pack(1) + Byte.pack(ordinal) # Exception ordinal (1 byte)
+            end
+          end
+        end
+
+        def unpack(bytes)
+          if (length = Integer.unpack(bytes)) && length > 0
+            ordinal = Byte.unpack(bytes)
+            body_size = length - 1
+            if body_size == 0 # Ordinal only, no body
+              [codes[ordinal], nil]
+            else
+              [codes[ordinal], bytes.read(body_size).unpack1("#{self::DIRECTIVE}#{body_size}")]
+            end
+          else
+            [nil, nil]
+          end
+        end
+      end
+      
+    end
+  end
+end

data/lib/ruby_volt/data_type/complex/volt_table.rb

@@ -0,0 +1,96 @@
+module RubyVolt
+  class DataType
+    class VoltTable < Complex
+      
+      class << self
+        def pack(columns, rows)
+          # The "Table Metadata Length" stores the length in bytes of the contents of the table from byte 8 (the end of the metadata length field) all the way to the end of the "Column Names" sequence. NOTE: It does not include the row count value. See below for an example.
+          status_code = ProcedureCallStatusCode.pack(0) # OK Status code
+          columns_sequence = pack_columns(columns) # Columns data
+          rows_sequence = pack_rows(columns, rows) # Rows data
+          table_metadata_length = status_code.bytesize + columns_sequence.bytesize # Table Metadata Length
+          total_table_length = table_metadata_length + rows_sequence.bytesize # Total Table Length
+          [Integer.pack(total_table_length),
+           Integer.pack(table_metadata_length),
+           status_code,
+           columns_sequence,
+           rows_sequence].join
+        end
+      
+        def unpack(bytes, &block)
+          table_info = unpack_table_info(bytes)
+          columns = unpack_columns(bytes)
+          rows = unpack_rows(columns, bytes, &block)
+          [*table_info, columns, rows]
+        end
+      
+        def unpack_table_info(bytes)
+          [Integer.unpack(bytes), # total_table_length
+           Integer.unpack(bytes), # table_metadata_length
+           ProcedureCallStatusCode.unpack(bytes)] # status_code
+        end
+      
+        def pack_columns(columns = []) # [["column", DataType]] ex.: [["city", :String], ["population", :Long]]
+          # The size of the "Column Types" and "Column Names" sequences is expected to equal the value stored in "Column Count".
+          # Column names are limited to the ASCII character set. Strings in row values are still UTF-8 encoded.
+          # Values with 4-byte (integer) length fields are signed and are limited to a max of 1 megabyte.
+          col_types, col_names = [], []
+          columns.each do |col|
+            col_name, dataType = *col
+            col_name = "modified_tuples" if col_name == ""
+            dataType = classifyDataType(dataType) unless dataType < DataType
+            col_types << WireTypeInfo.pack(dataType)
+            col_names << Varbinary.pack(col_name) # ASCII-8bit
+          end
+          Short.pack(columns.size) + col_types.join + col_names.join
+        end
+    
+        def unpack_columns(bytes)
+          columns_count = Short.unpack(bytes)
+          columns = columns_count.times.map do
+            WireTypeInfo.unpack(bytes)
+          end
+          columns.map do |dataType|
+            col_name = Varbinary.unpack(bytes) # ASCII-8bit
+            col_name = "modified_tuples" if col_name == ""
+            [col_name, dataType]
+          end
+        end
+      
+        def pack_rows(columns, rows = []) # [[val1, val2, ...]]
+          # Each row is preceded by a 4 byte integer that holds the length of the row not including the length. For example, if a row is a single 4-byte integer column, the value of this length prefix will be 4. Row size is artificially restricted to 2 megabytes.
+          # The body of the row is packed array of values. The value at index i is is of type specified by the column type field for index i.
+          Integer.pack(rows.size) + # Row count
+          rows.map do |row_values|
+            rlength = 0
+            row_values.map.with_index do |val, index|
+              dataType = columns[index][1]
+              packed = dataType.pack(val)
+              rlength += packed.bytesize
+              packed
+            end.join.prepend(Integer.pack(rlength))
+          end.join
+        end
+                        
+        def unpack_rows(columns, bytes, &block) # Block for parsing on fly
+          rows_count = Integer.unpack(bytes)
+          rows = []
+          rows_count.times do
+            Integer.unpack(bytes) # Bytesize of row length
+            row = columns.map do |c|
+              dataType = c[1]
+              dataType.unpack(bytes)
+            end
+            if block_given?
+              yield(row)
+            else
+              rows << row
+            end
+          end
+          rows
+        end
+      end
+      
+    end
+  end
+end

data/lib/ruby_volt/data_type/compound.rb

@@ -0,0 +1,8 @@
+module RubyVolt
+  class DataType
+    class Compound < self
+    end
+  end
+end
+
+require 'ruby_volt/data_type/compound/array'

data/lib/ruby_volt/data_type/compound/array.rb

@@ -0,0 +1,42 @@
+module RubyVolt
+  class DataType
+    class Array < Compound
+      # Arrays are represented as Byte value indicating the wire type of the elements and a 2 byte Short value indicating the number of elements in the array, followed by the specified number of elements. The length preceding value for the TINYINT (byte) type is length preceded by a 4 byte integer instead of a 2 byte short. This important exception allows large quantities of binary or string data to be passed as a byte array, and allows the serialization of and array of TINYINTs (bytes) to match the serialization of VARBINARY. Each array is serialized according to its type (Strings as Strings, VoltTables as VoltTables, Integers as Integers). Arrays are only present as parameters in parameter sets. Note that it is possible to pass an array of arrays of bytes if they are serialized as an array of VARBINARY types.
+      
+      class << self
+        def pack(val = []) # First element is a DataType indicator (DataType itself, Integer, String/Symbol)
+          array = val[1..-1]
+          dataType = classifyDataType(val[0])
+          unless dataType  # No indicator recognized
+            array = val
+            dataType = autodetect_dataType(array)
+          end
+          countDataType = (dataType <= Byte) ? Integer : Short # The length preceding value for the TINYINT (byte) type is length preceded by a 4 byte integer instead of a 2 byte short.
+          WireTypeInfo.pack(dataType) + countDataType.pack(array.size) + array.map {|e| dataType.pack(e)}.join
+        end
+      
+        def unpack(bytes)
+          if dataType = WireTypeInfo.unpack(bytes)
+            array = [dataType]
+            countDataType = (dataType <= Byte) ? Integer : Short
+            array_size = countDataType.unpack(bytes)
+            array_size.times do
+              array << dataType.unpack(bytes)
+            end
+            array
+          end
+        end
+      
+        def autodetect_dataType(array)
+          if array[0].is_a?(::Integer)
+            max_int = array.select {|e| e.is_a?(::Integer)}.max
+            voltDataType(max_int)
+          else
+            voltDataType(array[0])
+          end
+        end
+      end
+      
+    end
+  end
+end