dbd-sqlanywhere 0.1.0

data/CHANGELOG

@@ -0,0 +1,6 @@
+=CHANGE LOG
+
+=====0.1.0 -- 2008/10/29
+- Initial Release
+- Wraps DBCAPI funcationality
+- Tested against DBI 0.4

data/LICENSE

@@ -0,0 +1,23 @@
+/*====================================================
+*
+*   Copyright 2008 iAnywhere Solutions, Inc.
+*
+* Licensed under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License.
+* You may obtain a copy of the License at
+*                                                                               
+*
+* http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+*
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*
+* While not a requirement of the license, if you do modify this file, we
+* would appreciate hearing about it.   Please email sqlany_interfaces@sybase.com
+*
+*
+*====================================================*/

data/README

@@ -0,0 +1,123 @@
+=SQL Anywhere DBD Driver for Ruby-DBI
+
+This is a SQL Anywhere driver for Ruby DBI (http://ruby-dbi.rubyforge.org/). This driver requires the
+native SQL Anywhere Ruby driver. To get the native driver, use:
+
+   gem install sqlanywhere
+
+This driver is designed for use with DBI 0.4 and greater.
+
+This driver is licensed under the Apache License, Version 2.
+
+==Making a Connection
+
+The following code is a sample database configuration object that connects
+to a database called 'Test'.
+   
+  require 'dbi'
+  
+  DBI.connect('DBI:SQLAnywhere:Test') do | dbh |
+    if dbh.ping
+      print "Successfully Connected"
+    end
+  end
+
+The connection string takes the general form:
+
+  dbh = DBI.connect('DBI:SQLAnywhere:[DB_NAME]', [USER_NAME], [PASSWORD], [OPTIONS])
+
+where,
+  [DB_NAME] is the name of the database you wish to connect to
+  [USER_NAME] is the username
+  [PASSWORD] is the correspoding password for the username
+
+  [OPTIONS] is a hash of additional options for the connection. 
+
+For example, to start with named connection called 'ruby_dbi' you can use:
+ 
+  dbh = DBI.connect('DBI:SQLAnywhere:Test', 'dba', 'sql', {:CON => "ruby_dbi"})
+
+==Driver-Specific Features
+
+At the time of this writing, there was no standard way to handle INOUT and OUT parameters
+from stored procedures in DBI. 
+
+When binding to an OUT parameter, you must bind a hash that contains a key called
+:name. This :name will be used to retrieve the OUT value after execution. If the
+OUT column is of string or binary type, you must also pass a key called :length 
+with the expected maximum length of the OUT parameter.
+
+In the case of an INOUT parameter, the :name and :length keys are the same as for
+OUT parameters, but an additional :value parameter holds the value to be passed
+into the stored procedure.
+
+After execution, you can use the statement-specific function :bound_param
+to retrieve the output value using the :name supplied at binding time.
+
+===Example of using OUT and INOUT parameters
+      
+   # The result that should be printed to console is:
+   #  Complete string is PREFIX-some_string-SUFFIX and is 25 chars long
+   #  Complete string is PREFIXPREFIX-some_string-SUFFIXSUFFIX and is 37 chars long
+
+   require 'dbi'
+
+   begin
+   DBI.connect("DBI:SQLAnywhere:test") do |dbh|
+
+   sql = <<SQL
+   IF EXISTS(select * from sysprocedure where proc_name = 'foo') THEN
+       DROP PROCEDURE foo;
+   END IF
+   SQL
+
+      dbh.do(sql);
+
+   sql = <<SQL
+   create procedure foo 
+   ( IN prefix char(10),
+     INOUT buffer varchar(256),
+     OUT str_len int,
+     IN suffix char(10) 
+   )
+   begin                                       
+       set buffer = prefix || buffer || suffix;
+       select length( buffer ) into str_len;   
+   end                                         
+   SQL
+
+      dbh.do(sql);
+      
+      buffer = "-some_string-"
+      prefix = "PREFIX"
+      
+      # preparing the statment
+      sth = dbh.prepare("call foo( ?, ?, ?, ? )")
+
+      # Binding buffer column as :buf, and str_len column as :len
+      # Note that we must supply a :value for :buf since it is an INOUT
+      # And we must supply a :length for :buf since it is a string column
+      sth.execute( prefix, {:name => :buf, :value => buffer, :length => 255}, {:name => :len}, "SUFFIX")
+
+      # Retrieve the OUT value from buffer
+      new_buffer = sth.func(:bound_param, :buf)
+
+      # Retrieve the OUT value from str_len
+      length = sth.func(:bound_param, :len)
+      puts "Complete string is #{new_buffer} and is #{length} chars long"
+
+      # Add the results back into the string, and re-execute
+      sth.execute("PREFIX", {:name => :buf, :value => new_buffer, :length => 255}, {:name => :len}, "SUFFIX")
+      new_buffer = sth.func(:bound_param, :buf)
+      length = sth.func(:bound_param, :len)
+      puts "Complete string is #{new_buffer} and is #{length} chars long"
+   end
+
+   rescue DBI::DatabaseError => e
+    puts "An error occurred"
+    puts "Error code: #{e.err}"
+    puts "Error message: #{e.errstr}"
+    puts "Error SQLSTATE: #{e.state}"
+   ensure
+       DBI.disconnect_all
+   end

data/lib/dbd/SQLAnywhere.rb

@@ -0,0 +1,175 @@
+#====================================================
+#
+#    Copyright 2008 iAnywhere Solutions, Inc.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#                                                                               
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+# While not a requirement of the license, if you do modify this file, we
+# would appreciate hearing about it.   Please email sqlany_interfaces@sybase.com
+#
+#
+#====================================================
+
+begin
+    require 'rubygems'
+    gem 'sqlanywhere'
+    gem 'dbi'
+rescue LoadError => e
+end
+
+require 'dbi'
+require 'sqlanywhere'
+require 'singleton'
+
+module DBI
+module DBD
+module SQLAnywhere
+
+   VERSION = "0.1.0"
+
+   def self.driver_name
+      "SQLAnywhere"
+   end
+
+   class SA
+      include Singleton
+      attr_accessor :api
+
+      def initialize
+	 unless defined? SQLAnywhere
+	   require 'sqlanywhere'
+	 end
+
+	 @api = ::SQLAnywhere::SQLAnywhereInterface.new()
+	 result = ::SQLAnywhere::API.sqlany_initialize_interface( @api )
+	 if result == 0 
+	     raise LoadError, "Could not load SQLAnywhere DLL"
+	 end
+	 result = @api.sqlany_init()
+	 if result == 0 
+	     raise LoadError, "Could not initialize SQLAnywhere DLL"
+	 end
+      end
+
+      def free_api
+	 ::SQLAnywhere::API.sqlany_finalize_interface( @api );
+	 @api = nil
+      end
+   end   
+
+
+   DBI::TypeUtil.register_conversion(driver_name) do |obj|
+       case obj
+       when DBI::Binary # these need to be handled specially by the driver
+	   obj.to_s
+       when ::NilClass
+	   nil
+       when ::TrueClass
+	   1
+       when ::FalseClass
+	   0
+       when ::Time
+	   obj.strftime("%H:%M:%S")
+       when ::Date
+	   obj.strftime("%Y/%m/%d")
+       when ::DateTime, DBI::Timestamp
+	   DateTime.parse(obj.to_s).strftime("%Y/%m/%d %H:%M:%S")	
+       when ::String
+	   obj
+       when ::BigDecimal
+	   obj.to_s("F")
+       when ::Numeric
+	   obj.to_s
+       else
+	   obj
+       end
+   end
+
+
+   # This module provides funcationality that is used by all the DBD classes
+   module Utility
+
+      NO_DIRECTION = 0
+      INPUT_ONLY   = 1
+      OUTPUT_ONLY  = 2
+      INPUT_OUTPUT = 3
+
+      # do_bind takes the following arguments:
+      # * +prep_stmt+ : a handle the prepared Statement object
+      # * +param+     : the parameter to bound, obtained by sqlany_describe_bind_param
+      # * +bindvar+   : the actual value to bind the the parameter. Can be a +VALUE+, or a +HASH+.
+      # * +i+         : the parameter number to bind. Should be the same as used in sqlany_describe_bind_param
+      # * +bound+     : hash used to track INOUT, and OUT parameters
+      #
+      # +IN+ parameters will be bound once with +INPUT_ONLY+.
+      # +OUT+ parameters will be bound once with +OUTPUT_ONLY+.
+      # +INOUT+ parameters will be be bound twice, once as +INPUT_ONLY+, and once as +OUTPUT_ONLY+. +INOUT+ parameters 
+      # will use *different* buffers to pass the input and output values to the DLL.
+      #
+      # If the parameter to be bound is +INPUT_ONLY+, +bindvar+ *must* be a regular value type such as
+      # Bignum, Fixnum, String, etc. This value will be bound to the input parameter
+      #
+      # If the parameter to be bound is +OUTPUT_ONLY+, +bindvar+ *must* be a hash with keys:
+      # ::name => This is the name that you will be used later to retrieve the output value
+      # ::length => If the output will be a string or binary, the expected length must be stated. If this length is exceeded
+      #    a DatabaseError (truncation) will be raised.
+      #
+      # If the parameter to be bound is +INPUT_OUTPUT+, +bindvar+ *must* be a hash with keys:
+      # ::name => This is the name that you will be used later to retrieve the output value
+      # ::value => The value to bind to the input.
+      # ::length => If the output will be a string or binary, the expected length must be stated. If this length is exceeded
+      #    a DatabaseError (truncation) will be raised.
+      # 
+      def do_bind!(prep_stmt, param, bindvar, i, bound)
+	 # Get the direction
+	 orig_direction = param.get_direction;
+
+	 # Bind INPUT
+	 if orig_direction == INPUT_ONLY or orig_direction == INPUT_OUTPUT
+	    param.set_direction(INPUT_ONLY)
+	    # Obtain the value out of the hash if neccessary
+	    if bindvar.class == Hash
+	       raise DBI::ProgrammingError.new("Parameter hash must contain :value key") if !bindvar.has_key?(:value)
+	       param.set_value(bindvar[:value])
+	    else
+	       param.set_value(bindvar)
+	    end
+	    raise error() if SA.instance.api.sqlany_bind_param(prep_stmt, i, param) == 0
+	 end
+
+	 # Bind OUTPUT
+	 if orig_direction == OUTPUT_ONLY or orig_direction == INPUT_OUTPUT
+	    param.set_direction(OUTPUT_ONLY)
+	    # Add the +::name+ to the +bound+ hash so its output value can be retrieved later
+	    raise DBI::ProgrammingError.new("Parameter hash must contain :name key") if !bindvar.has_key?(:name)
+	    bound[bindvar[:name]] = i if !bound.nil?
+	    # set the buffer length if appropriate
+	    if bindvar.has_key?(:length)
+	       param.set_buffer_size(bindvar[:length])
+	    end
+	    # +set_value+ sets up the receiveing buffer
+	    param.set_value(nil)
+	    raise error() if SA.instance.api.sqlany_bind_param(prep_stmt, i, param) == 0
+	 end
+      end
+   end
+
+end # module SQLAnywhere
+end # module DBD
+end # module DBI
+
+require 'dbd/SQLAnywhere/driver'
+require 'dbd/SQLAnywhere/database'
+require 'dbd/SQLAnywhere/statement'

data/lib/dbd/sqlanywhere/database.rb

@@ -0,0 +1,253 @@
+#====================================================
+#
+#    Copyright 2008 iAnywhere Solutions, Inc.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#                                                                               
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+# While not a requirement of the license, if you do modify this file, we
+# would appreciate hearing about it.   Please email sqlany_interfaces@sybase.com
+#
+#
+#====================================================
+
+module DBI::DBD::SQLAnywhere
+   class Database < DBI::BaseDatabase
+      include Utility
+
+COLUMN_SELECT_STRING = <<END_OF_STATEMENT       
+SELECT systabcol.column_name,
+       sysidxcol.sequence,
+       systabcol."nulls",
+       systabcol."default",
+       systabcol.scale, 
+       systabcol.width,
+       sysdomain.type_id,
+       sysdomain.domain_name,
+       sysidx."unique"
+FROM   (systable join systabcol join sysdomain) left outer join (sysidxcol join sysidx)
+WHERE  table_name = ?
+END_OF_STATEMENT
+
+TABLE_SELECT_STRING = <<END_OF_STATEMENT       
+SELECT table_name 
+FROM sysuser, systab 
+WHERE user_name not in ('SYS', 'DBO', 'rs_systabgroup') 
+AND sysuser.user_id = systab.creator
+END_OF_STATEMENT
+
+      SQLANY_to_DBI = {
+	   5 => DBI::SQL_SMALLINT,
+	   4 => DBI::SQL_INTEGER,
+	   2 => DBI::SQL_NUMERIC,
+	   7 => DBI::SQL_FLOAT,
+	   8 => DBI::SQL_DOUBLE,
+	   9 => DBI::SQL_DATE,
+	   1 => DBI::SQL_CHAR,
+	  12 => DBI::SQL_VARCHAR,
+	  -1 => DBI::SQL_LONGVARCHAR,
+	  -2 => DBI::SQL_BINARY,
+	  -4 => DBI::SQL_LONGVARBINARY,
+	  11 => DBI::SQL_TIMESTAMP,
+	  10 => DBI::SQL_TIME,
+	  -6 => DBI::SQL_TINYINT,
+	  -5 => DBI::SQL_BIGINT,
+	  -9 => DBI::SQL_INTEGER, 
+	 -10 => DBI::SQL_SMALLINT,
+	 -11 => DBI::SQL_BIGINT,
+	  -7 => DBI::SQL_BIT,
+	   2 => DBI::SQL_DECIMAL,
+	  -2 => DBI::SQL_VARBINARY,
+	 -15 => DBI::SQL_BINARY,
+	 -16 => DBI::SQL_VARBINARY,
+	 -17 => DBI::SQL_LONGVARBINARY,
+	 -18 => DBI::SQL_LONGVARCHAR,
+	 -12 => DBI::SQL_CHAR,
+	 -13 => DBI::SQL_VARCHAR,
+	 -14 => DBI::SQL_LONGVARCHAR,
+      }
+
+
+      def disconnect
+	 SA.instance.api.sqlany_rollback(@handle)
+	 SA.instance.api.sqlany_disconnect(@handle)
+	 SA.instance.api.sqlany_free_connection(@handle)
+      end
+
+      def prepare( statement )
+	 stmt = SA.instance.api.sqlany_prepare(@handle, statement) 
+	 if stmt.nil?
+	    raise error()
+	 else
+	    return Statement.new(stmt, @handle)
+	 end
+      end
+
+      def ping
+	 res = SA.instance.api.sqlany_execute_immediate(@handle, 'SELECT * FROM dummy')
+	 raise error() if res == 0
+	 return res
+      end
+      
+      def commit
+	 res = SA.instance.api.sqlany_commit(@handle)
+	 raise error() if res == 0
+	 return res      
+      end
+
+      def rollback
+	 res = SA.instance.api.sqlany_rollback(@handle)     
+	 raise error() if res == 0
+	 return res
+      end
+
+      def quote(value)
+	 value.gsub("'", "''")
+      end
+
+      def execute(sql, *bindvars)
+	 bound = {}
+	 prep_stmt = SA.instance.api.sqlany_prepare(@handle, sql);
+	 raise error() if prep_stmt.nil?
+	 num_params = SA.instance.api.sqlany_num_params(prep_stmt)
+	 raise error("Wrong number of parameters. Supplied #{bindvars.length} but expecting #{num_params}") if (num_params != bindvars.length)	 
+	 num_params.times do |i|
+	    res, param = SA.instance.api.sqlany_describe_bind_param(prep_stmt, i)
+	    raise error() if res == 0 or param.nil?
+	    do_bind!(prep_stmt, param, bindvars[i], i, bound)
+	    param.finish
+	 end
+
+	 res = SA.instance.api.sqlany_execute(prep_stmt)
+	 raise error() if res == 0   
+	 return Statement.new(prep_stmt, @handle, bound)
+      end
+
+      def do(sql, *bindvars)
+	 prep_stmt = SA.instance.api.sqlany_prepare(@handle, sql);
+	 raise error() if prep_stmt.nil?
+	 num_params = SA.instance.api.sqlany_num_params(prep_stmt)    
+	 raise error("Wrong number of parameters. Supplied #{bindvars.length} but expecting #{num_params}") if (num_params != bindvars.length) 
+	 num_params.times do |i|      
+	    res, param = SA.instance.api.sqlany_describe_bind_param(prep_stmt, i)
+	    raise error() if res == 0 or param.nil?
+	    do_bind!(prep_stmt, param, bindvars[i], i, nil)
+	    param.finish
+	 end
+	 res  = SA.instance.api.sqlany_execute(prep_stmt)
+	 raise error() if res == 0
+	 affected_rows = SA.instance.api.sqlany_affected_rows(prep_stmt)
+	 return affected_rows
+      end
+
+      def tables
+	 rs = SA.instance.api.sqlany_execute_direct(@handle, TABLE_SELECT_STRING)
+	 if rs.nil?
+	    return nil
+	 else
+	    tables = []
+	    while (SA.instance.api.sqlany_fetch_next(rs) == 1)
+	       res, cols = SA.instance.api.sqlany_get_column(rs, 0) 
+	       raise error() if res == 0 or cols.nil?
+	       tables << cols
+	    end
+
+	    return tables
+	 end      
+      end
+
+      def columns( table )
+	 prep_stmt = SA.instance.api.sqlany_prepare(@handle, COLUMN_SELECT_STRING)
+	 raise error() if prep_stmt.nil?
+	 res, param = SA.instance.api.sqlany_describe_bind_param(prep_stmt, 0)
+	 raise error() if res == 0 or param.nil?
+	 param.set_value(table) 
+	 
+	 raise error() if SA.instance.api.sqlany_bind_param(prep_stmt, 0, param) == 0
+		     
+	 res = SA.instance.api.sqlany_execute(prep_stmt)     
+
+	 raise error() if res == 0 or prep_stmt.nil?
+	 columns = []
+	 col_count = 0
+	 while (SA.instance.api.sqlany_fetch_next(prep_stmt) == 1)
+	    columns << {}
+
+	    res, col_val = SA.instance.api.sqlany_get_column(prep_stmt, 0)
+	    raise error() if res == 0
+	    columns[col_count]['name'] = col_val
+
+	    res, col_val = SA.instance.api.sqlany_get_column(prep_stmt, 1)
+	    raise error() if res == 0
+	    columns[col_count]['pkey'] = !col_val.nil?
+
+	    res, col_val = SA.instance.api.sqlany_get_column(prep_stmt, 2)
+	    raise error() if res == 0
+	    if col_val == 'Y'
+	       columns[col_count]['nullable'] = true 
+	    else 
+	       columns[col_count]['nullable'] = false 
+	    end	 
+
+	    res, col_val = SA.instance.api.sqlany_get_column(prep_stmt, 3)
+	    raise error() if res == 0
+	    columns[col_count]['default'] = col_val
+
+	    res, col_val = SA.instance.api.sqlany_get_column(prep_stmt, 4)
+	    raise error() if res == 0
+	    columns[col_count]['scale'] = col_val
+	    
+	    res, col_val = SA.instance.api.sqlany_get_column(prep_stmt, 5)
+	    raise error() if res == 0
+	    columns[col_count]['precision'] = col_val
+
+	    res, col_val = SA.instance.api.sqlany_get_column(prep_stmt, 6)
+	    raise error() if res == 0 
+	    columns[col_count]['sql_type'] = SQLANY_to_DBI[col_val]
+
+	    res, col_val = SA.instance.api.sqlany_get_column(prep_stmt, 7)
+	    raise error() if res == 0
+	    columns[col_count]['type_name'] = col_val.downcase
+
+	    res, col_val = SA.instance.api.sqlany_get_column(prep_stmt, 8)
+	    raise error() if res == 0
+	    columns[col_count]['unique'] = (col_val == 1 or col_val == 2)
+
+	    col_count += 1	 
+	 end
+	 param.finish
+	 return columns
+      end
+
+      def [] (attr)
+	 @attr[attr]
+      end
+      
+      def []= (attr, val)
+	 @attr[attr] = val
+      end
+
+      protected
+	 def error(*custom_msg)
+	    code, msg = SA.instance.api.sqlany_error(@handle)
+	    state = SA.instance.api.sqlany_sqlstate(@handle)
+	    SA.instance.api.sqlany_clear_error(@handle)
+	    if !custom_msg.nil?
+	       msg = "#{custom_msg}. #{msg}"
+	    end
+	    return DBI::DatabaseError.new(code, msg, state)
+	 end
+   end
+
+end

data/lib/dbd/sqlanywhere/driver.rb

@@ -0,0 +1,58 @@
+#====================================================
+#
+#    Copyright 2008 iAnywhere Solutions, Inc.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#                                                                               
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+# While not a requirement of the license, if you do modify this file, we
+# would appreciate hearing about it.   Please email sqlany_interfaces@sybase.com
+#
+#
+#====================================================
+
+module DBI::DBD::SQLAnywhere
+   class Driver < DBI::BaseDriver
+      include Utility
+
+      def initialize
+	 super("0.4.0")
+      end
+
+      def connect( dbname, user, auth, attr )
+	 conn = SA.instance.api.sqlany_new_connection()
+	 conn_str = "uid=#{user};pwd=#{auth};";
+
+	 if !dbname.nil?
+	    conn_str += "eng=#{dbname};";
+	 end
+
+	 attr.keys.each do |option|
+	    conn_str += "#{option}=#{attr[option]};"
+	 end
+
+	 SA.instance.api.sqlany_connect(conn, conn_str)
+	 return Database.new(conn, attr)      
+      end
+
+      def default_user
+	 return ['dba', 'sql']
+      end
+
+      def disconnect_all
+	 SA.instance.api.sqlany_fini()
+	 SA.instance.free_api
+      end
+   end   
+end

data/lib/dbd/sqlanywhere/statement.rb

@@ -0,0 +1,209 @@
+#====================================================
+#
+#    Copyright 2008 iAnywhere Solutions, Inc.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#                                                                               
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+# While not a requirement of the license, if you do modify this file, we
+# would appreciate hearing about it.   Please email sqlany_interfaces@sybase.com
+#
+#
+#====================================================
+
+module DBI::DBD::SQLAnywhere
+   class Statement < DBI::BaseStatement
+      include Utility
+
+
+      # Conversion table between SQL Anywhere E-SQL types and DBI SQL Types
+      SQLANY_NATIVE_TYPES = {
+	 0   => DBI::SQL_LONGVARCHAR,
+	 384 => DBI::SQL_DATE,
+	 388 => DBI::SQL_TIME,
+	 392 => DBI::SQL_TIMESTAMP,
+	 448 => DBI::SQL_VARCHAR,
+	 452 => DBI::SQL_CHAR,
+	 456 => DBI::SQL_LONGVARCHAR,
+	 460 => DBI::SQL_LONGVARCHAR,
+	 480 => DBI::SQL_DOUBLE,
+	 482 => DBI::SQL_FLOAT,
+	 484 => DBI::SQL_DECIMAL,
+	 496 => DBI::SQL_INTEGER,
+	 500 => DBI::SQL_SMALLINT,
+	 524 => DBI::SQL_BINARY,
+	 528 => DBI::SQL_LONGVARBINARY,
+	 604 => DBI::SQL_TINYINT,
+	 608 => DBI::SQL_BIGINT,
+	 612 => DBI::SQL_INTEGER,
+	 616 => DBI::SQL_SMALLINT,
+	 620 => DBI::SQL_BIGINT,
+	 624 => DBI::SQL_BIT,
+	 640 => DBI::SQL_LONGVARCHAR
+      }
+
+      def initialize(handle, conn, bound = {} )
+	 @handle = handle
+	 @conn = conn
+	 @arr = []
+	 @bound = bound
+	 @offset = -1
+      end
+
+      def __bound_param(name)
+	 if !@bound[name].nil?
+	    res, param = SA.instance.api.sqlany_get_bind_param_info(@handle, @bound[name])
+	    raise error() if res == 0
+	    return param.get_output()
+	 end 
+      end
+
+      # Although SQL Anywhere allows multiple result sets,
+      # the @fetchable variable disallows there use
+      #
+      #def __next_resultset
+      #   return SA.instance.api.sqlany_get_next_result(@handle)
+      #end
+
+      def bind_param(param, value, attribs)
+	 param -= 1
+	 res, param_description = SA.instance.api.sqlany_describe_bind_param(@handle, param)
+	 raise error() if res == 0 or param_description.nil?
+	 do_bind!(@handle, param_description, value, param, @bound)
+	 param_description.finish
+      end
+
+      def execute()
+	 res = SA.instance.api.sqlany_execute(@handle)
+	 raise error() if res == 0
+      end
+
+      def fetch()
+	 return fetch_scroll(DBI::SQL_FETCH_NEXT, 1)  
+      end
+
+      def fetch_all()
+	 rows = []
+	 loop {
+	    new_row = self.fetch_scroll(DBI::SQL_FETCH_NEXT, 1)
+	    break if new_row.nil?
+	    rows << new_row.clone
+	 }
+	 return rows
+      end
+
+      def fetch_scroll(direction, offset)
+	 res = 0
+	 new_offset = @offset
+
+	 case direction
+	    when DBI::SQL_FETCH_NEXT
+	       res = SA.instance.api.sqlany_fetch_next(@handle)
+	       new_offset += 1
+	    when DBI::SQL_FETCH_PRIOR
+	       res = SA.instance.api.sqlany_fetch_absolute(@handle, @offset)
+	       new_offset -= 1
+	    when DBI::SQL_FETCH_FIRST
+	       res = SA.instance.api.sqlany_fetch_absolute(@handle, 1)
+	       new_offset = 0
+	    when DBI::SQL_FETCH_LAST
+	       res = SA.instance.api.sqlany_fetch_absolute(@handle, -1)
+	       new_offset = self.rows() - 1
+	    when DBI::SQL_FETCH_ABSOLUTE
+	       res = SA.instance.api.sqlany_fetch_absolute(@handle, offset)
+	       if offset <= 0
+		  new_offset = self.rows() + offset 
+	       else
+		  new_offset = offset - 1
+	       end
+	    when DBI::SQL_FETCH_RELATIVE
+	       res = SA.instance.api.sqlany_fetch_absolute(@handle, @offset + offset + 1)
+	       new_offset += offset
+	 end
+
+	 if (res == 1)
+	    retrieve_row_data()
+	    @offset = new_offset
+	    return @arr
+	 else
+	    return nil
+	 end   
+      end
+
+      def column_info
+	 columns = []
+	 if !@handle.nil?
+	    max_cols = SA.instance.api.sqlany_num_cols(@handle)
+	    raise error() if max_cols == -1
+	    max_cols.times do |cols|
+	       columns << {}
+	       res, holder, col_name, type, native_type, precision, scale, max_size, nullable = SA.instance.api.sqlany_get_column_info(@handle, cols)
+	       raise error() if res == 0 or col_name.nil?
+	       columns[cols]["name"] = col_name
+	       sql_type = SQLANY_NATIVE_TYPES[native_type]
+	       columns[cols]["sql_type"] = sql_type
+	       columns[cols]["type_name"] = DBI::SQL_TYPE_NAMES[sql_type]
+	       precision = max_size if precision == 0 and max_size != 0
+	       columns[cols]["precision"] = precision
+	       columns[cols]["scale"] = scale
+	       columns[cols]["nullable"] = (nullable == 0)
+
+	       columns[cols]["dbi_type"] = DBI::Type::Boolean if sql_type == DBI::SQL_BIT
+	    end
+	 end
+	 return columns  
+      end
+
+      def rows
+	 if @handle.nil?
+	    res = SA.instance.api.sqlany_affected_rows(@handle)
+	    raise error() if res == -1
+	    return res	 
+	 else
+	    0
+	 end
+      end
+
+      def finish
+	 if !@handle.nil?
+	    SA.instance.api.sqlany_free_stmt(@handle);
+	    @handle = nil
+	 end
+      end
+      
+      def cancel
+      end
+
+      protected
+	 def error(*custom_msg)
+	    code, msg = SA.instance.api.sqlany_error(@conn)
+	    state = SA.instance.api.sqlany_sqlstate(@conn)
+	    SA.instance.api.sqlany_clear_error(@conn)
+	    if !custom_msg.nil?
+	       msg = "#{custom_msg}. #{msg}"
+	    end
+	    return DBI::DatabaseError.new(code, msg, state)
+	 end
+
+	 def retrieve_row_data
+	    max_cols = SA.instance.api.sqlany_num_cols(@handle)
+	    raise error() if max_cols == -1
+	    max_cols.times do |cols|
+	       res, col_val = SA.instance.api.sqlany_get_column(@handle, cols)
+	       raise error() if res == 0
+	       @arr[cols] = col_val
+	    end
+	 end
+   end
+end

metadata

@@ -0,0 +1,75 @@
+--- !ruby/object:Gem::Specification 
+rubygems_version: 0.9.4
+specification_version: 1
+name: dbd-sqlanywhere
+version: !ruby/object:Gem::Version 
+  version: 0.1.0
+date: 2008-11-03 00:00:00 -05:00
+summary: Ruby DBI driver (DBD) for SQL Anywhere
+require_paths: 
+- lib
+email: eric.farrar@ianywhere.com
+homepage: http://sqlanywhere.rubyforge.org
+rubyforge_project: sqlanywhere
+description: Ruby DBI driver (DBD) for SQL Anywhere
+autorequire: 
+default_executable: 
+bindir: bin
+has_rdoc: true
+required_ruby_version: !ruby/object:Gem::Version::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: 1.8.6
+  version: 
+platform: ruby
+signing_key: 
+cert_chain: 
+post_install_message: 
+authors: 
+- Eric Farrar
+files: 
+- lib/dbd/SQLAnywhere.rb
+- lib/dbd/sqlanywhere/statement.rb
+- lib/dbd/sqlanywhere/driver.rb
+- lib/dbd/sqlanywhere/database.rb
+- README
+- CHANGELOG
+- LICENSE
+test_files: []
+
+rdoc_options: 
+- --title
+- SQL Anywhere DBD for Ruby-DBI
+- --main
+- README
+- --line-numbers
+extra_rdoc_files: 
+- README
+- CHANGELOG
+- LICENSE
+executables: []
+
+extensions: []
+
+requirements: []
+
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: sqlanywhere
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Version::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 0.1.0
+    version: 
+- !ruby/object:Gem::Dependency 
+  name: dbi
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Version::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 0.4.0
+    version: