System.Data.SQLite

  Tests/function.eagle
  Tests/installer.eagle
  Tests/linq.eagle
  Tests/memory.eagle
  Tests/pool.eagle
  Tests/progress.eagle
  Tests/pst-4db2934c2e.eagle
  Tests/pst-76cb35b58d.eagle
  Tests/pst-eeaefb84ec.eagle
  Tests/pst-f4e718891d.eagle
  Tests/session.eagle
  Tests/speed.eagle
  Tests/stress.eagle
  Tests/template/
  Tests/template/empty.eagle

/********************************************************
 * ADO.NET 2.0 Data Provider for SQLite Version 3.X
 * Written by Robert Simpson (robert@blackcastlesoft.com)
 *
 * Released to the public domain, use at your own risk!
 ********************************************************/

namespace System.Data.SQLite
{
  using System;
  using System.Data;
  using System.Data.Common;
  using System.ComponentModel;
  using System.Globalization;

  /// <summary>
  /// SQLite implementation of DbParameter.
  /// </summary>
  public sealed class SQLiteParameter : DbParameter, ICloneable
  {
    /// <summary>

    {
        _command = command;
    }

    /// <summary>
    /// Default constructor
    /// </summary>
    public SQLiteParameter()
      : this(null, UnknownDbType, 0, null, DataRowVersion.Current)
    {
    }

    /// <summary>
    /// Constructs a named parameter given the specified parameter name
    /// </summary>

    /// Constructs a named parameter of the specified type, size, source column and row version
    /// </summary>
    /// <param name="parameterName">The name of the parameter</param>
    /// <param name="parameterType">The data type</param>
    /// <param name="parameterSize">The size of the parameter</param>
    /// <param name="sourceColumn">The source column</param>
    /// <param name="rowVersion">The row version information</param>
    public SQLiteParameter(string parameterName, DbType parameterType, int parameterSize, string sourceColumn, DataRowVersion rowVersion)
    {
      _parameterName = parameterName;
      _dbType = parameterType;
      _sourceColumn = sourceColumn;
      _rowVersion = rowVersion;
      _dataSize = parameterSize;
      _nullable = true;

    /// <param name="parameterSize">The size of the parameter</param>
    /// <param name="direction">Only input parameters are supported in SQLite</param>
    /// <param name="isNullable">Ignored</param>
    /// <param name="precision">Ignored</param>
    /// <param name="scale">Ignored</param>
    /// <param name="sourceColumn">The source column</param>
    /// <param name="rowVersion">The row version information</param>
    /// <param name="value">The initial value to assign the parameter</param>
#if !PLATFORM_COMPACTFRAMEWORK
    [EditorBrowsable(EditorBrowsableState.Advanced)]
#endif
    public SQLiteParameter(string parameterName, DbType parameterType, int parameterSize, ParameterDirection direction, bool isNullable, byte precision, byte scale, string sourceColumn, DataRowVersion rowVersion, object value)
      : this(parameterName, parameterType, parameterSize, sourceColumn, rowVersion)
    {
      Direction = direction;

    /// </summary>
    public IDbCommand Command
    {
      get
      {
        return _command;
      }
      set
      {
        _command = value;
      }
    }

    /// <summary>
    /// Whether or not the parameter can contain a null value
    /// </summary>
    public override bool IsNullable
    {
      get
      {
        return _nullable;
      }
      set
      {
        _nullable = value;
      }
    }

    /// <summary>
    /// Returns the datatype of the parameter

    /// <returns>A new, unassociated SQLiteParameter</returns>
    public object Clone()
    {
      SQLiteParameter newparam = new SQLiteParameter(this);

      return newparam;
    }

    /// <summary>
    /// Attempts to build a name suitable for use with an index-only
    /// (unnamed) parameter.
    /// </summary>
    /// <param name="index">The index for the parameter.</param>
    /// <param name="placeholder">
    /// Non-zero if the returned name should be a placeholder, i.e.
    /// an unnamed parameter that does not use a syntax supported by
    /// the SQLite core library.
    /// </param>
    /// <returns>The built name -OR- null if it cannot be built.</returns>
    internal static string CreateNameForIndex(int index, bool placeholder)
    {
        return HelperMethods.StringFormat(CultureInfo.InvariantCulture,
            placeholder ? ";{0}" : "?{0}", index + 1);
    }

    /// <summary>
    /// Returns non-zero if the specified parameter name appears to
    /// refer to an unnamed parameter placeholder.
    /// </summary>
    /// <param name="name">
    /// The parameter name to check.
    /// </param>
    /// <param name="index">
    /// The parameter index or negative one if it cannot be determined.
    /// </param>
    /// <returns>
    /// Non-zero if the specified parameter name represents an unnamed
    /// placeholder parameter.
    /// </returns>
    internal static bool IsUnnamedPlaceholder(string name, out int index)
    {
        index = -1;

        if (String.IsNullOrEmpty(name))
            return false;

        if (name[0] != ';')
            return false;

        return int.TryParse(
            name.Substring(1), NumberStyles.None, null, out index);
    }
  }
}

      string s;
      int n;
      int y = -1;
      SQLiteStatement stmt;

      foreach(SQLiteParameter p in _parameterList)
      {
        y++;
        s = p.ParameterName;
        if (String.IsNullOrEmpty(s))
        {
          s = SQLiteParameter.CreateNameForIndex(nUnnamed, true);
          nUnnamed++;
        }

        int x;
        bool isMapped = false;

        if (activeStatement == null)

          stmt = null;
        }

        // If the parameter has a name, but the SQL statement uses unnamed references, this can happen -- attempt to map
        // the parameter by its index in the collection
        if (isMapped == false)
        {
          s = SQLiteParameter.CreateNameForIndex(y, true);

          stmt = activeStatement;
          for (n = 0; n < x; n++)
          {
            if (stmt == null) stmt = _command._statementList[n];
            if (stmt._paramNames != null)
            {
              if (stmt.MapParameter(s, p) ||
                  stmt.MapUnnamedParameter(s, p))
              {
                isMapped = true;
              }
            }
            stmt = null;
          }
        }
      }
      if (activeStatement == null) _unboundFlag = false;
    }
  }
}

        _paramValues = new SQLiteParameter[n];

        for (x = 0; x < n; x++)
        {
          s = _sql.Bind_ParamName(this, _flags, x + 1);
          if (String.IsNullOrEmpty(s))
          {
            s = SQLiteParameter.CreateNameForIndex(nCmdStart, true);
            nCmdStart++;
            _unnamedParameters++;
          }
          _paramNames[x] = s;
          _paramValues[x] = null;
        }
      }

        if ((_sql != null) && _sql.IsOpen())
        {
            changes = _sql.Changes;
            readOnly = _sql.IsReadOnly(this);

            return true;
        }

        return false;
    }

    ///////////////////////////////////////////////////////////////////////////////////////////////

    /// <summary>
    /// This method attempts to map the specified named placeholder
    /// parameter, i.e. an unnamed parameter that has been given an
    /// placeholder name.
    /// </summary>
    /// <param name="s">The placeholder parameter name to map.</param>
    /// <param name="p">The parameter to assign it.</param>
    internal bool MapUnnamedParameter(string s, SQLiteParameter p)
    {
        if (_paramNames == null)
            return false;

        int index;

        if (SQLiteParameter.IsUnnamedPlaceholder(s, out index))
        {
            s = String.Format("?{0}", s.Substring(index));

            int length = s.Length;
            int count = _paramNames.Length;

            for (int n = 0; n < count; n++)
            {
                if (String.Compare(
                      _paramNames[n], 0, s, 0, length,
                      StringComparison.Ordinal) == 0)
                {
                    _paramValues[n] = p;
                    return true;
                }
            }
        }

        return false;
    }

    ///////////////////////////////////////////////////////////////////////////////////////////////

    /// <summary>

###############################################################################
#
# pst-76cb35b58d.eagle --
#
# Written by Joe Mistachkin.
# Released to the public domain, use at your own risk!
#
###############################################################################

package require Eagle
package require Eagle.Library
package require Eagle.Test

runTestPrologue

###############################################################################

package require System.Data.SQLite.Test
runSQLiteTestPrologue

###############################################################################

runTest {test pst-76cb35b58d-1.1 {unnamed parameters "duplicates"} -setup {
  setupDb [set fileName pst-76cb35b58d-1.1.db]
} -body {
  sql execute $db {
    CREATE TABLE t1(x INTEGER, y TEXT);
    INSERT INTO t1 (x, y) VALUES(1, 'one');
    INSERT INTO t1 (x, y) VALUES(2, 'two');
    INSERT INTO t1 (x, y) VALUES(3, 'three');
  }

  set param1 [list "" Int64 99]

  sql execute $db "INSERT INTO t1 (x, y) VALUES(4, 'four');" $param1
  sql execute $db "INSERT INTO t1 (x, y) VALUES(5, ?1);" $param1

  set param1 [list "" Int64 6]

  sql execute $db "INSERT INTO t1 (x, y) VALUES(?1, ?1);" $param1

  sql execute -execute reader -format list $db \
      "SELECT x, y FROM t1 ORDER BY x;"
} -cleanup {
  cleanupDb $fileName

  unset -nocomplain param1
  unset -nocomplain db fileName
} -constraints {eagle command.object monoBug28 command.sql compile.DATA SQLite\
System.Data.SQLite} -result {1 one 2 two 3 three 4 four 5 99 6 6}}

###############################################################################

runSQLiteTestEpilogue
runTestEpilogue