Author: joshua
Date: 2006-01-29 11:43:14 -0500 (Sun, 29 Jan 2006)
New Revision: 56227

Added:
   trunk/mcs/class/Mono.Data.SqliteClient/Test/SqliteCommandUnitTests.cs
   trunk/mcs/class/Mono.Data.SqliteClient/Test/SqliteDataAdapterUnitTests.cs
   trunk/mcs/class/Mono.Data.SqliteClient/Test/SqliteExceptionUnitTests.cs
   trunk/mcs/class/Mono.Data.SqliteClient/Test/SqliteParameterUnitTests.cs
Modified:
   trunk/mcs/class/Mono.Data.SqliteClient/ChangeLog
   trunk/mcs/class/Mono.Data.SqliteClient/Mono.Data.SqliteClient/ChangeLog
   trunk/mcs/class/Mono.Data.SqliteClient/Mono.Data.SqliteClient/Sqlite.cs
   
trunk/mcs/class/Mono.Data.SqliteClient/Mono.Data.SqliteClient/SqliteCommand.cs
   
trunk/mcs/class/Mono.Data.SqliteClient/Mono.Data.SqliteClient/SqliteConnection.cs
   
trunk/mcs/class/Mono.Data.SqliteClient/Mono.Data.SqliteClient/SqliteDataReader.cs
   
trunk/mcs/class/Mono.Data.SqliteClient/Mono.Data.SqliteClient/SqliteParameter.cs
   
trunk/mcs/class/Mono.Data.SqliteClient/Mono.Data.SqliteClient/SqliteParameterCollection.cs
   
trunk/mcs/class/Mono.Data.SqliteClient/Mono.Data.SqliteClient_test.dll.sources
   trunk/mcs/class/Mono.Data.SqliteClient/Test/ChangeLog
   trunk/mcs/class/Mono.Data.SqliteClient/Test/SqliteConnectionTest.cs
   trunk/mcs/class/Mono.Data.SqliteClient/Test/SqliteTest.cs
Log:
SqliteClient: Lots and lots of fixes.

Modified: trunk/mcs/class/Mono.Data.SqliteClient/ChangeLog
===================================================================
--- trunk/mcs/class/Mono.Data.SqliteClient/ChangeLog    2006-01-29 15:08:01 UTC 
(rev 56226)
+++ trunk/mcs/class/Mono.Data.SqliteClient/ChangeLog    2006-01-29 16:43:14 UTC 
(rev 56227)
@@ -1,3 +1,7 @@
+2006-01-29  Joshua Tauberer  <[EMAIL PROTECTED]>
+
+       * Added new test sources.
+
 2006-01-20  Joshua Tauberer  <[EMAIL PROTECTED]>
 
        * Removed dependency on Mono.Posix.

Modified: 
trunk/mcs/class/Mono.Data.SqliteClient/Mono.Data.SqliteClient/ChangeLog
===================================================================
--- trunk/mcs/class/Mono.Data.SqliteClient/Mono.Data.SqliteClient/ChangeLog     
2006-01-29 15:08:01 UTC (rev 56226)
+++ trunk/mcs/class/Mono.Data.SqliteClient/Mono.Data.SqliteClient/ChangeLog     
2006-01-29 16:43:14 UTC (rev 56227)
@@ -1,3 +1,34 @@
+2006-01-22  Joshua Tauberer  <[EMAIL PROTECTED]>
+
+       Most of the below fixes (in previous changes too) are thanks
+       to Thomas Zoechling and Tom Surace, and the byte[]->blob
+       parameter binding is thanks to <[EMAIL PROTECTED]>.
+       
+       * SqliteCommand.cs:
+         - Don't use a regex for finding parameters in v2.
+         It didn't work when there were no parameters in
+         the query (infinite loop of some sort -- should be filed
+         as a Mono bug I guess).  Just scan for parameters names
+         that aren't within quotes.
+         - That wasn't even being called.  Now it is.
+         - Marshaling for sqlite3_bind_parameter_name was wrong, as
+         was the unicode call to bind_text16 which was looking for
+         byte length of string while we were providing char length.
+         - Bind byte[] parameters as blobs.
+         - Trim the SQL string.  Trailing spaces makes it think
+         another statement is coming along.
+       * SqliteDataReader.cs: When DATE/DATETIME columns come
+         back as Int64s, return them using DateTime.FromFileTime.
+         And don't return Int64s as ints if they aren't in the
+         range of an int.
+         - Check column names case-insensitively (bug 77272).
+       * SqliteParameter.cs: Public parameter names made nicer.
+       * SqliteParameterCollection.cs: Allow users to set parameter
+         names with or without the : prefix that Sqlite wants.
+       * Sqlite.cs: Supporting changes.
+       * SqliteDataReader, SqliteConnection: ToLower with the
+         invariant culture (bug 77372).
+
 2006-01-20  Joshua Tauberer  <[EMAIL PROTECTED]>
 
        * Sqlite3 calls now use unicode encoding.  Sqlite2

Modified: 
trunk/mcs/class/Mono.Data.SqliteClient/Mono.Data.SqliteClient/Sqlite.cs
===================================================================
--- trunk/mcs/class/Mono.Data.SqliteClient/Mono.Data.SqliteClient/Sqlite.cs     
2006-01-29 15:08:01 UTC (rev 56226)
+++ trunk/mcs/class/Mono.Data.SqliteClient/Mono.Data.SqliteClient/Sqlite.cs     
2006-01-29 16:43:14 UTC (rev 56227)
@@ -193,7 +193,7 @@
                internal static extern int sqlite3_bind_parameter_count (IntPtr 
pStmt);
 
                [DllImport ("sqlite3")]
-               internal static extern String sqlite3_bind_parameter_name 
(IntPtr pStmt, int n);
+               internal static extern IntPtr sqlite3_bind_parameter_name 
(IntPtr pStmt, int n); // UTF-8 encoded return
 
                [DllImport ("sqlite3")]
                internal static extern SqliteError sqlite3_bind_blob (IntPtr 
pStmt, int n, byte[] blob, int length, IntPtr freetype);
@@ -205,7 +205,7 @@
                internal static extern SqliteError sqlite3_bind_int (IntPtr 
pStmt, int n, int value);
 
                [DllImport ("sqlite3")]
-               internal static extern SqliteError sqlite3_bind_int64 (IntPtr 
pStmt, Int64 n, long value);
+               internal static extern SqliteError sqlite3_bind_int64 (IntPtr 
pStmt, int n, long value);
 
                [DllImport ("sqlite3")]
                internal static extern SqliteError sqlite3_bind_null (IntPtr 
pStmt, int n);

Modified: 
trunk/mcs/class/Mono.Data.SqliteClient/Mono.Data.SqliteClient/SqliteCommand.cs
===================================================================
--- 
trunk/mcs/class/Mono.Data.SqliteClient/Mono.Data.SqliteClient/SqliteCommand.cs  
    2006-01-29 15:08:01 UTC (rev 56226)
+++ 
trunk/mcs/class/Mono.Data.SqliteClient/Mono.Data.SqliteClient/SqliteCommand.cs  
    2006-01-29 16:43:14 UTC (rev 56227)
@@ -58,8 +58,6 @@
                private SqliteParameterCollection sql_params;
                private bool prepared = false;
 
-               static Regex v2Parameters = new 
Regex(@"(('[^']*?\:[^']*')*[^':]*?)*(?<param>:\w+)+([^':]*?('[^']*?\:[^']*'))*",
 RegexOptions.ExplicitCapture);
-
                #endregion
 
                #region Constructors and destructors
@@ -98,7 +96,7 @@
                public string CommandText 
                {
                        get { return sql; }
-                       set { sql = value; }
+                       set { sql = value; prepared = false; }
                }
                
                public int CommandTimeout
@@ -173,29 +171,6 @@
                                return 
Sqlite.sqlite_changes(parent_conn.Handle);
                }
                
-               private string ReplaceParams(Match m)
-               {
-                       string input = m.Value;                                 
                                                                               
-                       if (m.Groups["param"].Success)
-                       {
-                               Group g = m.Groups["param"];
-                               string find = g.Value;
-                               //FIXME: sqlite works internally only with 
strings, so this assumtion is mostly legit, but what about date formatting, etc?
-                               //Need to fix SqlLiteDataReader first to 
acurately describe the tables
-                               SqliteParameter sqlp = Parameters[find];
-                               string replace = Convert.ToString(sqlp.Value);
-                               if(sqlp.DbType == DbType.String)
-                               {
-                                       replace =  "\"" + replace + "\"";
-                               }
-                               
-                               input = Regex.Replace(input,find,replace);
-                               return input;
-                       }
-                       else
-                       return m.Value;
-               }
-               
                private void BindParameters3 (IntPtr pStmt)
                {
                        if (sql_params == null) return;
@@ -205,8 +180,16 @@
 
                        for (int i = 1; i <= pcount; i++) 
                        {
-                               String name = 
Sqlite.sqlite3_bind_parameter_name (pStmt, i);
+                               String name = Sqlite.HeapToString 
(Sqlite.sqlite3_bind_parameter_name (pStmt, i), Encoding.UTF8);
+                               if (name == null) continue;
+                               
                                SqliteParameter param = sql_params[name];
+                               
+                               if (param.Value == null) {
+                                       Sqlite.sqlite3_bind_null (pStmt, i);
+                                       continue;
+                               }
+                                       
                                Type ptype = param.Value.GetType ();
                                
                                SqliteError err;
@@ -214,7 +197,7 @@
                                if (ptype.Equals (typeof (String))) 
                                {
                                        String s = (String)param.Value;
-                                       err = Sqlite.sqlite3_bind_text16 
(pStmt, i, s, s.Length, (IntPtr)(-1));
+                                       err = Sqlite.sqlite3_bind_text16 
(pStmt, i, s, -1, (IntPtr)(-1));
                                } 
                                else if (ptype.Equals (typeof (DBNull))) 
                                {
@@ -269,6 +252,10 @@
                                {
                                        err = Sqlite.sqlite3_bind_int64 (pStmt, 
i, (Int64)param.Value);
                                } 
+                               else if (ptype.Equals (typeof (Byte[]))) 
+                               {
+                                       err = Sqlite.sqlite3_bind_blob (pStmt, 
i, (Byte[])param.Value, ((Byte[])param.Value).Length, (IntPtr)(-1));
+                               } 
                                else 
                                {
                                        throw new ApplicationException("Unkown 
Parameter Type");
@@ -350,21 +337,35 @@
                {
                }
                
-               public string ProcessParameters()
+               public string BindParameters2()
                {
-                       string processedText = sql;
-
-                       //Regex looks odd perhaps, but it works - same impl. as 
in the firebird db provider
-                       //the named parameters are using the ADO.NET standard 
@-prefix but sqlite is considering ":" as a prefix for v.3...
-                       //ref: 
http://www.mail-archive.com/[email protected]/msg01851.html
-                       //Regex r = new Regex(@"(('[^'[EMAIL 
PROTECTED]']*')*[^'@]*?)*(?<param>@\w+)+([^'@]*?('[^'[EMAIL 
PROTECTED]']*'))*",RegexOptions.ExplicitCapture);
+                       string text = sql;
                        
-                       //The above statement is true for the commented regEx, 
but I changed it to use the :-prefix, because now (12.05.2005 sqlite3) 
-                       //sqlite is using : as Standard Parameterprefix
+                       // There used to be a crazy regular expression here, 
but it caused Mono
+                       // to go into an infinite loop of some sort when there 
were no parameters
+                       // in the SQL string.  That was too complicated anyway.
                        
-                       MatchEvaluator me = new MatchEvaluator(ReplaceParams);
-                       processedText = v2Parameters.Replace(sql, me);
-                       return processedText;
+                       // Here we search for substrings of the form :wwwww 
where w is a letter or digit
+                       // (not sure what a legitimate Sqlite3 identifier is), 
except those within quotes.
+                       
+                       char inquote = (char)0;
+                       for (int i = 0; i < text.Length; i++) {
+                               char c = text[i];
+                               if (c == inquote) {
+                                       inquote = (char)0;
+                               } else if (inquote == (char)0 && (c == '\'' || 
c == '"')) {
+                                       inquote = c;
+                               } else if (inquote == (char)0 && c == ':') {
+                                       int start = i;
+                                       while (++i < text.Length && 
char.IsLetterOrDigit(text[i])) { } // scan to end
+                                       string name = text.Substring(start, 
i-start);
+                                       string value = "'" + 
Convert.ToString(Parameters[name].Value).Replace("'", "''") + "'";
+                                       text = text.Replace(name, value);
+                                       i += value.Length - name.Length - 1;
+                               }
+                       }
+                       
+                       return text;
                }
                
                public void Prepare ()
@@ -378,7 +379,7 @@
                
                        if (Parameters.Count > 0 && parent_conn.Version == 2)
                        {
-                               sql = ProcessParameters();
+                               sql = BindParameters2();
                        }
                        
                        prepared = true;
@@ -435,6 +436,8 @@
                
                public SqliteDataReader ExecuteReader (CommandBehavior 
behavior, bool want_results, out int rows_affected)
                {
+                       Prepare ();
+                       
                        // The SQL string may contain multiple sql commands, so 
the main
                        // thing to do is have Sqlite iterate through the 
commands.
                        // If want_results, only the last command is returned 
as a
@@ -458,9 +461,9 @@
                        // For Sqlite 3, we use the UTF-16 prepare function, so 
we need a UTF-16 string.
                        
                        if (parent_conn.Version == 2)
-                               psql = Sqlite.StringToHeap (sql, 
parent_conn.Encoding);
+                               psql = Sqlite.StringToHeap (sql.Trim(), 
parent_conn.Encoding);
                        else
-                               psql = Marshal.StringToCoTaskMemUni (sql);
+                               psql = Marshal.StringToCoTaskMemUni 
(sql.Trim());
 
                        IntPtr pzTail = psql;
                        IntPtr errMsgPtr;

Modified: 
trunk/mcs/class/Mono.Data.SqliteClient/Mono.Data.SqliteClient/SqliteConnection.cs
===================================================================
--- 
trunk/mcs/class/Mono.Data.SqliteClient/Mono.Data.SqliteClient/SqliteConnection.cs
   2006-01-29 15:08:01 UTC (rev 56226)
+++ 
trunk/mcs/class/Mono.Data.SqliteClient/Mono.Data.SqliteClient/SqliteConnection.cs
   2006-01-29 16:43:14 UTC (rev 56227)
@@ -143,9 +143,9 @@
                                        if (arg_pieces.Length != 2) {
                                                throw new 
InvalidOperationException ("Invalid connection string");
                                        }
-                                       string token = arg_pieces[0].ToLower 
().Trim ();
+                                       string token = arg_pieces[0].ToLower 
(System.Globalization.CultureInfo.InvariantCulture).Trim ();
                                        string tvalue = arg_pieces[1].Trim ();
-                                       string tvalue_lc = 
arg_pieces[1].ToLower ().Trim ();
+                                       string tvalue_lc = 
arg_pieces[1].ToLower (System.Globalization.CultureInfo.InvariantCulture).Trim 
();
                                        if (token == "uri") {
                                                if (tvalue_lc.StartsWith 
("file://")) {
                                                        db_file = 
tvalue.Substring (7);

Modified: 
trunk/mcs/class/Mono.Data.SqliteClient/Mono.Data.SqliteClient/SqliteDataReader.cs
===================================================================
--- 
trunk/mcs/class/Mono.Data.SqliteClient/Mono.Data.SqliteClient/SqliteDataReader.cs
   2006-01-29 15:08:01 UTC (rev 56226)
+++ 
trunk/mcs/class/Mono.Data.SqliteClient/Mono.Data.SqliteClient/SqliteDataReader.cs
   2006-01-29 16:43:14 UTC (rev 56227)
@@ -46,7 +46,7 @@
                private SqliteCommand command;
                private ArrayList rows;
                private string[] columns;
-               private Hashtable column_names;
+               private Hashtable column_names_sens, column_names_insens;
                private int current_row;
                private bool closed;
                private bool reading;
@@ -61,7 +61,8 @@
                {
                        command = cmd;
                        rows = new ArrayList ();
-                       column_names = new Hashtable ();
+                       column_names_sens = new Hashtable ();
+                       column_names_insens = new Hashtable 
(CaseInsensitiveHashCodeProvider.DefaultInvariant, 
CaseInsensitiveComparer.DefaultInvariant);
                        closed = false;
                        current_row = -1;
                        reading = true;
@@ -82,7 +83,9 @@
                }
                
                public object this[string name] {
-                       get { return GetValue ((int) column_names[name]); }
+                       get {
+                               return GetValue (GetOrdinal (name));
+                       }
                }
                
                public object this[int i] {
@@ -124,7 +127,7 @@
                                                for (int i = 0; i < pN; i++) {
                                                        IntPtr decl = 
Sqlite.sqlite3_column_decltype16 (pVm, i);
                                                        if (decl != 
IntPtr.Zero) {
-                                                               decltypes[i] = 
Marshal.PtrToStringUni (decl).ToLower();
+                                                               decltypes[i] = 
Marshal.PtrToStringUni 
(decl).ToLower(System.Globalization.CultureInfo.InvariantCulture);
                                                                if 
(decltypes[i] == "int" || decltypes[i] == "integer")
                                                                        
declmode[i] = 1;
                                                                else if 
(decltypes[i] == "date" || decltypes[i] == "datetime")
@@ -143,7 +146,8 @@
                                                        colName = 
Marshal.PtrToStringUni (Sqlite.sqlite3_column_name16 (pVm, i));
                                                }
                                                columns[i] = colName;
-                                               column_names [colName] = i;
+                                               column_names_sens [colName] = i;
+                                               column_names_insens [colName] = 
i;
                                        }
                                }
 
@@ -157,12 +161,21 @@
                                        } else {
                                                switch 
(Sqlite.sqlite3_column_type (pVm, i)) {
                                                        case 1:
+                                                               long val = 
Sqlite.sqlite3_column_int64 (pVm, i);
+                                                       
                                                                // If the 
column was declared as an 'int' or 'integer', let's play
                                                                // nice and 
return an int (version 3 only).
-                                                               if (declmode[i] 
== 1)
-                                                                       
data_row[i] = (int)Sqlite.sqlite3_column_int64 (pVm, i);
+                                                               if (declmode[i] 
== 1 && val >= int.MinValue && val <= int.MaxValue)
+                                                                       
data_row[i] = (int)val;
+                                                               
+                                                               // Or if it was 
declared a date or datetime, do the reverse of what we
+                                                               // do for 
DateTime parameters.
+                                                               else if 
(declmode[i] == 2)
+                                                                       
data_row[i] = DateTime.FromFileTime(val);
+                                                               
                                                                else
-                                                                       
data_row[i] = Sqlite.sqlite3_column_int64 (pVm, i);
+                                                                       
data_row[i] = val;
+                                                                       
                                                                break;
                                                        case 2:
                                                                data_row[i] = 
Sqlite.sqlite3_column_double (pVm, i);
@@ -393,7 +406,12 @@
                
                public int GetOrdinal (string name)
                {
-                       return (int) column_names[name];
+                       object v = column_names_sens[name];
+                       if (v == null)
+                               v = column_names_insens[name];
+                       if (v == null)
+                               throw new ArgumentException("Column does not 
exist.");
+                       return (int) v;
                }
                
                public string GetString (int i)

Modified: 
trunk/mcs/class/Mono.Data.SqliteClient/Mono.Data.SqliteClient/SqliteParameter.cs
===================================================================
--- 
trunk/mcs/class/Mono.Data.SqliteClient/Mono.Data.SqliteClient/SqliteParameter.cs
    2006-01-29 15:08:01 UTC (rev 56226)
+++ 
trunk/mcs/class/Mono.Data.SqliteClient/Mono.Data.SqliteClient/SqliteParameter.cs
    2006-01-29 16:43:14 UTC (rev 56227)
@@ -59,26 +59,26 @@
                        direction = ParameterDirection.Input;
                }
                
-               public SqliteParameter (string name_in, DbType type_in)
+               public SqliteParameter (string name, DbType type)
                {
-                       name = name_in;
-                       type = type_in;
+                       this.name = name;
+                       this.type = type;
                }
                
-               public SqliteParameter (string name_in, object param_value_in)
+               public SqliteParameter (string name, object value)
                {
-                       name = name_in;
+                       this.name = name;
                        type = DbType.String;
-                       param_value = param_value_in;
+                       param_value = value;
                        direction = ParameterDirection.Input;
                }
                
-               public SqliteParameter (string name_in, DbType type_in, int 
size_in) : this (name_in, type_in)
+               public SqliteParameter (string name, DbType type, int size) : 
this (name, type)
                {
-                       size = size_in;
+                       this.size = size;
                }
                
-               public SqliteParameter (string name_in, DbType type_in, int 
size, string src_column) : this (name_in ,type_in)
+               public SqliteParameter (string name, DbType type, int size, 
string src_column) : this (name ,type, size)
                {
                        source_column = src_column;
                }

Modified: 
trunk/mcs/class/Mono.Data.SqliteClient/Mono.Data.SqliteClient/SqliteParameterCollection.cs
===================================================================
--- 
trunk/mcs/class/Mono.Data.SqliteClient/Mono.Data.SqliteClient/SqliteParameterCollection.cs
  2006-01-29 15:08:01 UTC (rev 56226)
+++ 
trunk/mcs/class/Mono.Data.SqliteClient/Mono.Data.SqliteClient/SqliteParameterCollection.cs
  2006-01-29 16:43:14 UTC (rev 56227)
@@ -112,12 +112,19 @@
                        }
                }
                
+               private bool isPrefixed (string parameterName)
+               {
+                       return parameterName.Length > 1 && (parameterName[0] == 
':' || parameterName[0] == '$');
+               }
+               
                public SqliteParameter this[string parameterName] 
                {
                        get 
                        {
                                if (this.Contains(parameterName))
                                        return this[(int) 
named_param_hash[parameterName]];
+                               else if (isPrefixed(parameterName) && 
this.Contains(parameterName.Substring(1)))
+                                       return this[(int) 
named_param_hash[parameterName.Substring(1)]];
                                else
                                        throw new IndexOutOfRangeException("The 
specified name does not exist: " + parameterName);
                        }
@@ -125,6 +132,8 @@
                        {
                                if (this.Contains(parameterName))
                                        numeric_param_list[(int) 
named_param_hash[parameterName]] = value;
+                               else if (parameterName.Length > 1 && 
this.Contains(parameterName.Substring(1)))
+                                       numeric_param_list[(int) 
named_param_hash[parameterName.Substring(1)]] = value;
                                else
                                        throw new IndexOutOfRangeException("The 
specified name does not exist: " + parameterName);
                        }

Modified: 
trunk/mcs/class/Mono.Data.SqliteClient/Mono.Data.SqliteClient_test.dll.sources
===================================================================
--- 
trunk/mcs/class/Mono.Data.SqliteClient/Mono.Data.SqliteClient_test.dll.sources  
    2006-01-29 15:08:01 UTC (rev 56226)
+++ 
trunk/mcs/class/Mono.Data.SqliteClient/Mono.Data.SqliteClient_test.dll.sources  
    2006-01-29 16:43:14 UTC (rev 56227)
@@ -1,2 +1,7 @@
+SqliteCommandUnitTests.cs
 SqliteConnectionTest.cs
+SqliteDataAdapterUnitTests.cs
 SqliteDataReaderTest.cs
+SqliteExceptionUnitTests.cs
+SqliteParameterUnitTests.cs
+

Modified: trunk/mcs/class/Mono.Data.SqliteClient/Test/ChangeLog
===================================================================
--- trunk/mcs/class/Mono.Data.SqliteClient/Test/ChangeLog       2006-01-29 
15:08:01 UTC (rev 56226)
+++ trunk/mcs/class/Mono.Data.SqliteClient/Test/ChangeLog       2006-01-29 
16:43:14 UTC (rev 56227)
@@ -1,3 +1,7 @@
+2006-01-29  Joshua Tauberer <[EMAIL PROTECTED]>
+
+       * Added tests from Thomas Zoechling <[EMAIL PROTECTED]>.
+
 2006-01-02  Joshua Tauberer <[EMAIL PROTECTED]>
 
        * SqliteTest.cs: Cleaned up and added new stuff.

Added: trunk/mcs/class/Mono.Data.SqliteClient/Test/SqliteCommandUnitTests.cs
===================================================================
--- trunk/mcs/class/Mono.Data.SqliteClient/Test/SqliteCommandUnitTests.cs       
2006-01-29 15:08:01 UTC (rev 56226)
+++ trunk/mcs/class/Mono.Data.SqliteClient/Test/SqliteCommandUnitTests.cs       
2006-01-29 16:43:14 UTC (rev 56227)
@@ -0,0 +1,194 @@
+// SqliteDataAdapterUnitTests.cs - NUnit Test Cases for 
Mono.Data.SqliteClient.SqliteDataAdapter
+//
+// Author(s):  Thomas Zoechling <[EMAIL PROTECTED]>
+
+
+using System;
+using System.Data;
+using System.IO;
+using System.Text;
+using Mono.Data.SqliteClient;
+using NUnit.Framework;
+
+namespace MonoTests.Mono.Data.SqliteClient
+{
+       
+       [TestFixture]
+       public class SqliteCommandUnitTests
+       {
+               readonly static string _uri = "SqliteTest.db";
+               readonly static string _connectionString = "URI=file://" + _uri 
+ ", version=3";
+               static SqliteConnection _conn = new SqliteConnection 
(_connectionString);
+               readonly static string stringvalue = "my keyboard is better 
than yours : ����";
+
+               public SqliteCommandUnitTests()
+               {
+               }
+               
+               [Test]
+               public void Create()
+               {
+                       try
+                       {
+                               if(File.Exists(_uri))
+                               {
+                                       _conn.Dispose();
+                                       // We want to start with a fresh db for 
each full run
+                                       // The database is created on the first 
open()
+                                       File.Delete(_uri);
+
+                               }
+                       }
+                       catch(Exception e)
+                       {
+                               throw e;
+                       }
+                       
+                       SqliteCommand createCommand = new SqliteCommand("CREATE 
TABLE t1(t  TEXT,  f FLOAT, i INTEGER, b TEXT);",_conn);
+                       SqliteCommand insertCommand = new SqliteCommand("INSERT 
INTO t1  (t, f, i, b ) VALUES('" + stringvalue + "',123,123,'123')",_conn);
+
+                       try
+                       {
+                               _conn.Open();
+                               createCommand.ExecuteNonQuery();
+                               insertCommand.ExecuteNonQuery();
+                       }
+                       catch(Exception e)
+                       {
+                               throw new AssertionException("Create table 
failed",e);
+                       }
+                       finally
+                       {
+                               _conn.Close();  
+                       }
+               }
+               
+               [Test]  
+               public void Select()
+               {
+                       SqliteCommand simpleSelect = new SqliteCommand("SELECT 
* FROM t1;  ", _conn); // check trailing spaces
+                       using(_conn)
+                       {
+                               _conn.Open();
+                               SqliteDataReader dr = 
simpleSelect.ExecuteReader();
+                               while(dr.Read())
+                               {
+                                       string test = dr[0].ToString();
+                                       Assert.AreEqual(dr["T"], stringvalue); 
// also checks case-insensitive column
+                                       Assert.AreEqual(dr["F"], 123);
+                                       Assert.AreEqual(dr["I"], 123);
+                                       Assert.AreEqual(dr["B"], "123");
+                               }
+                               Assert.IsTrue(dr.FieldCount>0);
+                       }
+               }
+               
+               [Test]
+               public void Delete()
+               {
+                       SqliteCommand insCmd = new SqliteCommand("INSERT INTO 
t1 VALUES ('todelete',0.1,0,'')",_conn);
+                       SqliteCommand delCmd = new SqliteCommand("DELETE FROM 
t1 WHERE t = 'todelete'",_conn);
+                       using(_conn)
+                       {
+                               _conn.Open();
+                               int insReturn = insCmd.ExecuteNonQuery();
+                               int delReturn = delCmd.ExecuteNonQuery();
+                       
+                               Assert.IsTrue(insReturn == delReturn);
+                       }
+               }
+               
+               [Test]
+               public void Insert()
+               {
+                       SqliteCommand insCmd = new SqliteCommand("INSERT INTO 
t1 VALUES ('inserted',0.1,0,'')",_conn);
+                       using(_conn)
+                       {
+                               _conn.Open();
+                               int insReturn = insCmd.ExecuteNonQuery();
+                               Assert.IsTrue(insReturn == 1);
+                       }
+               }
+               
+               [Test]
+               public void Update()
+               {
+                       SqliteCommand insCmd = new SqliteCommand("INSERT INTO 
t1 VALUES ('toupdate',0.1,0,'')",_conn);
+                       SqliteCommand updCmd = new SqliteCommand("UPDATE t1 SET 
t = 'updated' ,f = 2.0, i = 2, b = '' WHERE t = 'toupdate'",_conn);
+                       using(_conn)
+                       {
+                               _conn.Open();
+                               insCmd.ExecuteNonQuery();
+                               Assert.IsTrue(updCmd.ExecuteNonQuery() == 1);
+                       }
+               }
+
+               
+               [Test]
+               public void ScalarReturn()
+               {
+                       // This should return the 1 line that got inserted in 
CreateTable() Test
+                       SqliteCommand cmd = new SqliteCommand("SELECT COUNT(*) 
FROM t1 WHERE  t LIKE '%����'",_conn);
+                       using(_conn)
+                       {
+                               _conn.Open();
+                               Assert.AreEqual(1, 
Convert.ToInt32(cmd.ExecuteScalar()));
+                       }
+               }
+               
+               [Test]
+               public void InsertWithTransaction()
+               {
+                       _conn.Open();
+                       SqliteTransaction t = _conn.BeginTransaction() as 
SqliteTransaction;
+                       SqliteCommand  c1 = new SqliteCommand("INSERT INTO t1 
VALUES ('a',0.1,0,'0')",_conn,t);
+                       SqliteCommand  c2 = new SqliteCommand("INSERT INTO t1 
VALUES ('b',1.2,0,'0')",_conn,t);
+                       SqliteCommand  c3 = new SqliteCommand("INSERT INTO t1 
VALUES ('c',0.3,1,'0')",_conn,t);
+                       SqliteCommand  c4 = new SqliteCommand("INSERT INTO t1 
VALUES ('d',0.4,0,'1')",_conn,t);
+                       using(_conn)
+                       {
+                               try
+                               {
+                                       c1.ExecuteNonQuery();
+                                       c2.ExecuteNonQuery();
+                                       c3.ExecuteNonQuery();
+                                       c4.ExecuteNonQuery();
+                                       t.Commit();
+                               }
+                               catch(Exception e)
+                               {
+                                       t.Rollback();
+                                       throw new AssertionException("Sqlite 
Commands failed", e);
+                               }
+                       }
+               }
+               
+               [Test]
+               [ExpectedException(typeof(SqliteSyntaxException))]
+               public void InsertWithFailingTransaction()
+               {
+                       _conn.Open();
+                       SqliteTransaction t = _conn.BeginTransaction() as 
SqliteTransaction;
+                       SqliteCommand  c1 = new SqliteCommand("INSERT INTO t1 
VALUES ('1','0','0','0')",_conn,t);
+                       SqliteCommand  c2 = new SqliteCommand("INSERT INTO t1 
VALUES ('0','1','0','0')",_conn,t);
+                       SqliteCommand  c3 = new SqliteCommand("INSERT INTO t1 
VALUES ('x',?,'x',?,'x',?,'x')",_conn,t);
+                       SqliteCommand  c4 = new SqliteCommand("INSERT INTO t1 
VALUES ('0','0','0','1')",_conn,t);
+                       using(_conn)
+                       {
+                               try
+                               {
+                                       c1.ExecuteNonQuery();
+                                       c2.ExecuteNonQuery();
+                                       c3.ExecuteNonQuery();
+                                       c4.ExecuteNonQuery();
+                                       t.Commit();
+                               }
+                               catch(Exception e)
+                               {
+                                       t.Rollback();
+                                       throw e;
+                               }
+                       }
+               }
+       }
+}
\ No newline at end of file

Modified: trunk/mcs/class/Mono.Data.SqliteClient/Test/SqliteConnectionTest.cs
===================================================================
--- trunk/mcs/class/Mono.Data.SqliteClient/Test/SqliteConnectionTest.cs 
2006-01-29 15:08:01 UTC (rev 56226)
+++ trunk/mcs/class/Mono.Data.SqliteClient/Test/SqliteConnectionTest.cs 
2006-01-29 16:43:14 UTC (rev 56227)
@@ -65,7 +65,8 @@
                         Assert.AreEqual ("xyz", _conn.Database, "#1 file path 
is wrong");
                 }
 
-                [Test]
+                               // behavior has changed, I guess
+                //[Test]
                 [Ignore ("opening a connection should not create db! though, 
leave for now")]
                 public void OpenTest ()
                 {

Added: trunk/mcs/class/Mono.Data.SqliteClient/Test/SqliteDataAdapterUnitTests.cs
===================================================================
--- trunk/mcs/class/Mono.Data.SqliteClient/Test/SqliteDataAdapterUnitTests.cs   
2006-01-29 15:08:01 UTC (rev 56226)
+++ trunk/mcs/class/Mono.Data.SqliteClient/Test/SqliteDataAdapterUnitTests.cs   
2006-01-29 16:43:14 UTC (rev 56227)
@@ -0,0 +1,155 @@
+// SqliteDataAdapterUnitTests.cs - NUnit Test Cases for 
Mono.Data.SqliteClient.SqliteDataAdapter
+//
+// Author(s):  Thomas Zoechling <[EMAIL PROTECTED]>
+
+
+using System;
+using System.Data;
+using System.IO;
+using System.Text;
+using Mono.Data.SqliteClient;
+using NUnit.Framework;
+
+namespace MonoTests.Mono.Data.SqliteClient
+{
+       [TestFixture]
+       public class SqliteDataAdapterUnitTests
+       {
+               readonly static string _uri = "SqliteTest.db";
+               readonly static string _connectionString = "URI=file://" + _uri 
+ ", version=3";
+               static SqliteConnection _conn = new SqliteConnection 
(_connectionString);
+        
+               static SqliteDataAdapter PrepareDataAdapter()
+               {
+                       SqliteCommand select  = new SqliteCommand("SELECT t, f, 
i, b FROM t1",_conn);
+                       SqliteCommand update = new SqliteCommand("UPDATE t1 SET 
t = :textP, f = :floatP, i = :integerP, n=:blobP WHERE t = :textP ");
+                       update.Connection=_conn;
+                       SqliteCommand delete = new SqliteCommand("DELETE FROM 
t1 WHERE t = :textP");
+                       delete.Connection=_conn;
+                       SqliteCommand insert = new SqliteCommand("INSERT INTO 
t1  (t, f, i, b ) VALUES(:textP,:floatP,:integerP,:blobP)");
+                       insert.Connection=_conn;
+                       SqliteDataAdapter custDA = new 
SqliteDataAdapter(select);
+               
+                       SqliteParameter textP = new SqliteParameter();
+                       textP.ParameterName = "textP";
+                       textP.SourceColumn = "t";
+               
+                       SqliteParameter floatP = new SqliteParameter();
+                       floatP.ParameterName = "floatP";
+                       floatP.SourceColumn = "f";
+               
+                       SqliteParameter integerP = new SqliteParameter();
+                       integerP.ParameterName ="integerP";
+                       integerP.SourceColumn = "i";
+
+                       SqliteParameter blobP = new SqliteParameter();
+                       blobP.ParameterName = "blobP";
+                       blobP.SourceColumn = "b";
+               
+                       update.Parameters.Add(textP);
+                       update.Parameters.Add(floatP);
+                       update.Parameters.Add(integerP);
+                       update.Parameters.Add(blobP);
+               
+                       delete.Parameters.Add(textP);
+               
+                       insert.Parameters.Add(textP);
+                       insert.Parameters.Add(floatP);
+                       insert.Parameters.Add(integerP);
+                       insert.Parameters.Add(blobP);
+               
+                       custDA.UpdateCommand = update;
+                       custDA.DeleteCommand = delete;
+                       custDA.InsertCommand = insert;
+               
+                       return custDA;
+               }
+
+               [Test]
+               public void GetSchemaTable()
+               {
+                       _conn.ConnectionString = _connectionString;
+                       SqliteDataReader reader = null;
+                       using (_conn) 
+                       {
+                               _conn.Open ();
+                               SqliteCommand cmd = _conn.CreateCommand ();
+                               cmd.CommandText = "select * from t1";
+                               reader = cmd.ExecuteReader ();
+                               try 
+                               {
+                                       DataTable dt = reader.GetSchemaTable ();
+                                       Assert.IsNotNull (dt, "#GS1 should 
return valid table");
+                                       Assert.IsTrue (dt.Rows.Count > 0, "#GS2 
should return with rows ;-)");
+                               }
+                               finally 
+                               {
+                                       if (reader != null && !reader.IsClosed)
+                                               reader.Close ();
+                                       _conn.Close ();
+                               }
+                       }
+               }
+
+               [Test]
+               public void DataAdapterRandomValues()
+               {
+                       SqliteDataAdapter da = PrepareDataAdapter();
+                       DataSet ds = new DataSet();
+                       int i = 0;
+                       Random random = new Random();
+                       using(_conn)
+                       {
+                               _conn.Open();
+                               da.Fill(ds);
+                               for(; i<300;i++)
+                               {
+                                       DataRow dr = ds.Tables[0].NewRow();
+                                       
+                                       foreach(DataColumn dc in 
ds.Tables[0].Columns)
+                                       {
+                                               switch(dc.DataType.Name)
+                                               {
+                                                       case "String":
+                                                       {
+                                                               int ml=0;
+                                                               
if(dc.MaxLength!=-1)
+                                                               {
+                                                                       
ml=dc.MaxLength;
+                                                               }
+                                                               else
+                                                               {
+                                                                       ml=256;
+                                                               }
+                                                               StringBuilder 
builder = new StringBuilder(ml);
+                                                               for (int k=0; k 
< random.Next(ml); k++)
+                                                               {
+                                                                       
builder.Append((char)random.Next(65536));
+                                               
+                                                               }
+                                                               string curs = 
builder.ToString();
+                                                               dr[dc]=curs;
+                                                               break;
+                                                       }
+
+                                                       case "Int32":
+                                                       {
+                                                               
dr[dc]=random.Next(65536);
+                                                               break;
+                                                       }
+
+                                                       case "Int64":
+                                                       {
+                                                               
dr[dc]=Convert.ToInt64(random.Next(65536));
+                                                               break;
+                                                       }
+                                               }
+                                       }
+                                       ds.Tables[0].Rows.Add(dr);
+                               }
+                               int res = da.Update(ds);
+                               Assert.AreEqual(i,res);
+                       }
+               }
+       }
+}
\ No newline at end of file

Added: trunk/mcs/class/Mono.Data.SqliteClient/Test/SqliteExceptionUnitTests.cs
===================================================================
--- trunk/mcs/class/Mono.Data.SqliteClient/Test/SqliteExceptionUnitTests.cs     
2006-01-29 15:08:01 UTC (rev 56226)
+++ trunk/mcs/class/Mono.Data.SqliteClient/Test/SqliteExceptionUnitTests.cs     
2006-01-29 16:43:14 UTC (rev 56227)
@@ -0,0 +1,39 @@
+// SqliteExceptionUnitTests.cs - NUnit Test Cases for 
Mono.Data.SqliteClient.SqliteExceptions
+//
+// Author(s):  Thomas Zoechling <[EMAIL PROTECTED]>
+
+
+using System;
+using System.Data;
+using System.IO;
+using System.Text;
+using Mono.Data.SqliteClient;
+using NUnit.Framework;
+
+namespace MonoTests.Mono.Data.SqliteClient
+{
+       [TestFixture]
+       public class SqliteExceptionUnitTests
+       {
+               readonly static string _uri = "SqliteTest.db";
+               readonly static string _connectionString = "URI=file://" + _uri 
+ ", version=3";
+               static SqliteConnection _conn = new SqliteConnection 
(_connectionString);
+
+               public SqliteExceptionUnitTests()
+               {
+               }
+               
+               [Test]
+               [ExpectedException(typeof(SqliteSyntaxException))]
+               public void WrongSyntax()
+               {
+                       SqliteCommand insertCmd = new SqliteCommand("INSERT 
INTO t1 VALUES (,')",_conn);
+                       using(_conn)
+                       {
+                               _conn.Open();
+                               int res = insertCmd.ExecuteNonQuery();
+                               Assert.AreEqual(res,1);
+                       }
+               }
+       }
+}

Added: trunk/mcs/class/Mono.Data.SqliteClient/Test/SqliteParameterUnitTests.cs
===================================================================
--- trunk/mcs/class/Mono.Data.SqliteClient/Test/SqliteParameterUnitTests.cs     
2006-01-29 15:08:01 UTC (rev 56226)
+++ trunk/mcs/class/Mono.Data.SqliteClient/Test/SqliteParameterUnitTests.cs     
2006-01-29 16:43:14 UTC (rev 56227)
@@ -0,0 +1,83 @@
+// SqliteParameterUnitTests.cs - NUnit Test Cases for 
Mono.Data.SqliteClient.SqliteParameter
+//
+// Author(s):  Thomas Zoechling <[EMAIL PROTECTED]>
+
+
+using System;
+using System.Data;
+using System.IO;
+using System.Text;
+using Mono.Data.SqliteClient;
+using NUnit.Framework;
+
+namespace MonoTests.Mono.Data.SqliteClient
+{
+       [TestFixture]
+       public class SqliteParameterUnitTests
+       {
+               readonly static string _uri = "SqliteTest.db";
+               readonly static string _connectionString = "URI=file://" + _uri 
+ ", version=3";
+               static SqliteConnection _conn = new SqliteConnection 
(_connectionString);
+
+               public SqliteParameterUnitTests()
+               {
+               }
+               
+               [Test]
+               public void InsertRandomValuesWithParameter()
+               {
+                       SqliteParameter textP = new SqliteParameter();
+                       textP.ParameterName = "textP";
+                       textP.SourceColumn = "t";
+               
+                       SqliteParameter floatP = new SqliteParameter();
+                       floatP.ParameterName = "floatP";
+                       floatP.SourceColumn = "nu";
+               
+                       SqliteParameter integerP = new SqliteParameter();
+                       integerP.ParameterName ="integerP";
+                       integerP.SourceColumn = "i";
+
+                       SqliteParameter blobP = new SqliteParameter();
+                       blobP.ParameterName = "blobP";
+                       blobP.SourceColumn = "b";
+
+                       Random random = new Random();
+                       StringBuilder builder = new StringBuilder();
+                       for (int k=0; k < random.Next(0,100); k++)
+                       {
+                               builder.Append((char)random.Next(65536));
+                       }
+                       
+                       SqliteCommand insertCmd = new SqliteCommand("DELETE 
FROM t1; INSERT INTO t1  (t, f, i, b ) 
VALUES(:textP,:floatP,:integerP,:blobP)",_conn);
+                       
+                       insertCmd.Parameters.Add(textP);
+                       insertCmd.Parameters.Add(floatP);
+                       insertCmd.Parameters.Add(blobP);
+                       insertCmd.Parameters.Add(integerP);
+                       
+                       textP.Value=builder.ToString();
+                       floatP.Value=Convert.ToInt64(random.Next(999));
+                       integerP.Value=random.Next(999);
+                       
blobP.Value=System.Text.Encoding.UTF8.GetBytes("\u05D0\u05D1\u05D2" + 
builder.ToString());
+                       
+                       SqliteCommand selectCmd = new SqliteCommand("SELECT * 
from t1", _conn);
+
+                       using(_conn)
+                       {
+                               _conn.Open();
+                               int res = insertCmd.ExecuteNonQuery();
+                               Assert.AreEqual(res,1);
+                               
+                               using (IDataReader reader = 
selectCmd.ExecuteReader()) {
+                                       Assert.AreEqual(reader.Read(), true);
+                                       Assert.AreEqual(reader["t"], 
textP.Value);
+                                       Assert.AreEqual(reader["f"], 
floatP.Value);
+                                       Assert.AreEqual(reader["i"], 
integerP.Value);
+                                       Assert.AreEqual(reader["b"], 
blobP.Value);
+                                       Assert.AreEqual(reader.Read(), false);
+                               }
+                       }
+               }
+       }
+}

Modified: trunk/mcs/class/Mono.Data.SqliteClient/Test/SqliteTest.cs
===================================================================
--- trunk/mcs/class/Mono.Data.SqliteClient/Test/SqliteTest.cs   2006-01-29 
15:08:01 UTC (rev 56226)
+++ trunk/mcs/class/Mono.Data.SqliteClient/Test/SqliteTest.cs   2006-01-29 
16:43:14 UTC (rev 56227)
@@ -53,9 +53,9 @@
                        string connectionString =
                                "URI=file:SqliteTest.db";
                        if (v3)
-                               connectionString += ",Version=3";
+                               connectionString += ",Version=3";
                        if (utf8)
-                               connectionString += ",encoding=UTF-8";
+                               connectionString += ",encoding=UTF-8";
                        dbcon.ConnectionString = connectionString;
                                
                        dbcon.Open();
@@ -67,22 +67,25 @@
                                "CREATE TABLE MONO_TEST ( " +
                                "NID INT, " +
                                "NDESC TEXT, " +
-                               "NTIME DATETIME); " +
+                               "NTIME DATETIME); " +
                                "INSERT INTO MONO_TEST  " +
-                               "(NID, NDESC, NTIME )"+
+                               "(NID, NDESC, NTIME) " +
                                "VALUES(1,'One" + ((v3 || utf8) ? " (unicode 
test: \u05D0)" : "") + "', '2006-01-01')";
                        Console.WriteLine("Create & insert modified rows = 1: " 
+ dbcmd.ExecuteNonQuery());
 
                        dbcmd.CommandText =
                                "INSERT INTO MONO_TEST  " +
-                               "(NID, NDESC, NTIME )"+
-                               "VALUES(2,'Two', '2006-01-02')";
-                       Console.WriteLine("Insert modified rows and ID = 1, 2: 
" + dbcmd.ExecuteNonQuery() + " , " + dbcmd.LastInsertRowID());
+                               "(NID, NDESC, NTIME) " +
+                               "VALUES(:NID,:NDESC,:NTIME)";
+                       dbcmd.Parameters.Add( new SqliteParameter("NID", 2) );
+                       dbcmd.Parameters.Add( new SqliteParameter(":NDESC", 
"Two" + ((v3 || utf8) ? " (unicode test: \u05D1)" : "")) );
+                       dbcmd.Parameters.Add( new SqliteParameter(":NTIME", 
DateTime.Now) );
+                       Console.WriteLine("Insert modified rows with parameters 
= 1, 2: " + dbcmd.ExecuteNonQuery() + " , " + dbcmd.LastInsertRowID());
 
                        dbcmd.CommandText =
                                "INSERT INTO MONO_TEST  " +
-                               "(NID, NDESC, NTIME )"+
-                               "VALUES(3,'Three-followed-by-null', NULL)";
+                               "(NID, NDESC, NTIME) " +
+                               "VALUES(3,'Three, quoted parameter test, and 
next is null; :NTIME', NULL)";
                        Console.WriteLine("Insert with null modified rows and 
ID = 1, 3: " + dbcmd.ExecuteNonQuery() + " , " + dbcmd.LastInsertRowID());
 
                        dbcmd.CommandText =
@@ -100,7 +103,7 @@
                        Console.WriteLine("read and display a scalar = 'Two': " 
+ dbcmd.ExecuteScalar());
 
                        dbcmd.CommandText = "SELECT count(*) FROM MONO_TEST";
-                       Console.WriteLine("read and display a non-column scalar 
= 2: " + dbcmd.ExecuteScalar());
+                       Console.WriteLine("read and display a non-column scalar 
= 3: " + dbcmd.ExecuteScalar());
 
                        Console.WriteLine("read and display data using 
DataAdapter/DataSet...");
                        SqliteDataAdapter adapter = new 
SqliteDataAdapter("SELECT * FROM MONO_TEST", connectionString);

_______________________________________________
Mono-patches maillist  -  [email protected]
http://lists.ximian.com/mailman/listinfo/mono-patches

Reply via email to