private static string GetDefaultTypeName(SQLiteConnection connection) { if (((connection != null ? connection.Flags : SQLiteConnectionFlags.None) & SQLiteConnectionFlags.NoConvertSettings) == SQLiteConnectionFlags.NoConvertSettings) { return(SQLiteConvert.FallbackDefaultTypeName); } string str = "Use_SQLiteConvert_DefaultTypeName"; object settingValue = null; string str1 = null; if (connection == null || !connection.TryGetCachedSetting(str, str1, out settingValue)) { try { settingValue = UnsafeNativeMethods.GetSettingValue(str, str1) ?? SQLiteConvert.FallbackDefaultTypeName; } finally { if (connection != null) { connection.SetCachedSetting(str, settingValue); } } } return(SQLiteConvert.SettingValueToString(settingValue)); }
public override bool TryGetValue(string keyword, out object value) { bool flag = base.TryGetValue(keyword, out value); if (!this._properties.ContainsKey(keyword)) { return(flag); } PropertyDescriptor item = this._properties[keyword] as PropertyDescriptor; if (item == null) { return(flag); } if (!flag) { DefaultValueAttribute defaultValueAttribute = item.Attributes[typeof(DefaultValueAttribute)] as DefaultValueAttribute; if (defaultValueAttribute != null) { value = defaultValueAttribute.Value; flag = true; } } else if (item.PropertyType == typeof(bool)) { value = SQLiteConvert.ToBoolean(value); } else if (item.PropertyType != typeof(byte[])) { value = TypeDescriptor.GetConverter(item.PropertyType).ConvertFrom(value); } return(flag); }
static SQLiteConvert() { SQLiteConvert.FallbackDefaultTypeName = string.Empty; SQLiteConvert.UnixEpoch = new DateTime(1970, 1, 1, 0, 0, 0, DateTimeKind.Utc); SQLiteConvert.OleAutomationEpochAsJulianDay = 2415018.5; SQLiteConvert.MinimumJd = SQLiteConvert.computeJD(DateTime.MinValue); SQLiteConvert.MaximumJd = SQLiteConvert.computeJD(DateTime.MaxValue); string[] strArrays = new string[] { "THHmmssK", "THHmmK", "HH:mm:ss.FFFFFFFK", "HH:mm:ssK", "HH:mmK", "yyyy-MM-dd HH:mm:ss.FFFFFFFK", "yyyy-MM-dd HH:mm:ssK", "yyyy-MM-dd HH:mmK", "yyyy-MM-ddTHH:mm:ss.FFFFFFFK", "yyyy-MM-ddTHH:mmK", "yyyy-MM-ddTHH:mm:ssK", "yyyyMMddHHmmssK", "yyyyMMddHHmmK", "yyyyMMddTHHmmssFFFFFFFK", "THHmmss", "THHmm", "HH:mm:ss.FFFFFFF", "HH:mm:ss", "HH:mm", "yyyy-MM-dd HH:mm:ss.FFFFFFF", "yyyy-MM-dd HH:mm:ss", "yyyy-MM-dd HH:mm", "yyyy-MM-ddTHH:mm:ss.FFFFFFF", "yyyy-MM-ddTHH:mm", "yyyy-MM-ddTHH:mm:ss", "yyyyMMddHHmmss", "yyyyMMddHHmm", "yyyyMMddTHHmmssFFFFFFF", "yyyy-MM-dd", "yyyyMMdd", "yy-MM-dd" }; SQLiteConvert._datetimeFormats = strArrays; SQLiteConvert._datetimeFormatUtc = SQLiteConvert._datetimeFormats[5]; SQLiteConvert._datetimeFormatLocal = SQLiteConvert._datetimeFormats[19]; SQLiteConvert._utf8 = new UTF8Encoding(); Type[] typeArray = new Type[] { typeof(object), typeof(long), typeof(double), typeof(string), typeof(byte[]), typeof(object), typeof(DateTime), typeof(object) }; SQLiteConvert._affinitytotype = typeArray; DbType[] dbTypeArray = new DbType[] { DbType.Object, DbType.Binary, DbType.Object, DbType.Boolean, DbType.SByte, DbType.SByte, DbType.Byte, DbType.Int16, DbType.UInt16, DbType.Int32, DbType.UInt32, DbType.Int64, DbType.UInt64, DbType.Single, DbType.Double, DbType.Decimal, DbType.DateTime, DbType.Object, DbType.String }; SQLiteConvert._typetodbtype = dbTypeArray; SQLiteConvert._dbtypetocolumnsize = new int[] { 2147483647, 2147483647, 1, 1, 8, 8, 8, 8, 8, 16, 2, 4, 8, 2147483647, 1, 4, 2147483647, 8, 2, 4, 8, 8, 2147483647, 2147483647, 2147483647, 2147483647 }; object[] value = new object[] { DBNull.Value, DBNull.Value, 3, DBNull.Value, 19, DBNull.Value, DBNull.Value, 53, 53, DBNull.Value, 5, 10, 19, DBNull.Value, 3, 24, DBNull.Value, DBNull.Value, 5, 10, 19, 53, DBNull.Value, DBNull.Value, DBNull.Value, DBNull.Value }; SQLiteConvert._dbtypetonumericprecision = value; object[] objArray = new object[] { DBNull.Value, DBNull.Value, 0, DBNull.Value, 4, DBNull.Value, DBNull.Value, DBNull.Value, DBNull.Value, DBNull.Value, 0, 0, 0, DBNull.Value, 0, DBNull.Value, DBNull.Value, DBNull.Value, 0, 0, 0, 0, DBNull.Value, DBNull.Value, DBNull.Value, DBNull.Value }; SQLiteConvert._dbtypetonumericscale = objArray; Type[] typeArray1 = new Type[] { typeof(string), typeof(byte[]), typeof(byte), typeof(bool), typeof(decimal), typeof(DateTime), typeof(DateTime), typeof(decimal), typeof(double), typeof(Guid), typeof(short), typeof(int), typeof(long), typeof(object), typeof(sbyte), typeof(float), typeof(string), typeof(DateTime), typeof(ushort), typeof(uint), typeof(ulong), typeof(double), typeof(string), typeof(string), typeof(string), typeof(string) }; SQLiteConvert._dbtypeToType = typeArray1; TypeAffinity[] typeAffinityArray = new TypeAffinity[] { TypeAffinity.Null, TypeAffinity.Blob, TypeAffinity.Null, TypeAffinity.Int64, TypeAffinity.Int64, TypeAffinity.Int64, TypeAffinity.Int64, TypeAffinity.Int64, TypeAffinity.Int64, TypeAffinity.Int64, TypeAffinity.Int64, TypeAffinity.Int64, TypeAffinity.Int64, TypeAffinity.Double, TypeAffinity.Double, TypeAffinity.Double, TypeAffinity.DateTime, TypeAffinity.Null, TypeAffinity.Text }; SQLiteConvert._typecodeAffinities = typeAffinityArray; SQLiteConvert._syncRoot = new object(); SQLiteConvert._typeNames = null; }
internal static string GetLastError(SQLiteConnectionHandle hdl, IntPtr db) { if (hdl == null || db == IntPtr.Zero) { return("null connection or database handle"); } string str = null; try { } finally { lock (hdl) { if (hdl.IsInvalid || hdl.IsClosed) { str = "closed or invalid connection handle"; } else { int num = 0; str = SQLiteConvert.UTF8ToString(UnsafeNativeMethods.sqlite3_errmsg_interop(db, ref num), num); } } } GC.KeepAlive(hdl); return(str); }
internal static bool ResetConnection(SQLiteConnectionHandle hdl, IntPtr db, bool canThrow) { SQLiteErrorCode sQLiteErrorCode; if (hdl == null || db == IntPtr.Zero) { return(false); } bool flag = false; try { } finally { lock (hdl) { if (canThrow && hdl.IsInvalid) { throw new InvalidOperationException("The connection handle is invalid."); } if (canThrow && hdl.IsClosed) { throw new InvalidOperationException("The connection handle is closed."); } if (!hdl.IsInvalid && !hdl.IsClosed) { IntPtr zero = IntPtr.Zero; do { zero = UnsafeNativeMethods.sqlite3_next_stmt(db, zero); if (zero == IntPtr.Zero) { continue; } sQLiteErrorCode = UnsafeNativeMethods.sqlite3_reset_interop(zero); }while (zero != IntPtr.Zero); if (!SQLiteBase.IsAutocommit(hdl, db)) { sQLiteErrorCode = UnsafeNativeMethods.sqlite3_exec(db, SQLiteConvert.ToUTF8("ROLLBACK"), IntPtr.Zero, IntPtr.Zero, ref zero); if (sQLiteErrorCode == SQLiteErrorCode.Ok) { flag = true; } else if (canThrow) { throw new SQLiteException(sQLiteErrorCode, SQLiteBase.GetLastError(hdl, db)); } } else { flag = true; } } } } GC.KeepAlive(hdl); return(flag); }
internal static Type SQLiteTypeToType(SQLiteType t) { if (t.Type != DbType.Object) { return(SQLiteConvert.DbTypeToType(t.Type)); } return(SQLiteConvert._affinitytotype[(int)t.Affinity]); }
public static bool ToBoolean(object source) { if (source is bool) { return((bool)source); } return(SQLiteConvert.ToBoolean(SQLiteConvert.ToStringWithProvider(source, CultureInfo.InvariantCulture))); }
public static DateTime ToDateTime(double julianDay, DateTimeKind kind) { long jd = SQLiteConvert.DoubleToJd(julianDay); DateTime dateTime = SQLiteConvert.computeYMD(jd, null); DateTime dateTime1 = SQLiteConvert.computeHMS(jd, null); return(new DateTime(dateTime.Year, dateTime.Month, dateTime.Day, dateTime1.Hour, dateTime1.Minute, dateTime1.Second, dateTime1.Millisecond, kind)); }
public static string ToString(DateTime dateValue, SQLiteDateFormats format, DateTimeKind kind, string formatString) { DateTime dateTime; switch (format) { case SQLiteDateFormats.Ticks: { return(dateValue.Ticks.ToString(CultureInfo.InvariantCulture)); } case SQLiteDateFormats.ISO8601: { if (dateValue.Kind != DateTimeKind.Unspecified) { return(dateValue.ToString(SQLiteConvert.GetDateTimeKindFormat(dateValue.Kind, formatString), CultureInfo.InvariantCulture)); } dateTime = DateTime.SpecifyKind(dateValue, kind); return(dateTime.ToString(SQLiteConvert.GetDateTimeKindFormat(kind, formatString), CultureInfo.InvariantCulture)); } case SQLiteDateFormats.JulianDay: { return(SQLiteConvert.ToJulianDay(dateValue).ToString(CultureInfo.InvariantCulture)); } case SQLiteDateFormats.UnixEpoch: { TimeSpan timeSpan = dateValue.Subtract(SQLiteConvert.UnixEpoch); return((timeSpan.Ticks / (long)10000000).ToString()); } case SQLiteDateFormats.InvariantCulture: { return(dateValue.ToString((formatString != null ? formatString : "yyyy-MM-ddTHH:mm:ss.fffffffK"), CultureInfo.InvariantCulture)); } case SQLiteDateFormats.CurrentCulture: { return(dateValue.ToString((formatString != null ? formatString : "yyyy-MM-ddTHH:mm:ss.fffffffK"), CultureInfo.CurrentCulture)); } default: { if (dateValue.Kind != DateTimeKind.Unspecified) { return(dateValue.ToString(SQLiteConvert.GetDateTimeKindFormat(dateValue.Kind, formatString), CultureInfo.InvariantCulture)); } dateTime = DateTime.SpecifyKind(dateValue, kind); return(dateTime.ToString(SQLiteConvert.GetDateTimeKindFormat(kind, formatString), CultureInfo.InvariantCulture)); } } }
internal static string DbTypeToTypeName(SQLiteConnection connection, DbType dbType, SQLiteConnectionFlags flags) { SQLiteDbTypeMapping sQLiteDbTypeMapping; SQLiteDbTypeMapping sQLiteDbTypeMapping1; string str; string defaultTypeName = null; if (connection != null) { flags |= connection.Flags; if ((flags & SQLiteConnectionFlags.UseConnectionTypes) == SQLiteConnectionFlags.UseConnectionTypes) { SQLiteDbTypeMap sQLiteDbTypeMap = connection._typeNames; if (sQLiteDbTypeMap != null && sQLiteDbTypeMap.TryGetValue(dbType, out sQLiteDbTypeMapping)) { return(sQLiteDbTypeMapping.typeName); } } defaultTypeName = connection.DefaultTypeName; } if ((flags & SQLiteConnectionFlags.NoGlobalTypes) == SQLiteConnectionFlags.NoGlobalTypes) { if (defaultTypeName != null) { return(defaultTypeName); } defaultTypeName = SQLiteConvert.GetDefaultTypeName(connection); SQLiteConvert.DefaultTypeNameWarning(dbType, flags, defaultTypeName); return(defaultTypeName); } lock (SQLiteConvert._syncRoot) { if (SQLiteConvert._typeNames == null) { SQLiteConvert._typeNames = SQLiteConvert.GetSQLiteDbTypeMap(); } if (!SQLiteConvert._typeNames.TryGetValue(dbType, out sQLiteDbTypeMapping1)) { if (defaultTypeName != null) { return(defaultTypeName); } defaultTypeName = SQLiteConvert.GetDefaultTypeName(connection); SQLiteConvert.DefaultTypeNameWarning(dbType, flags, defaultTypeName); return(defaultTypeName); } else { str = sQLiteDbTypeMapping1.typeName; } } return(str); }
internal override DateTime GetDateTime(SQLiteStatement stmt, int index) { if (this._datetimeFormat == SQLiteDateFormats.Ticks) { return(SQLiteConvert.TicksToDateTime(this.GetInt64(stmt, index), this._datetimeKind)); } if (this._datetimeFormat == SQLiteDateFormats.JulianDay) { return(SQLiteConvert.ToDateTime(this.GetDouble(stmt, index), this._datetimeKind)); } if (this._datetimeFormat != SQLiteDateFormats.UnixEpoch) { return(base.ToDateTime(this.GetText(stmt, index))); } return(SQLiteConvert.UnixEpochToDateTime(this.GetInt64(stmt, index), this._datetimeKind)); }
private static DbType GetDefaultDbType(SQLiteConnection connection) { DbType dbType; if (((connection != null ? connection.Flags : SQLiteConnectionFlags.None) & SQLiteConnectionFlags.NoConvertSettings) == SQLiteConnectionFlags.NoConvertSettings) { return(DbType.Object); } bool flag = false; string str = "Use_SQLiteConvert_DefaultDbType"; object settingValue = null; string str1 = null; if (connection == null || !connection.TryGetCachedSetting(str, str1, out settingValue)) { settingValue = UnsafeNativeMethods.GetSettingValue(str, str1); if (settingValue == null) { settingValue = DbType.Object; } } else { flag = true; } try { if (settingValue as DbType? == DbType.AnsiString) { settingValue = SQLiteConnection.TryParseEnum(typeof(DbType), SQLiteConvert.SettingValueToString(settingValue), true); if (settingValue as DbType? == DbType.AnsiString) { settingValue = DbType.Object; } } dbType = (DbType)settingValue; } finally { if (!flag && connection != null) { connection.SetCachedSetting(str, settingValue); } } return(dbType); }
private void InvokeBindValueCallback(int index, SQLiteParameter parameter, out bool complete) { SQLiteTypeCallbacks sQLiteTypeCallback; complete = false; SQLiteConnectionFlags sQLiteConnectionFlag = this._flags; SQLiteStatement sQLiteStatement = this; sQLiteStatement._flags = sQLiteStatement._flags & (SQLiteConnectionFlags.LogPrepare | SQLiteConnectionFlags.LogPreBind | SQLiteConnectionFlags.LogBind | SQLiteConnectionFlags.LogCallbackException | SQLiteConnectionFlags.LogBackup | SQLiteConnectionFlags.NoExtensionFunctions | SQLiteConnectionFlags.BindUInt32AsInt64 | SQLiteConnectionFlags.BindAllAsText | SQLiteConnectionFlags.GetAllAsText | SQLiteConnectionFlags.NoLoadExtension | SQLiteConnectionFlags.NoCreateModule | SQLiteConnectionFlags.NoBindFunctions | SQLiteConnectionFlags.NoLogModule | SQLiteConnectionFlags.LogModuleError | SQLiteConnectionFlags.LogModuleException | SQLiteConnectionFlags.TraceWarning | SQLiteConnectionFlags.ConvertInvariantText | SQLiteConnectionFlags.BindInvariantText | SQLiteConnectionFlags.NoConnectionPool | SQLiteConnectionFlags.UseConnectionPool | SQLiteConnectionFlags.UseConnectionTypes | SQLiteConnectionFlags.NoGlobalTypes | SQLiteConnectionFlags.StickyHasRows | SQLiteConnectionFlags.StrictEnlistment | SQLiteConnectionFlags.MapIsolationLevels | SQLiteConnectionFlags.DetectTextAffinity | SQLiteConnectionFlags.DetectStringType | SQLiteConnectionFlags.NoConvertSettings | SQLiteConnectionFlags.BindDateTimeWithKind | SQLiteConnectionFlags.RollbackOnException | SQLiteConnectionFlags.DenyOnException | SQLiteConnectionFlags.InterruptOnException | SQLiteConnectionFlags.UnbindFunctionsOnClose | SQLiteConnectionFlags.NoVerifyTextAffinity | SQLiteConnectionFlags.UseConnectionReadValueCallbacks | SQLiteConnectionFlags.UseParameterNameForTypeName | SQLiteConnectionFlags.UseParameterDbTypeForTypeName | SQLiteConnectionFlags.NoVerifyTypeAffinity | SQLiteConnectionFlags.AllowNestedTransactions | SQLiteConnectionFlags.BindDecimalAsText | SQLiteConnectionFlags.GetDecimalAsText | SQLiteConnectionFlags.BindInvariantDecimal | SQLiteConnectionFlags.GetInvariantDecimal | SQLiteConnectionFlags.BindAndGetAllAsText | SQLiteConnectionFlags.ConvertAndBindInvariantText | SQLiteConnectionFlags.BindAndGetAllAsInvariantText | SQLiteConnectionFlags.ConvertAndBindAndGetAllAsInvariantText | SQLiteConnectionFlags.UseParameterAnythingForTypeName | SQLiteConnectionFlags.LogAll | SQLiteConnectionFlags.LogDefault | SQLiteConnectionFlags.Default | SQLiteConnectionFlags.DefaultAndLogAll); try { if (parameter != null) { SQLiteConnection connection = SQLiteStatement.GetConnection(this); if (connection != null) { string typeName = parameter.TypeName; if (typeName == null && (this._flags & SQLiteConnectionFlags.UseParameterNameForTypeName) == SQLiteConnectionFlags.UseParameterNameForTypeName) { typeName = parameter.ParameterName; } if (typeName == null && (this._flags & SQLiteConnectionFlags.UseParameterDbTypeForTypeName) == SQLiteConnectionFlags.UseParameterDbTypeForTypeName) { typeName = SQLiteConvert.DbTypeToTypeName(connection, parameter.DbType, this._flags); } if (typeName != null) { if (connection.TryGetTypeCallbacks(typeName, out sQLiteTypeCallback) && sQLiteTypeCallback != null) { SQLiteBindValueCallback bindValueCallback = sQLiteTypeCallback.BindValueCallback; if (bindValueCallback != null) { object bindValueUserData = sQLiteTypeCallback.BindValueUserData; bindValueCallback(this._sql, this._command, sQLiteConnectionFlag, parameter, typeName, index, bindValueUserData, out complete); } } } } } } finally { this._flags |= SQLiteConnectionFlags.UseConnectionBindValueCallbacks; } }
internal static bool LooksLikeDateTime(SQLiteConvert convert, string text) { if (convert == null) { return(false); } try { if (string.Equals(convert.ToString(convert.ToDateTime(text)), text, StringComparison.Ordinal)) { return(true); } } catch { } return(false); }
private static DateTime computeHMS(long jd, DateTime?badValue) { DateTime dateTime; if (!SQLiteConvert.isValidJd(jd)) { if (!badValue.HasValue) { throw new ArgumentException("Not a supported Julian Day value."); } return(badValue.Value); } int num = (int)((jd + (long)43200000) % (long)86400000); decimal num1 = num / new decimal(10000, 0, 0, false, 1); num = (int)num1; int num2 = (int)((num1 - num) * new decimal(10000, 0, 0, false, 1)); num1 -= num; int num3 = num / 3600; num = num - num3 * 3600; int num4 = num / 60; num1 = num1 + (num - num4 * 60); int num5 = (int)num1; try { DateTime minValue = DateTime.MinValue; dateTime = new DateTime(minValue.Year, minValue.Month, minValue.Day, num3, num4, num5, num2); } catch { if (!badValue.HasValue) { throw; } dateTime = badValue.Value; } return(dateTime); }
private static DateTime computeYMD(long jd, DateTime?badValue) { DateTime dateTime; if (!SQLiteConvert.isValidJd(jd)) { if (!badValue.HasValue) { throw new ArgumentException("Not a supported Julian Day value."); } return(badValue.Value); } int num = (int)((jd + (long)43200000) / (long)86400000); int num1 = (int)(((double)num - 1867216.25) / 36524.25); num1 = num + 1 + num1 - num1 / 4; int num2 = num1 + 1524; int num3 = (int)(((double)num2 - 122.1) / 365.25); int num4 = 36525 * num3 / 100; int num5 = (int)((double)(num2 - num4) / 30.6001); int num6 = (int)(30.6001 * (double)num5); int num7 = num2 - num4 - num6; int num8 = (num5 < 14 ? num5 - 1 : num5 - 13); int num9 = (num8 > 2 ? num3 - 4716 : num3 - 4715); try { dateTime = new DateTime(num9, num8, num7); } catch { if (!badValue.HasValue) { throw; } dateTime = badValue.Value; } return(dateTime); }
public static DateTime ToDateTime(string dateText, SQLiteDateFormats format, DateTimeKind kind, string formatString) { string str; string[] strArrays; DateTimeFormatInfo invariantInfo; DateTimeStyles dateTimeStyle; string str1; string str2; DateTimeFormatInfo dateTimeFormatInfo; DateTimeStyles dateTimeStyle1; switch (format) { case SQLiteDateFormats.Ticks: { return(SQLiteConvert.TicksToDateTime(Convert.ToInt64(dateText, CultureInfo.InvariantCulture), kind)); } case SQLiteDateFormats.ISO8601: { if (formatString != null) { str1 = dateText; str2 = formatString; dateTimeFormatInfo = DateTimeFormatInfo.InvariantInfo; dateTimeStyle1 = (kind == DateTimeKind.Utc ? DateTimeStyles.AdjustToUniversal : DateTimeStyles.None); return(DateTime.SpecifyKind(DateTime.ParseExact(str1, str2, dateTimeFormatInfo, dateTimeStyle1), kind)); } str = dateText; strArrays = SQLiteConvert._datetimeFormats; invariantInfo = DateTimeFormatInfo.InvariantInfo; dateTimeStyle = (kind == DateTimeKind.Utc ? DateTimeStyles.AdjustToUniversal : DateTimeStyles.None); return(DateTime.SpecifyKind(DateTime.ParseExact(str, strArrays, invariantInfo, dateTimeStyle), kind)); } case SQLiteDateFormats.JulianDay: { return(SQLiteConvert.ToDateTime(Convert.ToDouble(dateText, CultureInfo.InvariantCulture), kind)); } case SQLiteDateFormats.UnixEpoch: { return(SQLiteConvert.UnixEpochToDateTime(Convert.ToInt64(dateText, CultureInfo.InvariantCulture), kind)); } case SQLiteDateFormats.InvariantCulture: { if (formatString == null) { return(DateTime.SpecifyKind(DateTime.Parse(dateText, DateTimeFormatInfo.InvariantInfo, (kind == DateTimeKind.Utc ? DateTimeStyles.AdjustToUniversal : DateTimeStyles.None)), kind)); } return(DateTime.SpecifyKind(DateTime.ParseExact(dateText, formatString, DateTimeFormatInfo.InvariantInfo, (kind == DateTimeKind.Utc ? DateTimeStyles.AdjustToUniversal : DateTimeStyles.None)), kind)); } case SQLiteDateFormats.CurrentCulture: { if (formatString == null) { return(DateTime.SpecifyKind(DateTime.Parse(dateText, DateTimeFormatInfo.CurrentInfo, (kind == DateTimeKind.Utc ? DateTimeStyles.AdjustToUniversal : DateTimeStyles.None)), kind)); } return(DateTime.SpecifyKind(DateTime.ParseExact(dateText, formatString, DateTimeFormatInfo.CurrentInfo, (kind == DateTimeKind.Utc ? DateTimeStyles.AdjustToUniversal : DateTimeStyles.None)), kind)); } default: { if (formatString != null) { str1 = dateText; str2 = formatString; dateTimeFormatInfo = DateTimeFormatInfo.InvariantInfo; dateTimeStyle1 = (kind == DateTimeKind.Utc ? DateTimeStyles.AdjustToUniversal : DateTimeStyles.None); return(DateTime.SpecifyKind(DateTime.ParseExact(str1, str2, dateTimeFormatInfo, dateTimeStyle1), kind)); } str = dateText; strArrays = SQLiteConvert._datetimeFormats; invariantInfo = DateTimeFormatInfo.InvariantInfo; dateTimeStyle = (kind == DateTimeKind.Utc ? DateTimeStyles.AdjustToUniversal : DateTimeStyles.None); return(DateTime.SpecifyKind(DateTime.ParseExact(str, strArrays, invariantInfo, dateTimeStyle), kind)); } } }
public DateTime ToDateTime(string dateText) { return(SQLiteConvert.ToDateTime(dateText, this._datetimeFormat, this._datetimeKind, this._datetimeFormatString)); }
public byte[] ToUTF8(DateTime dateTimeValue) { return(SQLiteConvert.ToUTF8(this.ToString(dateTimeValue))); }
public string ToString(DateTime dateValue) { return(SQLiteConvert.ToString(dateValue, this._datetimeFormat, this._datetimeKind, this._datetimeFormatString)); }
public static double ToJulianDay(DateTime value) { return(SQLiteConvert.JdToDouble(SQLiteConvert.computeJD(value))); }
private static void LogCallback(IntPtr pUserData, int errorCode, IntPtr pMessage) { bool flag; SQLiteLogEventHandler sQLiteLogEventHandler; lock (SQLiteLog.syncRoot) { flag = SQLiteLog._enabled; if (SQLiteLog._handlers == null) { sQLiteLogEventHandler = null; } else { sQLiteLogEventHandler = SQLiteLog._handlers.Clone() as SQLiteLogEventHandler; } } if (flag && sQLiteLogEventHandler != null) { sQLiteLogEventHandler(null, new LogEventArgs(pUserData, (object)errorCode, SQLiteConvert.UTF8ToString(pMessage, -1), null)); } }
internal static DbType TypeNameToDbType(SQLiteConnection connection, string typeName, SQLiteConnectionFlags flags) { SQLiteDbTypeMapping sQLiteDbTypeMapping; SQLiteDbTypeMapping sQLiteDbTypeMapping1; DbType dbType; DbType?defaultDbType = null; if (connection != null) { flags |= connection.Flags; if ((flags & SQLiteConnectionFlags.UseConnectionTypes) == SQLiteConnectionFlags.UseConnectionTypes) { SQLiteDbTypeMap sQLiteDbTypeMap = connection._typeNames; if (sQLiteDbTypeMap != null && typeName != null) { if (sQLiteDbTypeMap.TryGetValue(typeName, out sQLiteDbTypeMapping)) { return(sQLiteDbTypeMapping.dataType); } int num = typeName.IndexOf('('); if (num > 0 && sQLiteDbTypeMap.TryGetValue(typeName.Substring(0, num).TrimEnd(new char[0]), out sQLiteDbTypeMapping)) { return(sQLiteDbTypeMapping.dataType); } } } defaultDbType = connection.DefaultDbType; } if ((flags & SQLiteConnectionFlags.NoGlobalTypes) == SQLiteConnectionFlags.NoGlobalTypes) { if (defaultDbType.HasValue) { return(defaultDbType.Value); } defaultDbType = new DbType?(SQLiteConvert.GetDefaultDbType(connection)); SQLiteConvert.DefaultDbTypeWarning(typeName, flags, defaultDbType); return(defaultDbType.Value); } lock (SQLiteConvert._syncRoot) { if (SQLiteConvert._typeNames == null) { SQLiteConvert._typeNames = SQLiteConvert.GetSQLiteDbTypeMap(); } if (typeName != null) { if (!SQLiteConvert._typeNames.TryGetValue(typeName, out sQLiteDbTypeMapping1)) { int num1 = typeName.IndexOf('('); if (num1 > 0 && SQLiteConvert._typeNames.TryGetValue(typeName.Substring(0, num1).TrimEnd(new char[0]), out sQLiteDbTypeMapping1)) { dbType = sQLiteDbTypeMapping1.dataType; return(dbType); } } else { dbType = sQLiteDbTypeMapping1.dataType; return(dbType); } } if (defaultDbType.HasValue) { return(defaultDbType.Value); } defaultDbType = new DbType?(SQLiteConvert.GetDefaultDbType(connection)); SQLiteConvert.DefaultDbTypeWarning(typeName, flags, defaultDbType); return(defaultDbType.Value); } return(dbType); }
public DateTime ToDateTime(double julianDay) { return(SQLiteConvert.ToDateTime(julianDay, this._datetimeKind)); }
internal SQLiteKeyReader(SQLiteConnection cnn, SQLiteDataReader reader, SQLiteStatement stmt) { List <string> item; Dictionary <string, int> strs = new Dictionary <string, int>(); Dictionary <string, List <string> > strs1 = new Dictionary <string, List <string> >(); List <SQLiteKeyReader.KeyInfo> keyInfos = new List <SQLiteKeyReader.KeyInfo>(); List <SQLiteKeyReader.RowIdInfo> rowIdInfos = new List <SQLiteKeyReader.RowIdInfo>(); this._stmt = stmt; using (DataTable schema = cnn.GetSchema("Catalogs")) { foreach (DataRow row in schema.Rows) { strs.Add((string)row["CATALOG_NAME"], Convert.ToInt32(row["ID"], CultureInfo.InvariantCulture)); } } using (DataTable schemaTable = reader.GetSchemaTable(false, false)) { foreach (DataRow dataRow in schemaTable.Rows) { if (dataRow[SchemaTableOptionalColumn.BaseCatalogName] == DBNull.Value) { continue; } string str = (string)dataRow[SchemaTableOptionalColumn.BaseCatalogName]; string item1 = (string)dataRow[SchemaTableColumn.BaseTableName]; if (strs1.ContainsKey(str)) { item = strs1[str]; } else { item = new List <string>(); strs1.Add(str, item); } if (item.Contains(item1)) { continue; } item.Add(item1); } foreach (KeyValuePair <string, List <string> > keyValuePair in strs1) { for (int i = 0; i < keyValuePair.Value.Count; i++) { string str1 = keyValuePair.Value[i]; DataRow dataRow1 = null; string[] key = new string[] { keyValuePair.Key, null, str1 }; using (DataTable dataTable = cnn.GetSchema("Indexes", key)) { for (int j = 0; j < 2 && dataRow1 == null; j++) { foreach (DataRow row1 in dataTable.Rows) { if (j != 0 || !(bool)row1["PRIMARY_KEY"]) { if (j != 1 || !(bool)row1["UNIQUE"]) { continue; } dataRow1 = row1; break; } else { dataRow1 = row1; break; } } } if (dataRow1 != null) { string[] strArrays = new string[] { keyValuePair.Key, null, str1 }; using (DataTable schema1 = cnn.GetSchema("Tables", strArrays)) { int num = strs[keyValuePair.Key]; int num1 = Convert.ToInt32(schema1.Rows[0]["TABLE_ROOTPAGE"], CultureInfo.InvariantCulture); int cursorForTable = stmt._sql.GetCursorForTable(stmt, num, num1); string[] key1 = new string[] { keyValuePair.Key, null, str1, (string)dataRow1["INDEX_NAME"] }; using (DataTable dataTable1 = cnn.GetSchema("IndexColumns", key1)) { bool flag = (string)dataRow1["INDEX_NAME"] == string.Concat("sqlite_master_PK_", str1); SQLiteKeyReader.KeyQuery keyQuery = null; List <string> strs2 = new List <string>(); for (int k = 0; k < dataTable1.Rows.Count; k++) { string stringOrNull = SQLiteConvert.GetStringOrNull(dataTable1.Rows[k]["COLUMN_NAME"]); bool flag1 = true; foreach (DataRow row2 in schemaTable.Rows) { if (row2.IsNull(SchemaTableColumn.BaseColumnName) || !((string)row2[SchemaTableColumn.BaseColumnName] == stringOrNull) || !((string)row2[SchemaTableColumn.BaseTableName] == str1) || !((string)row2[SchemaTableOptionalColumn.BaseCatalogName] == keyValuePair.Key)) { continue; } if (flag) { SQLiteKeyReader.RowIdInfo rowIdInfo = new SQLiteKeyReader.RowIdInfo() { databaseName = keyValuePair.Key, tableName = str1, column = (int)row2[SchemaTableColumn.ColumnOrdinal] }; rowIdInfos.Add(rowIdInfo); } dataTable1.Rows.RemoveAt(k); k--; flag1 = false; break; } if (flag1) { strs2.Add(stringOrNull); } } if (!flag && strs2.Count > 0) { string[] strArrays1 = new string[strs2.Count]; strs2.CopyTo(strArrays1); keyQuery = new SQLiteKeyReader.KeyQuery(cnn, keyValuePair.Key, str1, strArrays1); } for (int l = 0; l < dataTable1.Rows.Count; l++) { string stringOrNull1 = SQLiteConvert.GetStringOrNull(dataTable1.Rows[l]["COLUMN_NAME"]); SQLiteKeyReader.KeyInfo keyInfo = new SQLiteKeyReader.KeyInfo() { rootPage = num1, cursor = cursorForTable, database = num, databaseName = keyValuePair.Key, tableName = str1, columnName = stringOrNull1, query = keyQuery, column = l }; keyInfos.Add(keyInfo); } } } } else { keyValuePair.Value.RemoveAt(i); i--; } } } } } this._keyInfo = new SQLiteKeyReader.KeyInfo[keyInfos.Count]; keyInfos.CopyTo(this._keyInfo); this._rowIdInfo = new SQLiteKeyReader.RowIdInfo[rowIdInfos.Count]; rowIdInfos.CopyTo(this._rowIdInfo); }
public static SQLiteBlob Create(SQLiteDataReader dataReader, int i, bool readOnly) { SQLiteConnection connection = SQLiteDataReader.GetConnection(dataReader); if (connection == null) { throw new InvalidOperationException("Connection not available"); } SQLite3 sQLite3 = connection._sql as SQLite3; if (sQLite3 == null) { throw new InvalidOperationException("Connection has no wrapper"); } SQLiteConnectionHandle sQLiteConnectionHandle = sQLite3._sql; if (sQLiteConnectionHandle == null) { throw new InvalidOperationException("Connection has an invalid handle."); } long?rowId = dataReader.GetRowId(i); if (!rowId.HasValue) { throw new InvalidOperationException("No RowId is available"); } SQLiteBlobHandle sQLiteBlobHandle = null; try { } finally { IntPtr zero = IntPtr.Zero; SQLiteErrorCode sQLiteErrorCode = UnsafeNativeMethods.sqlite3_blob_open(sQLiteConnectionHandle, SQLiteConvert.ToUTF8(dataReader.GetDatabaseName(i)), SQLiteConvert.ToUTF8(dataReader.GetTableName(i)), SQLiteConvert.ToUTF8(dataReader.GetName(i)), rowId.Value, (readOnly ? 0 : 1), ref zero); if (sQLiteErrorCode != SQLiteErrorCode.Ok) { throw new SQLiteException(sQLiteErrorCode, null); } sQLiteBlobHandle = new SQLiteBlobHandle(sQLiteConnectionHandle, zero); } object[] objArray = new object[] { typeof(SQLiteBlob), dataReader, i, readOnly }; SQLiteConnection.OnChanged(null, new ConnectionEventArgs(SQLiteConnectionEventType.NewCriticalHandle, null, null, null, dataReader, sQLiteBlobHandle, null, objArray)); return(new SQLiteBlob(sQLite3, sQLiteBlobHandle)); }
public virtual string ToString(IntPtr nativestring, int nativestringlen) { return(SQLiteConvert.UTF8ToString(nativestring, nativestringlen)); }
private void BindParameter(int index, SQLiteParameter param) { bool flag; SQLiteBase sQLiteBase; SQLiteConnectionFlags sQLiteConnectionFlag; int num; string str; if (param == null) { throw new SQLiteException("Insufficient parameters supplied to the command"); } if ((this._flags & SQLiteConnectionFlags.UseConnectionBindValueCallbacks) == SQLiteConnectionFlags.UseConnectionBindValueCallbacks) { this.InvokeBindValueCallback(index, param, out flag); if (flag) { return; } } object value = param.Value; DbType dbType = param.DbType; if (value != null && dbType == DbType.Object) { dbType = SQLiteConvert.TypeToDbType(value.GetType()); } if (HelperMethods.LogPreBind(this._flags)) { IntPtr _sqliteStmt = this._sqlite_stmt; CultureInfo currentCulture = CultureInfo.CurrentCulture; object[] objArray = new object[] { _sqliteStmt, index, dbType, value }; SQLiteLog.LogMessage(HelperMethods.StringFormat(currentCulture, "Binding statement {0} paramter #{1} with database type {2} and raw value {{{3}}}...", objArray)); } if (value == null || Convert.IsDBNull(value)) { this._sql.Bind_Null(this, this._flags, index); return; } CultureInfo invariantCulture = CultureInfo.InvariantCulture; bool flag1 = (this._flags & SQLiteConnectionFlags.BindInvariantText) == SQLiteConnectionFlags.BindInvariantText; CultureInfo cultureInfo = CultureInfo.CurrentCulture; if ((this._flags & SQLiteConnectionFlags.ConvertInvariantText) == SQLiteConnectionFlags.ConvertInvariantText) { cultureInfo = invariantCulture; } if ((this._flags & SQLiteConnectionFlags.BindAllAsText) == SQLiteConnectionFlags.BindAllAsText) { if (value is DateTime) { this._sql.Bind_DateTime(this, this._flags, index, (DateTime)value); return; } this._sql.Bind_Text(this, this._flags, index, (flag1 ? SQLiteConvert.ToStringWithProvider(value, invariantCulture) : SQLiteConvert.ToStringWithProvider(value, cultureInfo))); return; } bool flag2 = (this._flags & SQLiteConnectionFlags.BindInvariantDecimal) == SQLiteConnectionFlags.BindInvariantDecimal; if ((this._flags & SQLiteConnectionFlags.BindDecimalAsText) == SQLiteConnectionFlags.BindDecimalAsText && value is decimal) { this._sql.Bind_Text(this, this._flags, index, (flag1 || flag2 ? SQLiteConvert.ToStringWithProvider(value, invariantCulture) : SQLiteConvert.ToStringWithProvider(value, cultureInfo))); return; } switch (dbType) { case DbType.Binary: { this._sql.Bind_Blob(this, this._flags, index, (byte[])value); return; } case DbType.Byte: { this._sql.Bind_UInt32(this, this._flags, index, Convert.ToByte(value, cultureInfo)); return; } case DbType.Boolean: { this._sql.Bind_Boolean(this, this._flags, index, SQLiteConvert.ToBoolean(value, cultureInfo, true)); return; } case DbType.Currency: case DbType.Double: case DbType.Single: { this._sql.Bind_Double(this, this._flags, index, Convert.ToDouble(value, cultureInfo)); return; } case DbType.Date: case DbType.DateTime: case DbType.Time: { this._sql.Bind_DateTime(this, this._flags, index, (value is string?this._sql.ToDateTime((string)value) : Convert.ToDateTime(value, cultureInfo))); return; } case DbType.Decimal: { this._sql.Bind_Text(this, this._flags, index, (flag1 || flag2 ? SQLiteConvert.ToStringWithProvider(Convert.ToDecimal(value, cultureInfo), invariantCulture) : SQLiteConvert.ToStringWithProvider(Convert.ToDecimal(value, cultureInfo), cultureInfo))); return; } case DbType.Guid: { if (this._command.Connection._binaryGuid) { SQLiteBase sQLiteBase1 = this._sql; SQLiteConnectionFlags sQLiteConnectionFlag1 = this._flags; Guid guid = (Guid)value; sQLiteBase1.Bind_Blob(this, sQLiteConnectionFlag1, index, guid.ToByteArray()); return; } this._sql.Bind_Text(this, this._flags, index, (flag1 ? SQLiteConvert.ToStringWithProvider(value, invariantCulture) : SQLiteConvert.ToStringWithProvider(value, cultureInfo))); return; } case DbType.Int16: { this._sql.Bind_Int32(this, this._flags, index, Convert.ToInt16(value, cultureInfo)); return; } case DbType.Int32: { this._sql.Bind_Int32(this, this._flags, index, Convert.ToInt32(value, cultureInfo)); return; } case DbType.Int64: { this._sql.Bind_Int64(this, this._flags, index, Convert.ToInt64(value, cultureInfo)); return; } case DbType.Object: case DbType.String: { sQLiteBase = this._sql; sQLiteConnectionFlag = this._flags; num = index; str = (flag1 ? SQLiteConvert.ToStringWithProvider(value, invariantCulture) : SQLiteConvert.ToStringWithProvider(value, cultureInfo)); sQLiteBase.Bind_Text(this, sQLiteConnectionFlag, num, str); return; } case DbType.SByte: { this._sql.Bind_Int32(this, this._flags, index, Convert.ToSByte(value, cultureInfo)); return; } case DbType.UInt16: { this._sql.Bind_UInt32(this, this._flags, index, Convert.ToUInt16(value, cultureInfo)); return; } case DbType.UInt32: { this._sql.Bind_UInt32(this, this._flags, index, Convert.ToUInt32(value, cultureInfo)); return; } case DbType.UInt64: { this._sql.Bind_UInt64(this, this._flags, index, Convert.ToUInt64(value, cultureInfo)); return; } default: { sQLiteBase = this._sql; sQLiteConnectionFlag = this._flags; num = index; str = (flag1 ? SQLiteConvert.ToStringWithProvider(value, invariantCulture) : SQLiteConvert.ToStringWithProvider(value, cultureInfo)); sQLiteBase.Bind_Text(this, sQLiteConnectionFlag, num, str); return; } } }
internal static bool ToBoolean(object obj, IFormatProvider provider, bool viaFramework) { object[] objArray; CultureInfo currentCulture; if (obj == null) { return(false); } TypeCode typeCode = Type.GetTypeCode(obj.GetType()); switch (typeCode) { case TypeCode.Empty: case TypeCode.DBNull: { return(false); } case TypeCode.Object: case TypeCode.DateTime: case TypeCode.Object | TypeCode.DateTime: { currentCulture = CultureInfo.CurrentCulture; objArray = new object[] { typeCode }; throw new SQLiteException(HelperMethods.StringFormat(currentCulture, "Cannot convert type {0} to boolean", objArray)); } case TypeCode.Boolean: { return((bool)obj); } case TypeCode.Char: { if ((char)obj == 0) { return(false); } return(true); } case TypeCode.SByte: { if ((sbyte)obj == 0) { return(false); } return(true); } case TypeCode.Byte: { if ((byte)obj == 0) { return(false); } return(true); } case TypeCode.Int16: { if ((short)obj == 0) { return(false); } return(true); } case TypeCode.UInt16: { if ((ushort)obj == 0) { return(false); } return(true); } case TypeCode.Int32: { if ((int)obj == 0) { return(false); } return(true); } case TypeCode.UInt32: { if ((uint)obj == 0) { return(false); } return(true); } case TypeCode.Int64: { if ((long)obj == (long)0) { return(false); } return(true); } case TypeCode.UInt64: { if ((ulong)obj == (long)0) { return(false); } return(true); } case TypeCode.Single: { if ((float)obj == 0f) { return(false); } return(true); } case TypeCode.Double: { if ((double)obj == 0) { return(false); } return(true); } case TypeCode.Decimal: { if ((decimal)obj == new decimal(0)) { return(false); } return(true); } case TypeCode.String: { if (viaFramework) { return(Convert.ToBoolean(obj, provider)); } return(SQLiteConvert.ToBoolean(SQLiteConvert.ToStringWithProvider(obj, provider))); } default: { currentCulture = CultureInfo.CurrentCulture; objArray = new object[] { typeCode }; throw new SQLiteException(HelperMethods.StringFormat(currentCulture, "Cannot convert type {0} to boolean", objArray)); } } }
internal override void Open(string strFilename, string vfsName, SQLiteConnectionFlags connectionFlags, SQLiteOpenFlagsEnum openFlags, int maxPoolSize, bool usePool) { SQLiteErrorCode sQLiteErrorCode; if (this._sql != null) { this.Close(true); } if (this._sql != null) { throw new SQLiteException("connection handle is still active"); } this._usePool = usePool; this._fileName = strFilename; this._flags = connectionFlags; if (usePool) { this._sql = SQLiteConnectionPool.Remove(strFilename, maxPoolSize, out this._poolVersion); SQLiteConnectionHandle sQLiteConnectionHandle = this._sql; object[] objArray = new object[] { typeof(SQLite3_UTF16), strFilename, vfsName, connectionFlags, openFlags, maxPoolSize, usePool, this._poolVersion }; SQLiteConnection.OnChanged(null, new ConnectionEventArgs(SQLiteConnectionEventType.OpenedFromPool, null, null, null, null, sQLiteConnectionHandle, strFilename, objArray)); } if (this._sql == null) { try { } finally { IntPtr zero = IntPtr.Zero; int num = ((connectionFlags & SQLiteConnectionFlags.NoExtensionFunctions) != SQLiteConnectionFlags.NoExtensionFunctions ? 1 : 0); if (vfsName != null || num != 0) { sQLiteErrorCode = UnsafeNativeMethods.sqlite3_open16_interop(SQLiteConvert.ToUTF8(strFilename), SQLiteConvert.ToUTF8(vfsName), openFlags, num, ref zero); } else { if ((openFlags & SQLiteOpenFlagsEnum.Create) != SQLiteOpenFlagsEnum.Create && !File.Exists(strFilename)) { throw new SQLiteException(SQLiteErrorCode.CantOpen, strFilename); } if (vfsName != null) { CultureInfo currentCulture = CultureInfo.CurrentCulture; object[] objArray1 = new object[] { vfsName }; throw new SQLiteException(SQLiteErrorCode.CantOpen, HelperMethods.StringFormat(currentCulture, "cannot open using UTF-16 and VFS \"{0}\": need interop assembly", objArray1)); } sQLiteErrorCode = UnsafeNativeMethods.sqlite3_open16(strFilename, ref zero); } if (sQLiteErrorCode != SQLiteErrorCode.Ok) { throw new SQLiteException(sQLiteErrorCode, null); } this._sql = new SQLiteConnectionHandle(zero, true); } lock (this._sql) { } SQLiteConnectionHandle sQLiteConnectionHandle1 = this._sql; object[] objArray2 = new object[] { typeof(SQLite3_UTF16), strFilename, vfsName, connectionFlags, openFlags, maxPoolSize, usePool }; SQLiteConnection.OnChanged(null, new ConnectionEventArgs(SQLiteConnectionEventType.NewCriticalHandle, null, null, null, null, sQLiteConnectionHandle1, strFilename, objArray2)); } if ((connectionFlags & SQLiteConnectionFlags.NoBindFunctions) != SQLiteConnectionFlags.NoBindFunctions) { if (this._functions == null) { this._functions = new Dictionary <SQLiteFunctionAttribute, SQLiteFunction>(); } foreach (KeyValuePair <SQLiteFunctionAttribute, SQLiteFunction> value in SQLiteFunction.BindFunctions(this, connectionFlags)) { this._functions[value.Key] = value.Value; } } this.SetTimeout(0); GC.KeepAlive(this._sql); }