System.Data.SQLite

      <ReturnType Type="Int32" />
      <Parameter Name="date" Type="DateTimeOffset" Mode="In" />
    </Function>
    <Function Name="DAY" BuiltIn="true">
      <ReturnType Type="Int32" />
      <Parameter Name="date" Type="String" Mode="In" />
    </Function>

    <!-- TOLOCALTIME( date )
            date: smalldatetime, datetime
            returns: datetime
        -->
    <Function Name="TOLOCALTIME" BuiltIn="true">
      <ReturnType Type="DateTime" />
      <Parameter Name="date" Type="DateTime" Mode="In" />
    </Function>
    <Function Name="TOLOCALTIME" BuiltIn="true">
      <ReturnType Type="DateTime" />
      <Parameter Name="date" Type="DateTimeOffset" Mode="In" />
    </Function>
    <Function Name="TOLOCALTIME" BuiltIn="true">
      <ReturnType Type="DateTime" />
      <Parameter Name="date" Type="String" Mode="In" />
    </Function>

    <!-- TOUNIVERSALTIME( date )
            date: smalldatetime, datetime
            returns: datetime
        -->
    <Function Name="TOUNIVERSALTIME" BuiltIn="true">
      <ReturnType Type="DateTime" />
      <Parameter Name="date" Type="DateTime" Mode="In" />
    </Function>
    <Function Name="TOUNIVERSALTIME" BuiltIn="true">
      <ReturnType Type="DateTime" />
      <Parameter Name="date" Type="DateTimeOffset" Mode="In" />
    </Function>
    <Function Name="TOUNIVERSALTIME" BuiltIn="true">
      <ReturnType Type="DateTime" />
      <Parameter Name="date" Type="String" Mode="In" />
    </Function>

    <!-- GETDATE()
            returns: datetime   
        -->
    <Function Name="GETDATE" BuiltIn="true">
      <ReturnType Type="DateTime"/>
    </Function>

    {
      Dictionary<string, FunctionHandler> functionHandlers = new Dictionary<string, FunctionHandler>(7, StringComparer.Ordinal);
      functionHandlers.Add("CONCAT", HandleConcatFunction);
      functionHandlers.Add("DATEPART", HandleDatepartDateFunction);
      functionHandlers.Add("DatePart", HandleDatepartDateFunction);
      functionHandlers.Add("GETDATE", HandleGetDateFunction);
      functionHandlers.Add("GETUTCDATE", HandleGetUtcDateFunction);
      functionHandlers.Add("TOLOCALTIME", HandleToLocalTimeFunction);
      functionHandlers.Add("TOUNIVERSALTIME", HandleToUniversalTimeFunction);
      return functionHandlers;
    }

    /// <summary>
    /// All special non-aggregate canonical functions and their handlers
    /// </summary>
    /// <returns></returns>

    {
      SqlBuilder result = new SqlBuilder();
      Debug.Assert(e.Arguments.Count == 0, "Canonical getdate function should have no arguments");

      switch (sqlgen._manifest._dateFormat)
      {
        case SQLiteDateFormats.Ticks:
          result.Append("(STRFTIME('%s', 'now', 'localtime') * 10000000 + 621355968000000000)");
          break;
        case SQLiteDateFormats.JulianDay:
          result.Append("CAST(STRFTIME('%J', 'now', 'localtime') AS double)");
          break;
        case SQLiteDateFormats.UnixEpoch:
          result.Append("STRFTIME('%s', 'now', 'localtime')");
          break;
        case SQLiteDateFormats.InvariantCulture:
        case SQLiteDateFormats.CurrentCulture:
          result.Append("STRFTIME('%Y-%m-%dT%H:%M:%fZ', 'now', 'localtime')");
          break;
        default:
          result.Append("STRFTIME('%Y-%m-%d %H:%M:%S', 'now', 'localtime')");
          break;
      }

      return result;
    }

    private static ISqlFragment HandleGetUtcDateFunction(SqlGenerator sqlgen, DbFunctionExpression e)
    {
      SqlBuilder result = new SqlBuilder();
      Debug.Assert(e.Arguments.Count == 0, "Canonical getutcdate function should have no arguments");

      switch (sqlgen._manifest._dateFormat)
      {
        case SQLiteDateFormats.Ticks:
          result.Append("(STRFTIME('%s', 'now') * 10000000 + 621355968000000000)");
          break;
        case SQLiteDateFormats.JulianDay:
          result.Append("CAST(STRFTIME('%J', 'now') AS double)");
          break;
        case SQLiteDateFormats.UnixEpoch:
          result.Append("STRFTIME('%s', 'now')");
          break;
        case SQLiteDateFormats.InvariantCulture:
        case SQLiteDateFormats.CurrentCulture:
          result.Append("STRFTIME('%Y-%m-%dT%H:%M:%fZ', 'now')");
          break;
        default:
          result.Append("STRFTIME('%Y-%m-%d %H:%M:%S', 'now')");
          break;
      }

      return result;
    }

    private static ISqlFragment HandleToUniversalTimeFunction(SqlGenerator sqlgen, DbFunctionExpression e)
    {
        SqlBuilder result = new SqlBuilder();
        Debug.Assert(e.Arguments.Count == 1, "Canonical touniversaltime function should have exactly one argument");

        switch (sqlgen._manifest._dateFormat)
        {
            case SQLiteDateFormats.Ticks:
                result.Append(String.Format("(STRFTIME('%s', {0}, 'utc') * 10000000 + 621355968000000000)", e.Arguments[0].Accept(sqlgen)));
                break;
            case SQLiteDateFormats.JulianDay:
                result.Append(String.Format("CAST(STRFTIME('%J', {0}, 'utc') AS double)", e.Arguments[0].Accept(sqlgen)));
                break;
            case SQLiteDateFormats.UnixEpoch:
                result.Append(String.Format("STRFTIME('%s', {0}, 'utc')", e.Arguments[0].Accept(sqlgen)));
                break;
            case SQLiteDateFormats.InvariantCulture:
            case SQLiteDateFormats.CurrentCulture:
                result.Append(String.Format("STRFTIME('%Y-%m-%dT%H:%M:%fZ', {0}, 'utc')", e.Arguments[0].Accept(sqlgen)));
                break;
            default:
                result.Append(String.Format("STRFTIME('%Y-%m-%d %H:%M:%S', {0}, 'utc')", e.Arguments[0].Accept(sqlgen)));
                break;
        }

        return result;
    }

    private static ISqlFragment HandleToLocalTimeFunction(SqlGenerator sqlgen, DbFunctionExpression e)
    {
        SqlBuilder result = new SqlBuilder();
        Debug.Assert(e.Arguments.Count == 1, "Canonical tolocaltime function should have exactly one argument");

        switch (sqlgen._manifest._dateFormat)
        {
            case SQLiteDateFormats.Ticks:
                result.Append(String.Format("(STRFTIME('%s', {0}, 'localtime') * 10000000 + 621355968000000000)", e.Arguments[0].Accept(sqlgen)));
                break;
            case SQLiteDateFormats.JulianDay:
                result.Append(String.Format("CAST(STRFTIME('%J', {0}, 'localtime') AS double)", e.Arguments[0].Accept(sqlgen)));
                break;
            case SQLiteDateFormats.UnixEpoch:
                result.Append(String.Format("STRFTIME('%s', {0}, 'localtime')", e.Arguments[0].Accept(sqlgen)));
                break;
            case SQLiteDateFormats.InvariantCulture:
            case SQLiteDateFormats.CurrentCulture:
                result.Append(String.Format("STRFTIME('%Y-%m-%dT%H:%M:%fZ', {0}, 'localtime')", e.Arguments[0].Accept(sqlgen)));
                break;
            default:
                result.Append(String.Format("STRFTIME('%Y-%m-%d %H:%M:%S', {0}, 'localtime')", e.Arguments[0].Accept(sqlgen)));
                break;
        }

        return result;
    }

    /// <summary>
    /// Handles special case in which datepart 'type' parameter is present. all the functions
    /// handles here have *only* the 1st parameter as datepart. datepart value is passed along
    /// the QP as string and has to be expanded as TSQL keyword.
    /// </summary>
    /// <param name="sqlgen"></param>

        result.Append("', ");

        switch (sqlgen._manifest._dateFormat)
        {
          case SQLiteDateFormats.Ticks:
            result.Append(String.Format("(({0} - 621355968000000000) / 10000000.0)", e.Arguments[1].Accept(sqlgen)));
            break;
          case SQLiteDateFormats.UnixEpoch:
            result.Append(String.Format("{0}, 'unixepoch'", e.Arguments[1].Accept(sqlgen)));
            break;
          default:
            result.Append(e.Arguments[1].Accept(sqlgen));
            break;
        }

        result.Append(") AS integer)");
      }
      else
      {
        result.Append("CAST(SUBSTR(STRFTIME('%f', ");

        switch (sqlgen._manifest._dateFormat)
        {
          case SQLiteDateFormats.Ticks:
            result.Append(String.Format("(({0} - 621355968000000000) / 10000000.0)", e.Arguments[1].Accept(sqlgen)));
            break;
          case SQLiteDateFormats.UnixEpoch:
            result.Append(String.Format("{0}, 'unixepoch'", e.Arguments[1].Accept(sqlgen)));
            break;
          default:
            result.Append(e.Arguments[1].Accept(sqlgen));
            break;
        }

        result.Append("), 4) AS integer)");
      }

      {
        case SQLiteDateFormats.Ticks:
          result.Append(String.Format("(STRFTIME('%s', JULIANDAY({1}) + ({0} / 86400.0)) * 10000000 + 621355968000000000)", e.Arguments[0].Accept(sqlgen), e.Arguments[1].Accept(sqlgen)));
          break;
        case SQLiteDateFormats.JulianDay:
          result.Append(String.Format("CAST(STRFTIME('%J', JULIANDAY({1}) + ({0} / 86400.0)) AS double)", e.Arguments[0].Accept(sqlgen), e.Arguments[1].Accept(sqlgen)));
          break;
        case SQLiteDateFormats.UnixEpoch:
          result.Append(String.Format("(STRFTIME('%s', JULIANDAY({1}) + ({0} / 86400.0)))", e.Arguments[0].Accept(sqlgen), e.Arguments[1].Accept(sqlgen)));
          break;
        default:
          result.Append(String.Format("STRFTIME('%Y-%m-%d %H:%M:%S', JULIANDAY({1}) + ({0} / 86400.0))", e.Arguments[0].Accept(sqlgen), e.Arguments[1].Accept(sqlgen)));
          break;
      }

      return result;
    }

      Debug.Assert(e.Arguments.Count == 2, "Canonical datepart functions should have exactly two arguments");

      switch (sqlgen._manifest._dateFormat)
      {
        case SQLiteDateFormats.Ticks:
          result.Append(String.Format("CAST((({0} - 621355968000000000) / 10000000.0)  - (({1} - 621355968000000000) / 10000000.0) * 86400.0 AS integer)", e.Arguments[0].Accept(sqlgen), e.Arguments[1].Accept(sqlgen)));
          break;
        case SQLiteDateFormats.UnixEpoch:
          result.Append(String.Format("CAST(({0} - {1}) * 86400.0 AS integer)", e.Arguments[0].Accept(sqlgen), e.Arguments[1].Accept(sqlgen)));
          break;
        default:
          result.Append(String.Format("CAST((JULIANDAY({1}) - JULIANDAY({0})) * 86400.0 AS integer)", e.Arguments[0].Accept(sqlgen), e.Arguments[1].Accept(sqlgen)));
          break;
      }

      return result;
    }

      Debug.Assert(e.Arguments.Count == 1, "Canonical datepart functions should have exactly one argument");

      switch (sqlgen._manifest._dateFormat)
      {
        case SQLiteDateFormats.Ticks:
          result.Append(String.Format("(({0} - 621355968000000000) / 10000000.0)", e.Arguments[0].Accept(sqlgen)));
          break;
        case SQLiteDateFormats.UnixEpoch:
          result.Append(String.Format("{0}, 'unixepoch'", e.Arguments[0].Accept(sqlgen)));
          break;
        default:
          result.Append(e.Arguments[0].Accept(sqlgen));
          break;
      }

      result.Append(") AS integer)");

      _dateFormat = (SQLiteDateFormats)Enum.Parse(typeof(SQLiteDateFormats), manifestToken, true);
    }

    internal static XmlReader GetProviderManifest()
    {
      return GetXmlResource("System.Data.SQLite.Linq.Resources.SQLiteProviderServices.ProviderManifest.xml");
    }

    /// <summary>
    /// Returns or sets the date/time format in use for this instance.
    /// </summary>
    internal SQLiteDateFormats DateTimeFormat
    {
        get { return _dateFormat; }
        set { _dateFormat = value; }
    }

    /// <summary>
    /// Returns manifest information for the provider
    /// </summary>
    /// <param name="informationType">The name of the information to be retrieved.</param>
    /// <returns>An XmlReader at the begining of the information requested.</returns>
    protected override XmlReader GetDbInformation(string informationType)

      byte[] b = ToUTF8(value);
      int n = UnsafeNativeMethods.sqlite3_bind_text(stmt._sqlite_stmt, index, b, b.Length - 1, (IntPtr)(-1));
      if (n > 0) throw new SQLiteException(n, SQLiteLastError());
    }

    internal override void Bind_DateTime(SQLiteStatement stmt, int index, DateTime dt)
    {
      byte[] b = ToBindUTF8(dt);
      int n = UnsafeNativeMethods.sqlite3_bind_text(stmt._sqlite_stmt, index, b, b.Length - 1, (IntPtr)(-1));
      if (n > 0) throw new SQLiteException(n, SQLiteLastError());
    }

    internal override void Bind_Blob(SQLiteStatement stmt, int index, byte[] blobData)
    {
      int n = UnsafeNativeMethods.sqlite3_bind_blob(stmt._sqlite_stmt, index, blobData, blobData.Length, (IntPtr)(-1));

      {
        if (_sql == null)
          throw new InvalidOperationException("Database connection not valid for getting number of changes.");

        return _sql.Changes;
      }
    }

    /// <summary>
    /// Returns or sets the date/time format currently in use for this connection.
    /// </summary>
#if !PLATFORM_COMPACTFRAMEWORK
    [Browsable(false), DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
#endif
    public SQLiteDateFormats DateTimeFormat
    {
        get {
            if (_sql == null)
                throw new InvalidOperationException("Database connection not valid for getting date/time format.");

            return _sql.DateTimeFormat;
        }
        set
        {
            if (_sql == null)
                throw new InvalidOperationException("Database connection not valid for setting date/time format.");

            _sql.DateTimeFormat = value;
        }
    }

    /// <summary>
    /// Returns the version of the underlying SQLite database engine
    /// </summary>
    public static string SQLiteVersion
    {
      get { return SQLite3.SQLiteVersion; }

  {
    /// <summary>
    /// The value for the Unix epoch (e.g. January 1, 1970 at midnight, in UTC).
    /// </summary>
    private static readonly DateTime UnixEpoch =
        new DateTime(1970, 1, 1, 0, 0, 0, DateTimeKind.Utc);

    /// <summary>
    /// The most complete human-readable time string format natively understood by SQLite.
    /// </summary>
    private const string BindFormat = "yyyy-MM-ddTHH:mm:ss.fff";

    /// <summary>
    /// The format string for DateTime values when using the InvariantCulture or CurrentCulture formats.
    /// </summary>
    private const string FullFormat = "yyyy-MM-ddTHH:mm:ss.fffffffK";

    /// <summary>
    /// An array of ISO8601 datetime formats we support conversion from

    /// Initializes the conversion class
    /// </summary>
    /// <param name="fmt">The default date/time format to use for this instance</param>
    internal SQLiteConvert(SQLiteDateFormats fmt)
    {
      _datetimeFormat = fmt;
    }

    #region Public Properties
    /// <summary>
    /// Returns or sets the date/time format currently in use for this instance.
    /// </summary>
    public SQLiteDateFormats DateTimeFormat
    {
        get { return _datetimeFormat; }
        set { _datetimeFormat = value; }
    }
    #endregion

    #region UTF-8 Conversion Functions
    /// <summary>
    /// Converts a string to a UTF-8 encoded byte array sized to include a null-terminating character.
    /// </summary>
    /// <param name="sourceText">The string to convert to UTF-8</param>
    /// <returns>A byte array containing the converted string plus an extra 0 terminating byte at the end of the array.</returns>

    /// </remarks>
    /// <param name="dateTimeValue">The DateTime to convert.</param>
    /// <returns>The UTF-8 encoded string, including a 0 terminating byte at the end of the array.</returns>
    public byte[] ToUTF8(DateTime dateTimeValue)
    {
      return ToUTF8(ToString(dateTimeValue));
    }

    /// <summary>
    /// Convert a DateTime to a UTF-8 encoded, zero-terminated byte array.
    /// </summary>
    /// <remarks>
    /// This function is a convenience function, which first calls ToBindString() on the DateTime, and then calls ToUTF8() with
    /// the string result.
    /// </remarks>
    /// <param name="dateTimeValue">The DateTime to convert.</param>
    /// <returns>The UTF-8 encoded string, including a 0 terminating byte at the end of the array.</returns>
    public byte[] ToBindUTF8(DateTime dateTimeValue)
    {
      return ToUTF8(ToBindString(dateTimeValue));
    }

    /// <summary>
    /// Converts a UTF-8 encoded IntPtr of the specified length into a .NET string
    /// </summary>
    /// <param name="nativestring">The pointer to the memory where the UTF-8 string is encoded</param>
    /// <param name="nativestringlen">The number of bytes to decode</param>
    /// <returns>A string containing the translated character(s)</returns>

    /// <param name="dateText">The string containing either a long integer number of 100-nanosecond units since
    /// System.DateTime.MinValue, a Julian day double, an integer number of seconds since the Unix epoch, a
    /// culture-independent formatted date and time string, a formatted date and time string in the current
    /// culture, or an ISO8601-format string.</param>
    /// <returns>A DateTime value</returns>
    public DateTime ToDateTime(string dateText)
    {
      //
      // NOTE: First, try to interpret the string as a correctly formatted date.
      //
      DateTime result;

      if (DateTime.TryParseExact(dateText, _datetimeFormats, DateTimeFormatInfo.InvariantInfo, DateTimeStyles.None, out result))
      {
        return result;
      }

      switch (_datetimeFormat)
      {
        case SQLiteDateFormats.Ticks:
          return new DateTime(Convert.ToInt64(dateText, CultureInfo.InvariantCulture));
        case SQLiteDateFormats.JulianDay:
          return ToDateTime(Convert.ToDouble(dateText, CultureInfo.InvariantCulture));
        case SQLiteDateFormats.UnixEpoch:

    /// </summary>
    /// <param name="value">The DateTime to convert</param>
    /// <returns>The JulianDay value the Datetime represents</returns>
    public double ToJulianDay(DateTime value)
    {
      return value.ToOADate() + 2415018.5;
    }

    /// <summary>
    /// Converts a DateTime to a string value suitable for binding to a query parameter.
    /// </summary>
    /// <param name="dateValue">The DateTime value to convert</param>
    /// <returns>An ISO8601 formatted date/time string in the invariant culture.</returns>
    public string ToBindString(DateTime dateValue)
    {
      return dateValue.ToString(BindFormat, CultureInfo.InvariantCulture);
    }

    /// <summary>
    /// Converts a DateTime to a string value, using the current DateTimeFormat specified for the connection when it was opened.
    /// </summary>
    /// <param name="dateValue">The DateTime value to convert</param>
    /// <returns>Either a string containing the long integer number of 100-nanosecond units since System.DateTime.MinValue, a
    /// Julian day double, an integer number of seconds since the Unix epoch, a culture-independent formatted date and time

  cleanupDb $fileName

  unset -nocomplain name rows result db fileName
} -constraints {eagle monoBug28 command.sql compile.DATA System.Data.SQLite} \
-result [subst {{1 {{x 1} {y2 {Wednesday, 16 December 2009}}}} {2 {{x 2} {y2\
12:00:00}}} {3 {{x 3} {y2 {Wednesday, 16 December 2009 12:00:00}}}} {4 {{x 4}\
{y2 12/16/2009}}} {5 {{x 5} {y2 12:00}}} {6 {{x 6} {y2 {12/16/2009 12:00}}}} {7\
{{x 7} {y2 2009-12-16T00:00:00.000}}} {8 {{x 8} {y2\
${date}T12:00:00.000}}} {9 {{x 9} {y2 2009-12-16T12:00:00.000}}} {10 {{x 10}\
{y2 2009-12-16T00:00:00.000}}} {11 {{x 11} {y2 ${date}T12:00:00.000}}} {12 {{x\
12} {y2 2009-12-16T12:00:00.000}}}}]}

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

runTest {test basic-1.14 {DateTime using current culture} -setup {
  setupDb [set fileName basic-1.14.db] "" "" "DateTimeFormat=CurrentCulture;"
} -body {
  set result [list]

  unset -nocomplain db fileName
} -constraints \
{eagle culture.en_US monoBug28 command.sql compile.DATA System.Data.SQLite} \
-result [subst {{1 {{x 1} {y2 {Wednesday, 16 December 2009}}}} {2 {{x 2} {y2\
12:00:00}}} {3 {{x 3} {y2 {Wednesday, 16 December 2009 12:00:00}}}} {4 {{x 4}\
{y2 12/16/2009}}} {5 {{x 5} {y2 12:00}}} {6 {{x 6} {y2 {12/16/2009 12:00}}}} {7\
{{x 7} {y2 2009-12-16T00:00:00.000}}} {8 {{x 8} {y2\
${date}T12:00:00.000}}} {9 {{x 9} {y2 2009-12-16T12:00:00.000}}} {10 {{x 10}\
{y2 2009-12-16T00:00:00.000}}} {11 {{x 11} {y2 ${date}T12:00:00.000}}} {12 {{x\
12} {y2 2009-12-16T12:00:00.000}}}}]}

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

runTest {test basic-1.15 {other date/time functions for LINQ} -setup {
  set formats [list Ticks ISO8601 JulianDay UnixEpoch \
                    InvariantCulture CurrentCulture]

  # 1996-07-04 00:00:00|1996-08-01 00:00:00
  # 1998-05-06 00:00:00|1998-06-03 00:00:00
  # 11078|ALFKI|1|2003-01-02 04:05:06.789|
  # 2009-08-07 06:05:04.321|1999-12-25 23:59:42.654|0||||||

  set prefix "SELECT VALUE o FROM Orders AS o WHERE"

  set queries [list \
      "SQLite.GetDate() >= SQLite.ToLocalTime(@dt) AND o.OrderID = 11078;" \
      "SQLite.GetUtcDate() >= @dt AND o.OrderID = 11078;" \
      "Year(SQLite.GetDate()) == Year(@dt) AND o.OrderID = 11078;" \
      "Month(SQLite.GetDate()) == Month(@dt) AND o.OrderID = 11078;" \
      "Day(SQLite.GetDate()) == Day(@dt) AND o.OrderID = 11078;" \
      "Hour(o.OrderDate) == 4 AND o.OrderID = 11078;" \
      "Minute(o.OrderDate) == 5 AND o.OrderID = 11078;" \
      "Second(o.OrderDate) == 6 AND o.OrderID = 11078;"]
} -body {
  set result [list]

  foreach format $formats {
    foreach query $queries {
      set code [catch {
        testExec $testLinqExeFile [list -eventflags Wait -directory \
        [file dirname $testLinqExeFile] -nocarriagereturns -stdout output \
        -success 0] -dateTime [appendArgs \" $format \"] [appendArgs \" \
        $prefix " " $query \"] [appendArgs \" \
        [expr {[string first @dt $query] != -1 ? $date : ""}] \"]
      } error]

      tlog "---- BEGIN STDOUT OUTPUT\n"
      tlog $output
      tlog "\n---- END STDOUT OUTPUT\n"

      lappend result $code

      if {$code == 0} then {
        lappend result [string trim $output]
      } else {
        lappend result [string trim $error]
      }
    }
  }

  set result
} -cleanup {
  unset -nocomplain prefix format formats query queries
  unset -nocomplain code output error result
} -constraints {eagle file_testlinq.exe file_northwindEF.db} \
-result {}}

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

unset -nocomplain date

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

unset -nocomplain testExeFile testLinqExeFile northwindEfDbFile testLinqOutFile

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

runSQLiteTestEpilogue
runTestEpilogue

3508
8010
05033
1734
1204
13008
87110

Chai
Chang
Chef Anton's Cajun Seasoning
Chef Anton's Gumbo Mix
Uncle Bob's Organic Dried Pears
Guaraná Fantástica
Gumbär Gummibärchen

using System;
using System.Diagnostics;
using System.Linq;
using System.Data.EntityClient;
using System.Data.Objects;
using System.Data.SQLite;
using System.Text;
using System.Transactions;

namespace testlinq
{
  class Program
  {

                  {
                      return OldTests();
                  }
              case "skip":
                  {
                      int pageSize = 0;

                      if ((args.Length > 1) && !String.IsNullOrEmpty(args[1]))
                      {
                          arg = args[1];

                          if (arg != null)
                              pageSize = int.Parse(arg.Trim());
                      }

                      return StartsWithTest(value);
                  }
              case "eftransaction":
                  {
                      bool value = false;

                      if ((args.Length > 1) && !String.IsNullOrEmpty(args[1]))
                      {
                          if (!bool.TryParse(args[1], out value))
                          {
                              Console.WriteLine(
                                  "cannot parse \"{0}\" as boolean",
                                  args[1]);

                              return 1;
                          }
                      }

                      return EFTransactionTest(value);
                  }
              case "datetime":
                  {
                      SQLiteDateFormats dateTimeFormat = SQLiteDateFormats.Default;
                      string queryString = null;
                      DateTime? dateTime = null;

                      if ((args.Length > 1) && !String.IsNullOrEmpty(args[1]))
                      {
                          try
                          {
                              dateTimeFormat = (SQLiteDateFormats)Enum.Parse(
                                  typeof(SQLiteDateFormats), args[1], true);
                          }
                          catch
                          {
                              Console.WriteLine(
                                  "cannot parse \"{0}\" as a date/time format",
                                  args[1]);

                              return 1;
                          }
                      }

                      if (args.Length > 2)
                      {
                          queryString = args[2];

                          if (queryString != null)
                              queryString = queryString.Trim();
                      }

                      if ((args.Length > 3) && !String.IsNullOrEmpty(args[3]))
                      {
                          DateTime dateTimeValue;

                          if (DateTime.TryParse(args[3], out dateTimeValue))
                          {
                              dateTime = DateTime.SpecifyKind(
                                  dateTimeValue, DateTimeKind.Utc);
                          }
                          else
                          {
                              Console.WriteLine(
                                  "cannot parse \"{0}\" as a date/time",
                                  args[3]);

                              return 1;
                          }
                      }

                      return DateTimeTest(dateTimeFormat, queryString, dateTime);
                  }
              default:
                  {
                      Console.WriteLine("unknown test \"{0}\"", arg);
                      return 1;
                  }
          }
      }

                      Console.Write(territories.TerritoryID);

                      once = true;
                  }
              }
          }

          return 0;
      }

      //
      // NOTE: Used to test the various DateTime methods.
      //
      private static int DateTimeTest(
          SQLiteDateFormats dateTimeFormat,
          string queryString,
          DateTime? dateTime
          )
      {
          using (northwindEFEntities db = new northwindEFEntities())
          {
              EntityConnection connection = db.Connection as EntityConnection;

              if (connection == null)
              {
                  Console.WriteLine("not an entity connection");
                  return 1;
              }

              SQLiteConnection storeConnection =
                  connection.StoreConnection as SQLiteConnection;

              if (storeConnection == null)
              {
                  Console.WriteLine("not a SQLite store connection");
                  return 1;
              }

              connection.Open(); /* NOTE: Force open now. */
              storeConnection.DateTimeFormat = dateTimeFormat;

              bool once = false;

              ObjectParameter[] parameters = (dateTime != null) ?
                  new ObjectParameter[] { new ObjectParameter("dt", dateTime) } :
                  new ObjectParameter[] { };

              var query = db.CreateQuery<Orders>(queryString, parameters);

              foreach (Orders orders in query)
              {
                  if (once)
                      Console.Write(' ');

                  Console.Write(orders.OrderID);

                  once = true;
              }
          }

          return 0;
      }

    private static int OldTests()
    {
      using (northwindEFEntities db = new northwindEFEntities())

    <Reference Include="System.Core" />
    <Reference Include="System.Data.Entity" />
    <Reference Include="System.Runtime.Serialization" />
    <Reference Include="System.Transactions" />
    <Reference Include="System.Xml" />
    <Reference Include="System.Data" />
  </ItemGroup>
  <ItemGroup>
    <ProjectReference Include="..\System.Data.SQLite\System.Data.SQLite.2008.csproj">
      <Project>{AC139952-261A-4463-B6FA-AEBC25283A66}</Project>
      <Name>System.Data.SQLite.2008</Name>
    </ProjectReference>
  </ItemGroup>
  <ItemGroup>
    <Compile Include="NorthwindModel2008.Designer.cs">
      <AutoGen>True</AutoGen>
      <DesignTime>True</DesignTime>
      <DependentUpon>NorthwindModel2008.edmx</DependentUpon>
    </Compile>
    <Compile Include="Program.cs" />

    <Reference Include="System" />
    <Reference Include="System.Data.Entity" />
    <Reference Include="System.Runtime.Serialization" />
    <Reference Include="System.Transactions" />
    <Reference Include="System.Xml" />
    <Reference Include="System.Data" />
  </ItemGroup>
  <ItemGroup>
    <ProjectReference Include="..\System.Data.SQLite\System.Data.SQLite.2010.csproj">
      <Project>{AC139952-261A-4463-B6FA-AEBC25283A66}</Project>
      <Name>System.Data.SQLite.2010</Name>
    </ProjectReference>
  </ItemGroup>
  <ItemGroup>
    <Compile Condition="'$(TargetFrameworkVersion)' == 'v3.5'"
             Include="NorthwindModel2008.Designer.cs">
      <AutoGen>True</AutoGen>
      <DesignTime>True</DesignTime>
      <DependentUpon>NorthwindModel2008.edmx</DependentUpon>
    </Compile>