private void SetupDB2Connect()
{
SqlProviderFlags.IsParameterOrderDependent = false;
SetCharFieldToType <char>(Constants.DbTypes.Char, (r, i) => DataTools.GetChar(r, i));
var adapter = (DB2.DB2ProviderAdapter)Adapter.GetInstance();
SetProviderField(adapter.DB2Int64Type, typeof(long), adapter.GetDB2Int64ReaderMethod, dataReaderType: adapter.DataReaderType);
SetProviderField(adapter.DB2Int32Type, typeof(int), adapter.GetDB2Int32ReaderMethod, dataReaderType: adapter.DataReaderType);
SetProviderField(adapter.DB2Int16Type, typeof(short), adapter.GetDB2Int16ReaderMethod, dataReaderType: adapter.DataReaderType);
SetProviderField(adapter.DB2DecimalType, typeof(decimal), adapter.GetDB2DecimalReaderMethod, dataReaderType: adapter.DataReaderType);
SetProviderField(adapter.DB2DecimalFloatType, typeof(decimal), adapter.GetDB2DecimalFloatReaderMethod, dataReaderType: adapter.DataReaderType);
SetProviderField(adapter.DB2RealType, typeof(float), adapter.GetDB2RealReaderMethod, dataReaderType: adapter.DataReaderType);
SetProviderField(adapter.DB2Real370Type, typeof(float), adapter.GetDB2Real370ReaderMethod, dataReaderType: adapter.DataReaderType);
SetProviderField(adapter.DB2DoubleType, typeof(double), adapter.GetDB2DoubleReaderMethod, dataReaderType: adapter.DataReaderType);
SetProviderField(adapter.DB2StringType, typeof(string), adapter.GetDB2StringReaderMethod, dataReaderType: adapter.DataReaderType);
SetProviderField(adapter.DB2ClobType, typeof(string), adapter.GetDB2ClobReaderMethod, dataReaderType: adapter.DataReaderType);
SetProviderField(adapter.DB2BinaryType, typeof(byte[]), adapter.GetDB2BinaryReaderMethod, dataReaderType: adapter.DataReaderType);
SetProviderField(adapter.DB2BlobType, typeof(byte[]), adapter.GetDB2BlobReaderMethod, dataReaderType: adapter.DataReaderType);
SetProviderField(adapter.DB2DateType, typeof(DateTime), adapter.GetDB2DateReaderMethod, dataReaderType: adapter.DataReaderType);
SetProviderField(adapter.DB2TimeType, typeof(TimeSpan), adapter.GetDB2TimeReaderMethod, dataReaderType: adapter.DataReaderType);
SetProviderField(adapter.DB2TimeStampType, typeof(DateTime), adapter.GetDB2TimeStampReaderMethod, dataReaderType: adapter.DataReaderType);
SetProviderField(adapter.DB2XmlType, typeof(string), adapter.GetDB2XmlReaderMethod, dataReaderType: adapter.DataReaderType);
SetProviderField(adapter.DB2RowIdType, typeof(byte[]), adapter.GetDB2RowIdReaderMethod, dataReaderType: adapter.DataReaderType);
}
protected AccessODBCDataProvider(string name, MappingSchema mappingSchema)
: base(name, mappingSchema, OdbcProviderAdapter.GetInstance())
{
SqlProviderFlags.AcceptsTakeAsParameter = false;
SqlProviderFlags.IsSkipSupported = false;
SqlProviderFlags.IsCountSubQuerySupported = false;
SqlProviderFlags.IsInsertOrUpdateSupported = false;
SqlProviderFlags.TakeHintsSupported = TakeHints.Percent;
SqlProviderFlags.IsCrossJoinSupported = false;
SqlProviderFlags.IsInnerJoinAsCrossSupported = false;
SqlProviderFlags.IsDistinctOrderBySupported = false;
SqlProviderFlags.IsDistinctSetOperationsSupported = false;
SqlProviderFlags.IsParameterOrderDependent = true;
SqlProviderFlags.IsUpdateFromSupported = false;
SqlProviderFlags.DefaultMultiQueryIsolationLevel = IsolationLevel.Unspecified;
SetCharField("CHAR", (r, i) => r.GetString(i).TrimEnd(' '));
SetCharFieldToType <char>("CHAR", (r, i) => DataTools.GetChar(r, i));
SetToType <IDataReader, sbyte, int> ("INTEGER", (r, i) => unchecked ((sbyte )r.GetInt32(i)));
SetToType <IDataReader, uint, int> ("INTEGER", (r, i) => unchecked ((uint )r.GetInt32(i)));
SetToType <IDataReader, ulong, int> ("INTEGER", (r, i) => unchecked ((ulong)(uint)r.GetInt32(i)));
SetToType <IDataReader, ushort, short>("SMALLINT", (r, i) => unchecked ((ushort)r.GetInt16(i)));
SetProviderField <IDataReader, TimeSpan, DateTime>((r, i) => r.GetDateTime(i) - new DateTime(1899, 12, 30));
_sqlOptimizer = new AccessODBCSqlOptimizer(SqlProviderFlags);
}
public AS400DataProvider(DB2iSeriesConfiguration dB2ISeriesConfiguration) : base(dB2ISeriesConfiguration.Provider.Name(), dB2ISeriesConfiguration.MappingSchema)
{
this.dB2ISeriesConfiguration = dB2ISeriesConfiguration;
dB2ISeriesConfiguration.InitDataProvider(this, SetCharField);
SqlProviderFlags.IsDistinctOrderBySupported = true;
SetCharFieldToType <char>("CHAR", (r, i) => DataTools.GetChar(r, i));
}
public PostgreSQLDataProvider(string name, PostgreSQLVersion version = PostgreSQLVersion.v92)
: base(
name,
GetMappingSchema(version, NpgsqlProviderAdapter.GetInstance().MappingSchema),
NpgsqlProviderAdapter.GetInstance())
{
Version = version;
SqlProviderFlags.IsApplyJoinSupported = version != PostgreSQLVersion.v92;
SqlProviderFlags.IsInsertOrUpdateSupported = version == PostgreSQLVersion.v95;
SqlProviderFlags.IsUpdateSetTableAliasSupported = false;
SqlProviderFlags.IsCommonTableExpressionsSupported = true;
SqlProviderFlags.IsDistinctOrderBySupported = false;
SqlProviderFlags.IsSubQueryOrderBySupported = true;
SqlProviderFlags.IsAllSetOperationsSupported = true;
SetCharFieldToType <char>("bpchar", (r, i) => DataTools.GetChar(r, i));
SetCharFieldToType <char>("character", (r, i) => DataTools.GetChar(r, i));
SetCharField("bpchar", (r, i) => r.GetString(i).TrimEnd(' '));
SetCharField("character", (r, i) => r.GetString(i).TrimEnd(' '));
_sqlOptimizer = new PostgreSQLSqlOptimizer(SqlProviderFlags);
ConfigureTypes();
}
protected InformixDataProvider(string name, MappingSchema mappingSchema)
: base(name, mappingSchema)
{
SqlProviderFlags.IsParameterOrderDependent = true;
SqlProviderFlags.IsSubQueryTakeSupported = false;
SqlProviderFlags.IsInsertOrUpdateSupported = false;
SqlProviderFlags.IsGroupByExpressionSupported = false;
SqlProviderFlags.IsCrossJoinSupported = false;
SetCharField("CHAR", (r, i) => r.GetString(i).TrimEnd(' '));
SetCharField("NCHAR", (r, i) => r.GetString(i).TrimEnd(' '));
SetCharFieldToType <char>("CHAR", (r, i) => DataTools.GetChar(r, i));
SetCharFieldToType <char>("NCHAR", (r, i) => DataTools.GetChar(r, i));
if (!Configuration.AvoidSpecificDataProviderAPI)
{
SetProviderField <IDataReader, float, float>((r, i) => GetFloat(r, i));
SetProviderField <IDataReader, double, double>((r, i) => GetDouble(r, i));
SetProviderField <IDataReader, decimal, decimal>((r, i) => GetDecimal(r, i));
SetField <IDataReader, float>((r, i) => GetFloat(r, i));
SetField <IDataReader, double>((r, i) => GetDouble(r, i));
SetField <IDataReader, decimal>((r, i) => GetDecimal(r, i));
}
_sqlOptimizer = new InformixSqlOptimizer(SqlProviderFlags);
}
protected AccessDataProvider(string name, MappingSchema mappingSchema)
: base(name, mappingSchema)
{
SqlProviderFlags.AcceptsTakeAsParameter = false;
SqlProviderFlags.IsSkipSupported = false;
SqlProviderFlags.IsCountSubQuerySupported = false;
SqlProviderFlags.IsInsertOrUpdateSupported = false;
SqlProviderFlags.TakeHintsSupported = TakeHints.Percent;
SqlProviderFlags.IsCrossJoinSupported = false;
SqlProviderFlags.IsInnerJoinAsCrossSupported = false;
SqlProviderFlags.IsDistinctOrderBySupported = false;
SetCharField("DBTYPE_WCHAR", (r, i) => r.GetString(i).TrimEnd(' '));
SetCharFieldToType <char>("DBTYPE_WCHAR", (r, i) => DataTools.GetChar(r, i));
SetProviderField <IDataReader, TimeSpan, DateTime>((r, i) => r.GetDateTime(i) - new DateTime(1899, 12, 30));
SetProviderField <IDataReader, DateTime, DateTime>((r, i) => GetDateTime(r, i));
_sqlOptimizer = new AccessSqlOptimizer(SqlProviderFlags);
if (System.Globalization.CultureInfo.CurrentCulture.NumberFormat.NumberDecimalSeparator != ".")
{
_decimalType = OleDbType.VarChar;
}
}
public SqlServerDataProvider(string name, SqlServerVersion version)
: base(name, (MappingSchema)null)
{
Version = version;
if (version == SqlServerVersion.v2000)
{
SqlProviderFlags.AcceptsTakeAsParameter = false;
SqlProviderFlags.IsSkipSupported = false;
SqlProviderFlags.IsCountSubQuerySupported = false;
}
else
{
SqlProviderFlags.IsApplyJoinSupported = true;
SqlProviderFlags.TakeHintsSupported = TakeHints.Percent | TakeHints.WithTies;
SqlProviderFlags.IsCommonTableExpressionsSupported = version >= SqlServerVersion.v2008;
}
SetCharField("char", (r, i) => r.GetString(i).TrimEnd(' '));
SetCharField("nchar", (r, i) => r.GetString(i).TrimEnd(' '));
SetCharFieldToType <char>("char", (r, i) => DataTools.GetChar(r, i));
SetCharFieldToType <char>("nchar", (r, i) => DataTools.GetChar(r, i));
if (!Configuration.AvoidSpecificDataProviderAPI)
{
SetProviderField <SqlDataReader, SqlBinary, SqlBinary>((r, i) => r.GetSqlBinary(i));
SetProviderField <SqlDataReader, SqlBoolean, SqlBoolean>((r, i) => r.GetSqlBoolean(i));
SetProviderField <SqlDataReader, SqlByte, SqlByte>((r, i) => r.GetSqlByte(i));
SetProviderField <SqlDataReader, SqlDateTime, SqlDateTime>((r, i) => r.GetSqlDateTime(i));
SetProviderField <SqlDataReader, SqlDecimal, SqlDecimal>((r, i) => r.GetSqlDecimal(i));
SetProviderField <SqlDataReader, SqlDouble, SqlDouble>((r, i) => r.GetSqlDouble(i));
SetProviderField <SqlDataReader, SqlGuid, SqlGuid>((r, i) => r.GetSqlGuid(i));
SetProviderField <SqlDataReader, SqlInt16, SqlInt16>((r, i) => r.GetSqlInt16(i));
SetProviderField <SqlDataReader, SqlInt32, SqlInt32>((r, i) => r.GetSqlInt32(i));
SetProviderField <SqlDataReader, SqlInt64, SqlInt64>((r, i) => r.GetSqlInt64(i));
SetProviderField <SqlDataReader, SqlMoney, SqlMoney>((r, i) => r.GetSqlMoney(i));
SetProviderField <SqlDataReader, SqlSingle, SqlSingle>((r, i) => r.GetSqlSingle(i));
SetProviderField <SqlDataReader, SqlString, SqlString>((r, i) => r.GetSqlString(i));
SetProviderField <SqlDataReader, SqlXml, SqlXml>((r, i) => r.GetSqlXml(i));
SetProviderField <SqlDataReader, DateTimeOffset>((r, i) => r.GetDateTimeOffset(i));
SetProviderField <SqlDataReader, TimeSpan> ((r, i) => r.GetTimeSpan(i));
}
else
{
SetProviderField <IDataReader, SqlString, SqlString>((r, i) => r.GetString(i));
}
_sqlServer2000SqlOptimizer = new SqlServer2000SqlOptimizer(SqlProviderFlags);
_sqlServer2005SqlOptimizer = new SqlServer2005SqlOptimizer(SqlProviderFlags);
_sqlServer2008SqlOptimizer = new SqlServerSqlOptimizer(SqlProviderFlags);
_sqlServer2012SqlOptimizer = new SqlServer2012SqlOptimizer(SqlProviderFlags);
SetField <IDataReader, decimal>((r, i) => r.GetDecimal(i));
SetField <IDataReader, decimal>("money", (r, i) => SqlServerTools.DataReaderGetMoney(r, i));
SetField <IDataReader, decimal>("smallmoney", (r, i) => SqlServerTools.DataReaderGetMoney(r, i));
SetField <IDataReader, decimal>("decimal", (r, i) => SqlServerTools.DataReaderGetDecimal(r, i));
}
protected FirebirdDataProvider(string name, MappingSchema mappingSchema)
: base(name, mappingSchema)
{
SqlProviderFlags.IsIdentityParameterRequired = true;
SetCharField("CHAR", (r, i) => r.GetString(i).TrimEnd(' '));
SetCharFieldToType <char>("CHAR", (r, i) => DataTools.GetChar(r, i));
SetProviderField <IDataReader, TimeSpan, DateTime>((r, i) => r.GetDateTime(i) - new DateTime(1970, 1, 1));
SetProviderField <IDataReader, DateTime, DateTime>((r, i) => GetDateTime(r, i));
_sqlOptimizer = new FirebirdSqlOptimizer(SqlProviderFlags);
}
public InformixDataProvider(string providerName)
: base(
providerName,
GetMappingSchema(providerName, InformixProviderAdapter.GetInstance(providerName).MappingSchema),
InformixProviderAdapter.GetInstance(providerName))
{
SqlProviderFlags.IsParameterOrderDependent = !Adapter.IsIDSProvider;
SqlProviderFlags.IsSubQueryTakeSupported = false;
SqlProviderFlags.IsInsertOrUpdateSupported = false;
SqlProviderFlags.IsGroupByExpressionSupported = false;
SqlProviderFlags.IsCrossJoinSupported = false;
SqlProviderFlags.IsCommonTableExpressionsSupported = true;
SqlProviderFlags.IsSubQueryOrderBySupported = true;
SqlProviderFlags.IsDistinctOrderBySupported = false;
SqlProviderFlags.IsUpdateFromSupported = false;
SqlProviderFlags.IsGroupByColumnRequred = true;
SetCharField("CHAR", (r, i) => r.GetString(i).TrimEnd(' '));
SetCharField("NCHAR", (r, i) => r.GetString(i).TrimEnd(' '));
SetCharFieldToType <char>("CHAR", (r, i) => DataTools.GetChar(r, i));
SetCharFieldToType <char>("NCHAR", (r, i) => DataTools.GetChar(r, i));
SetProviderField <IDataReader, float, float>((r, i) => GetFloat(r, i));
SetProviderField <IDataReader, double, double>((r, i) => GetDouble(r, i));
SetProviderField <IDataReader, decimal, decimal>((r, i) => GetDecimal(r, i));
SetField <IDataReader, float>((r, i) => GetFloat(r, i));
SetField <IDataReader, double>((r, i) => GetDouble(r, i));
SetField <IDataReader, decimal>((r, i) => GetDecimal(r, i));
_sqlOptimizer = new InformixSqlOptimizer(SqlProviderFlags);
if (Adapter.GetBigIntReaderMethod != null)
{
SetField(typeof(long), "BIGINT", Adapter.GetBigIntReaderMethod, false, dataReaderType: Adapter.DataReaderType);
}
if (Name == ProviderName.Informix && Adapter.DecimalType != null)
{
SetProviderField(Adapter.DecimalType, typeof(decimal), Adapter.GetDecimalReaderMethod !, dataReaderType: Adapter.DataReaderType);
}
if (Adapter.DateTimeType != null)
{
SetProviderField(Adapter.DateTimeType, typeof(DateTime), Adapter.GetDateTimeReaderMethod, dataReaderType: Adapter.DataReaderType);
}
if (Adapter.TimeSpanType != null)
{
SetProviderField(Adapter.TimeSpanType, typeof(TimeSpan), Adapter.GetTimeSpanReaderMethod, dataReaderType: Adapter.DataReaderType);
}
}
protected SqlCeDataProvider(string name, MappingSchema mappingSchema)
: base(name, mappingSchema)
{
SqlProviderFlags.IsSubQueryColumnSupported = false;
SqlProviderFlags.IsCountSubQuerySupported = false;
SqlProviderFlags.IsApplyJoinSupported = true;
SqlProviderFlags.IsInsertOrUpdateSupported = false;
SqlProviderFlags.IsCrossJoinSupported = true;
SetCharFieldToType <char>("NChar", (r, i) => DataTools.GetChar(r, i));
SetCharField("NChar", (r, i) => r.GetString(i).TrimEnd(' '));
_sqlOptimizer = new SqlCeSqlOptimizer(SqlProviderFlags);
}
public DB2DataProvider(string name, DB2Version version)
: base(name, null)
{
Version = version;
SqlProviderFlags.AcceptsTakeAsParameter = false;
SqlProviderFlags.AcceptsTakeAsParameterIfSkip = true;
SqlProviderFlags.IsDistinctOrderBySupported = version != DB2Version.zOS;
SetCharFieldToType <char>("CHAR", (r, i) => DataTools.GetChar(r, i));
SetCharField("CHAR", (r, i) => r.GetString(i).TrimEnd(' '));
_sqlOptimizer = new DB2SqlOptimizer(SqlProviderFlags);
}
protected SQLiteDataProvider(string name, MappingSchema mappingSchema)
: base(name, mappingSchema)
{
SqlProviderFlags.IsSkipSupported = false;
SqlProviderFlags.IsSkipSupportedIfTake = true;
SqlProviderFlags.IsInsertOrUpdateSupported = false;
SqlProviderFlags.IsUpdateSetTableAliasSupported = false;
SetCharField("char", (r, i) => r.GetString(i).TrimEnd(' '));
SetCharField("nchar", (r, i) => r.GetString(i).TrimEnd(' '));
SetCharFieldToType <char>("char", (r, i) => DataTools.GetChar(r, i));
SetCharFieldToType <char>("nchar", (r, i) => DataTools.GetChar(r, i));
_sqlOptimizer = new SQLiteSqlOptimizer(SqlProviderFlags);
}
protected FirebirdDataProvider(string name, MappingSchema mappingSchema, ISqlOptimizer sqlOptimizer)
: base(name, mappingSchema)
{
SqlProviderFlags.IsIdentityParameterRequired = true;
SqlProviderFlags.IsCommonTableExpressionsSupported = true;
SqlProviderFlags.IsSubQueryOrderBySupported = true;
SqlProviderFlags.IsDistinctSetOperationsSupported = false;
SetCharField("CHAR", (r, i) => r.GetString(i).TrimEnd(' '));
SetCharFieldToType <char>("CHAR", (r, i) => DataTools.GetChar(r, i));
SetProviderField <IDataReader, TimeSpan, DateTime>((r, i) => r.GetDateTime(i) - new DateTime(1970, 1, 1));
SetProviderField <IDataReader, DateTime, DateTime>((r, i) => GetDateTime(r, i));
_sqlOptimizer = sqlOptimizer ?? new FirebirdSqlOptimizer(SqlProviderFlags);
}
protected PostgreSQLDataProvider(string name, MappingSchema mappingSchema, PostgreSQLVersion version = PostgreSQLVersion.v92)
: base(name, mappingSchema)
{
Version = version;
SqlProviderFlags.IsApplyJoinSupported = version != PostgreSQLVersion.v92;
SqlProviderFlags.IsInsertOrUpdateSupported = version == PostgreSQLVersion.v95;
SqlProviderFlags.IsUpdateSetTableAliasSupported = false;
SqlProviderFlags.IsCommonTableExpressionsSupported = true;
SetCharFieldToType <char>("bpchar", (r, i) => DataTools.GetChar(r, i));
SetCharField("bpchar", (r, i) => r.GetString(i).TrimEnd(' '));
_sqlOptimizer = new PostgreSQLSqlOptimizer(SqlProviderFlags);
}
public DB2DataProvider(string name, DB2Version version)
: base(
name,
GetMappingSchema(version, DB2ProviderAdapter.GetInstance().MappingSchema),
DB2ProviderAdapter.GetInstance())
{
Version = version;
SqlProviderFlags.AcceptsTakeAsParameter = false;
SqlProviderFlags.AcceptsTakeAsParameterIfSkip = true;
SqlProviderFlags.IsDistinctOrderBySupported = false;
SqlProviderFlags.IsCommonTableExpressionsSupported = true;
SqlProviderFlags.IsUpdateFromSupported = false;
SetCharFieldToType <char>("CHAR", (r, i) => DataTools.GetChar(r, i));
SetCharField("CHAR", (r, i) => r.GetString(i).TrimEnd(' '));
_sqlOptimizer = new DB2SqlOptimizer(SqlProviderFlags);
SetProviderField(Adapter.DB2Int64Type, typeof(long), Adapter.GetDB2Int64ReaderMethod, dataReaderType: Adapter.DataReaderType);
SetProviderField(Adapter.DB2Int32Type, typeof(int), Adapter.GetDB2Int32ReaderMethod, dataReaderType: Adapter.DataReaderType);
SetProviderField(Adapter.DB2Int16Type, typeof(short), Adapter.GetDB2Int16ReaderMethod, dataReaderType: Adapter.DataReaderType);
SetProviderField(Adapter.DB2DecimalType, typeof(decimal), Adapter.GetDB2DecimalReaderMethod, dataReaderType: Adapter.DataReaderType);
SetProviderField(Adapter.DB2DecimalFloatType, typeof(decimal), Adapter.GetDB2DecimalFloatReaderMethod, dataReaderType: Adapter.DataReaderType);
SetProviderField(Adapter.DB2RealType, typeof(float), Adapter.GetDB2RealReaderMethod, dataReaderType: Adapter.DataReaderType);
SetProviderField(Adapter.DB2Real370Type, typeof(float), Adapter.GetDB2Real370ReaderMethod, dataReaderType: Adapter.DataReaderType);
SetProviderField(Adapter.DB2DoubleType, typeof(double), Adapter.GetDB2DoubleReaderMethod, dataReaderType: Adapter.DataReaderType);
SetProviderField(Adapter.DB2StringType, typeof(string), Adapter.GetDB2StringReaderMethod, dataReaderType: Adapter.DataReaderType);
SetProviderField(Adapter.DB2ClobType, typeof(string), Adapter.GetDB2ClobReaderMethod, dataReaderType: Adapter.DataReaderType);
SetProviderField(Adapter.DB2BinaryType, typeof(byte[]), Adapter.GetDB2BinaryReaderMethod, dataReaderType: Adapter.DataReaderType);
SetProviderField(Adapter.DB2BlobType, typeof(byte[]), Adapter.GetDB2BlobReaderMethod, dataReaderType: Adapter.DataReaderType);
SetProviderField(Adapter.DB2DateType, typeof(DateTime), Adapter.GetDB2DateReaderMethod, dataReaderType: Adapter.DataReaderType);
SetProviderField(Adapter.DB2TimeType, typeof(TimeSpan), Adapter.GetDB2TimeReaderMethod, dataReaderType: Adapter.DataReaderType);
SetProviderField(Adapter.DB2TimeStampType, typeof(DateTime), Adapter.GetDB2TimeStampReaderMethod, dataReaderType: Adapter.DataReaderType);
SetProviderField(Adapter.DB2XmlType, typeof(string), Adapter.GetDB2XmlReaderMethod, dataReaderType: Adapter.DataReaderType);
SetProviderField(Adapter.DB2RowIdType, typeof(byte[]), Adapter.GetDB2RowIdReaderMethod, dataReaderType: Adapter.DataReaderType);
if (Adapter.DB2DateTimeType != null)
{
SetProviderField(Adapter.DB2DateTimeType, typeof(DateTime), Adapter.GetDB2DateTimeReaderMethod !, dataReaderType: Adapter.DataReaderType);
}
}
protected SqlCeDataProvider(string name, MappingSchema mappingSchema)
: base(name, mappingSchema, SqlCeProviderAdapter.GetInstance())
{
SqlProviderFlags.IsSubQueryColumnSupported = false;
SqlProviderFlags.IsCountSubQuerySupported = false;
SqlProviderFlags.IsApplyJoinSupported = true;
SqlProviderFlags.IsInsertOrUpdateSupported = false;
SqlProviderFlags.IsCrossJoinSupported = true;
SqlProviderFlags.IsDistinctOrderBySupported = false;
SqlProviderFlags.IsOrderByAggregateFunctionsSupported = false;
SqlProviderFlags.IsDistinctSetOperationsSupported = false;
SqlProviderFlags.IsUpdateFromSupported = false;
SetCharFieldToType <char>("NChar", (r, i) => DataTools.GetChar(r, i));
SetCharField("NChar", (r, i) => r.GetString(i).TrimEnd(' '));
SetCharField("NVarChar", (r, i) => r.GetString(i).TrimEnd(' '));
_sqlOptimizer = new SqlCeSqlOptimizer(SqlProviderFlags);
}
public OracleDataProvider(string name)
: base(name, null)
{
//SqlProviderFlags.IsCountSubQuerySupported = false;
SqlProviderFlags.IsIdentityParameterRequired = true;
SqlProviderFlags.MaxInListValuesCount = 1000;
SetCharField("Char", (r,i) => r.GetString(i).TrimEnd(' '));
SetCharField("NChar", (r,i) => r.GetString(i).TrimEnd(' '));
SetCharFieldToType<char>("Char", (r, i) => DataTools.GetChar(r, i));
SetCharFieldToType<char>("NChar", (r, i) => DataTools.GetChar(r, i));
// ReaderExpressions[new ReaderInfo { FieldType = typeof(decimal), ToType = typeof(TimeSpan) }] =
// (Expression<Func<IDataReader,int,TimeSpan>>)((rd,n) => new TimeSpan((long)rd.GetDecimal(n)));
_sqlOptimizer = new OracleSqlOptimizer(SqlProviderFlags);
// SetField<IDataReader,decimal>((r,i) => OracleTools.DataReaderGetDecimal(r, i));
}
protected SQLiteDataProvider(string name, MappingSchema mappingSchema)
: base(name, mappingSchema, SQLiteProviderAdapter.GetInstance(name))
{
SqlProviderFlags.IsSkipSupported = false;
SqlProviderFlags.IsSkipSupportedIfTake = true;
SqlProviderFlags.IsInsertOrUpdateSupported = false;
SqlProviderFlags.IsUpdateSetTableAliasSupported = false;
SqlProviderFlags.IsCommonTableExpressionsSupported = true;
SqlProviderFlags.IsDistinctOrderBySupported = true;
SqlProviderFlags.IsSubQueryOrderBySupported = true;
SqlProviderFlags.IsDistinctSetOperationsSupported = true;
SqlProviderFlags.IsUpdateFromSupported = false;
SqlProviderFlags.DefaultMultiQueryIsolationLevel = IsolationLevel.Serializable;
SetCharField("char", (r, i) => r.GetString(i).TrimEnd(' '));
SetCharField("nchar", (r, i) => r.GetString(i).TrimEnd(' '));
SetCharFieldToType <char>("char", (r, i) => DataTools.GetChar(r, i));
SetCharFieldToType <char>("nchar", (r, i) => DataTools.GetChar(r, i));
_sqlOptimizer = new SQLiteSqlOptimizer(SqlProviderFlags);
}
protected SybaseDataProvider(string name, MappingSchema mappingSchema)
: base(name, mappingSchema)
{
SqlProviderFlags.AcceptsTakeAsParameter = false;
SqlProviderFlags.IsSkipSupported = false;
SqlProviderFlags.IsSubQueryTakeSupported = false;
//SqlProviderFlags.IsCountSubQuerySupported = false;
SqlProviderFlags.CanCombineParameters = false;
SqlProviderFlags.IsSybaseBuggyGroupBy = true;
SqlProviderFlags.IsCrossJoinSupported = false;
SetCharField("char", (r, i) => r.GetString(i).TrimEnd(' '));
SetCharField("nchar", (r, i) => r.GetString(i).TrimEnd(' '));
SetCharFieldToType <char>("char", (r, i) => DataTools.GetChar(r, i));
SetCharFieldToType <char>("nchar", (r, i) => DataTools.GetChar(r, i));
SetProviderField <IDataReader, TimeSpan, DateTime>((r, i) => r.GetDateTime(i) - new DateTime(1900, 1, 1));
SetProviderField <IDataReader, DateTime, DateTime>((r, i) => GetDateTime(r, i));
_sqlOptimizer = new SybaseSqlOptimizer(SqlProviderFlags);
}
protected AccessOleDbDataProvider(string name, MappingSchema mappingSchema)
: base(name, mappingSchema, OleDbProviderAdapter.GetInstance())
{
SqlProviderFlags.AcceptsTakeAsParameter = false;
SqlProviderFlags.IsSkipSupported = false;
SqlProviderFlags.IsCountSubQuerySupported = false;
SqlProviderFlags.IsInsertOrUpdateSupported = false;
SqlProviderFlags.TakeHintsSupported = TakeHints.Percent;
SqlProviderFlags.IsCrossJoinSupported = false;
SqlProviderFlags.IsInnerJoinAsCrossSupported = false;
SqlProviderFlags.IsDistinctOrderBySupported = false;
SqlProviderFlags.IsDistinctSetOperationsSupported = false;
SqlProviderFlags.IsParameterOrderDependent = true;
SqlProviderFlags.IsUpdateFromSupported = false;
SqlProviderFlags.DefaultMultiQueryIsolationLevel = IsolationLevel.Unspecified;
SetCharField("DBTYPE_WCHAR", (r, i) => r.GetString(i).TrimEnd(' '));
SetCharFieldToType <char>("DBTYPE_WCHAR", (r, i) => DataTools.GetChar(r, i));
SetProviderField <IDataReader, TimeSpan, DateTime>((r, i) => r.GetDateTime(i) - new DateTime(1899, 12, 30));
_sqlOptimizer = new AccessSqlOptimizer(SqlProviderFlags);
}
public SybaseDataProvider(string name)
: base(name, null)
{
SqlProviderFlags.AcceptsTakeAsParameter = false;
SqlProviderFlags.IsSkipSupported = false;
SqlProviderFlags.IsSubQueryTakeSupported = false;
//SqlProviderFlags.IsCountSubQuerySupported = false;
SqlProviderFlags.CanCombineParameters = false;
SqlProviderFlags.IsSybaseBuggyGroupBy = true;
SqlProviderFlags.IsCrossJoinSupported = false;
SqlProviderFlags.IsSubQueryOrderBySupported = false;
SqlProviderFlags.IsDistinctOrderBySupported = false;
SqlProviderFlags.IsDistinctSetOperationsSupported = false;
SetCharField("char", (r, i) => r.GetString(i).TrimEnd(' '));
SetCharField("nchar", (r, i) => r.GetString(i).TrimEnd(' '));
SetCharFieldToType <char>("char", (r, i) => DataTools.GetChar(r, i));
SetCharFieldToType <char>("nchar", (r, i) => DataTools.GetChar(r, i));
SetProviderField <IDataReader, TimeSpan, DateTime>((r, i) => r.GetDateTime(i) - new DateTime(1900, 1, 1));
SetField <IDataReader, DateTime>("time", (r, i) => GetDateTimeAsTime(r, i));
_sqlOptimizer = new SybaseSqlOptimizer(SqlProviderFlags);
}
public SqlServerDataProvider(string name, SqlServerVersion version, SqlServerProvider provider)
: base(
name,
MappingSchemaInstance.Get(version),
SqlServerProviderAdapter.GetInstance(provider))
{
Version = version;
Provider = provider;
SqlProviderFlags.IsDistinctOrderBySupported = false;
SqlProviderFlags.IsSubQueryOrderBySupported = false;
SqlProviderFlags.IsDistinctSetOperationsSupported = true;
SqlProviderFlags.IsCountDistinctSupported = true;
SqlProviderFlags.IsUpdateFromSupported = true;
if (version == SqlServerVersion.v2000)
{
SqlProviderFlags.AcceptsTakeAsParameter = false;
SqlProviderFlags.IsSkipSupported = false;
SqlProviderFlags.IsCountSubQuerySupported = false;
}
else
{
SqlProviderFlags.IsApplyJoinSupported = true;
SqlProviderFlags.TakeHintsSupported = TakeHints.Percent | TakeHints.WithTies;
SqlProviderFlags.IsCommonTableExpressionsSupported = version >= SqlServerVersion.v2008;
}
SetCharField("char", (r, i) => r.GetString(i).TrimEnd(' '));
SetCharField("nchar", (r, i) => r.GetString(i).TrimEnd(' '));
SetCharFieldToType <char>("char", (r, i) => DataTools.GetChar(r, i));
SetCharFieldToType <char>("nchar", (r, i) => DataTools.GetChar(r, i));
_sqlOptimizer = version switch
{
SqlServerVersion.v2000 => new SqlServer2000SqlOptimizer(SqlProviderFlags),
SqlServerVersion.v2005 => new SqlServer2005SqlOptimizer(SqlProviderFlags),
SqlServerVersion.v2012 => new SqlServer2012SqlOptimizer(SqlProviderFlags),
SqlServerVersion.v2017 => new SqlServer2017SqlOptimizer(SqlProviderFlags),
_ => new SqlServer2008SqlOptimizer(SqlProviderFlags),
};
SetField <IDataReader, decimal>((r, i) => r.GetDecimal(i));
SetField <IDataReader, decimal>("money", (r, i) => SqlServerTools.DataReaderGetMoney(r, i));
SetField <IDataReader, decimal>("smallmoney", (r, i) => SqlServerTools.DataReaderGetMoney(r, i));
SetField <IDataReader, decimal>("decimal", (r, i) => SqlServerTools.DataReaderGetDecimal(r, i));
// missing:
// GetSqlBytes
// GetSqlChars
SetProviderField <SqlBinary, SqlBinary>(SqlTypes.GetSqlBinaryReaderMethod, dataReaderType: Adapter.DataReaderType);
SetProviderField <SqlBoolean, SqlBoolean>(SqlTypes.GetSqlBooleanReaderMethod, dataReaderType: Adapter.DataReaderType);
SetProviderField <SqlByte, SqlByte>(SqlTypes.GetSqlByteReaderMethod, dataReaderType: Adapter.DataReaderType);
SetProviderField <SqlDateTime, SqlDateTime>(SqlTypes.GetSqlDateTimeReaderMethod, dataReaderType: Adapter.DataReaderType);
SetProviderField <SqlDecimal, SqlDecimal>(SqlTypes.GetSqlDecimalReaderMethod, dataReaderType: Adapter.DataReaderType);
SetProviderField <SqlDouble, SqlDouble>(SqlTypes.GetSqlDoubleReaderMethod, dataReaderType: Adapter.DataReaderType);
SetProviderField <SqlGuid, SqlGuid>(SqlTypes.GetSqlGuidReaderMethod, dataReaderType: Adapter.DataReaderType);
SetProviderField <SqlInt16, SqlInt16>(SqlTypes.GetSqlInt16ReaderMethod, dataReaderType: Adapter.DataReaderType);
SetProviderField <SqlInt32, SqlInt32>(SqlTypes.GetSqlInt32ReaderMethod, dataReaderType: Adapter.DataReaderType);
SetProviderField <SqlInt64, SqlInt64>(SqlTypes.GetSqlInt64ReaderMethod, dataReaderType: Adapter.DataReaderType);
SetProviderField <SqlMoney, SqlMoney>(SqlTypes.GetSqlMoneyReaderMethod, dataReaderType: Adapter.DataReaderType);
SetProviderField <SqlSingle, SqlSingle>(SqlTypes.GetSqlSingleReaderMethod, dataReaderType: Adapter.DataReaderType);
SetProviderField <SqlString, SqlString>(SqlTypes.GetSqlStringReaderMethod, dataReaderType: Adapter.DataReaderType);
SetProviderField <SqlXml, SqlXml>(Adapter.GetSqlXmlReaderMethod, dataReaderType: Adapter.DataReaderType);
SetProviderField <DateTimeOffset>(Adapter.GetDateTimeOffsetReaderMethod, dataReaderType: Adapter.DataReaderType);
SetProviderField <TimeSpan> (Adapter.GetTimeSpanReaderMethod, dataReaderType: Adapter.DataReaderType);
// non-specific fallback
SetProviderField <IDataReader, SqlString, SqlString>((r, i) => r.GetString(i));
SqlServerTypes.Configure(this);
}
protected SQLiteDataProvider(string name, MappingSchema mappingSchema)
: base(name, mappingSchema, SQLiteProviderAdapter.GetInstance(name))
{
SqlProviderFlags.IsSkipSupported = false;
SqlProviderFlags.IsSkipSupportedIfTake = true;
SqlProviderFlags.IsInsertOrUpdateSupported = false;
SqlProviderFlags.IsUpdateSetTableAliasSupported = false;
SqlProviderFlags.IsCommonTableExpressionsSupported = true;
SqlProviderFlags.IsDistinctOrderBySupported = true;
SqlProviderFlags.IsSubQueryOrderBySupported = true;
SqlProviderFlags.IsDistinctSetOperationsSupported = true;
SqlProviderFlags.IsUpdateFromSupported = false;
SqlProviderFlags.DefaultMultiQueryIsolationLevel = IsolationLevel.Serializable;
_sqlOptimizer = new SQLiteSqlOptimizer(SqlProviderFlags);
/*
* WHAT'S WRONG WITH SQLITE:
* - sqlite has only 5 types: https://sqlite.org/datatype3.html
* - types applied to value, not to column => column could contain value of any type (e.g. all 5 types)
* - there is "column type affinity" thingy, which doesn't help with data read
*
* Which means our general approach to build column read expression, where we ask data reader
* about column type and read value using corresponding Get*() method, doesn't work as provider cannot
* give us detailed type information.
*
* How it works for supported providers
* System.Data.Sqlite:
* This provider actually works fine, as it use column type name from create table statement to infer column
* type. In other words, while you use proper type names to create your table and don't mix values of different
* types in your column - you are safe.
*
* Microsoft.Data.Sqlite:
* This provider decides to leave typing to user and return data to user only using 5 basic types
* (v1.x also could return int-typed value, which is just casted long value).
*
* Which means we need to handle Microsoft.Data.Sqlite in special way to be able to read data from database
* without fallback to slow-mode mapping
*
* There are two ways to fix it:
* 1. implement extra type-name resolve as it is done by System.Data.Sqlite (we can still get type name from provider)
* 2. implement mixed type support using target field type
*
* in other words use column type name vs target field type to decide value of which type we should create (read)
*
* While 2 sounds tempting, it doesn't work well with mapping to custom field types. Also VARIANT-like columns is
* not something users usually do, even with sqlite, so we will implement first approach here.
*
* Type information we can get from provider:
* 1. column type name from GetDataTypeName(): could be type name from CREATE TABLE statement or if this
* information missing - standard type: INTEGER, REAL, TEXT, BLOB
* for null/unknown type will be BLOB (or INTEGER in v1)
* 2. .net type of value: long, double, string, byte[]
* for null/unknown type it will be byte[] (or int in v1)
*
* So, in code below we will map default type names and type names, used by System.Data.Sqlite to reader expressions.
* With additional fixes for cases, where it doesn't work well due to provider being unable to convert value to
* requested type.
*/
if (Name == ProviderName.SQLiteMS)
{
SetSqliteField((r, i) => r.GetInt64(i), new[] { typeof(long), typeof(string), typeof(double) },
"INTEGER", "BIGINT", "COUNTER", "IDENTITY", "INT64", "INTEGER64", "LONG", "MEDIUMINT", "UINT", "UINT32", "UNSIGNEDINTEGER32");
SetSqliteField((r, i) => r.GetDecimal(i), new[] { typeof(long), typeof(string), typeof(double) },
"CURRENCY", "DECIMAL", "DECIMALTEXT", "MONEY", "NUMBER", "NUMERIC", "VARNUMERIC", "NUMERICTEXT", "SMALLMONEY", "BIGUINT", "UINT64", "ULONG", "UNSIGNEDINTEGER", "UNSIGNEDINTEGER64");
SetSqliteField((r, i) => r.GetInt32(i), new[] { typeof(long), typeof(string), typeof(double) },
"INT", "INT32", "INTEGER32", "MEDIUMINT", "SMALLUINT", "UINT16", "UNSIGNEDINTEGER16");
SetSqliteField((r, i) => r.GetInt16(i), new[] { typeof(long), typeof(string), typeof(double) },
"INT8", "INT16", "INTEGER8", "INTEGER16", "SMALLINT", "TINYSINT", "SBYTE");
SetSqliteField((r, i) => r.GetByte(i), new[] { typeof(long), typeof(string), typeof(double) },
"TINYINT", "UINT8", "UNSIGNEDINTEGER8", "BYTE");
SetSqliteField((r, i) => r.GetDouble(i), new[] { typeof(long), typeof(string), typeof(double) },
"REAL", "DOUBLE", "FLOAT");
SetSqliteField((r, i) => r.GetByte(i), new[] { typeof(long), typeof(string), typeof(double) },
"SINGLE");
SetSqliteField((r, i) => r.GetString(i), new[] { typeof(string) },
"TEXT", "CHAR", "CLOB", "LONGCHAR", "LONGTEXT", "LONGVARCHAR", "MEMO", "NCHAR", "NOTE", "NTEXT", "NVARCHAR", "STRING", "VARCHAR", "VARCHAR2");
SetSqliteField((r, i) => (byte[])r.GetValue(i), new[] { typeof(byte[]), typeof(string) },
"BLOB", "BINARY", "GENERAL", "IMAGE", "OLEOBJECT", "RAW", "VARBINARY");
SetSqliteField((r, i) => r.GetGuid(i), new[] { typeof(string), typeof(byte[]) },
"GUID", "UNIQUEIDENTIFIER");
SetSqliteField((r, i) => r.GetBoolean(i), new[] { typeof(long), typeof(string), typeof(double) },
"BIT", "BOOL", "BOOLEAN", "LOGICAL", "YESNO");
SetSqliteField((r, i) => r.GetDateTime(i), new[] { typeof(long), typeof(string), typeof(double) },
"DATETIME", "DATETIME2", "DATE", "SMALLDATE", "SMALLDATETIME", "TIME", "TIMESTAMP", "DATETIMEOFFSET");
// also specify explicit converter for non-integer numerics, repored as integer by provider
SetToType <IDataReader, float, long>((r, i) => r.GetFloat(i));
SetToType <IDataReader, double, long>((r, i) => r.GetDouble(i));
SetToType <IDataReader, decimal, long>((r, i) => r.GetDecimal(i));
}
SetCharField("char", (r, i) => r.GetString(i).TrimEnd(' '));
SetCharField("nchar", (r, i) => r.GetString(i).TrimEnd(' '));
SetCharFieldToType <char>("char", (r, i) => DataTools.GetChar(r, i));
SetCharFieldToType <char>("nchar", (r, i) => DataTools.GetChar(r, i));
}
public OracleDataProvider(string name, OracleVersion version)
: base(
name,
GetMappingSchema(name, OracleProviderAdapter.GetInstance(name).MappingSchema),
OracleProviderAdapter.GetInstance(name))
{
Version = version;
//SqlProviderFlags.IsCountSubQuerySupported = false;
SqlProviderFlags.IsIdentityParameterRequired = true;
SqlProviderFlags.IsCommonTableExpressionsSupported = true;
SqlProviderFlags.IsSubQueryOrderBySupported = true;
SqlProviderFlags.IsDistinctOrderBySupported = false;
SqlProviderFlags.IsUpdateFromSupported = false;
SqlProviderFlags.DefaultMultiQueryIsolationLevel = IsolationLevel.ReadCommitted;
if (version >= OracleVersion.v12)
{
SqlProviderFlags.IsApplyJoinSupported = true;
}
SqlProviderFlags.MaxInListValuesCount = 1000;
SetCharField("Char", (r, i) => r.GetString(i).TrimEnd(' '));
SetCharField("NChar", (r, i) => r.GetString(i).TrimEnd(' '));
SetCharFieldToType <char>("Char", (r, i) => DataTools.GetChar(r, i));
SetCharFieldToType <char>("NChar", (r, i) => DataTools.GetChar(r, i));
if (version == OracleVersion.v11)
{
_sqlOptimizer = new Oracle11SqlOptimizer(SqlProviderFlags);
}
else
{
_sqlOptimizer = new Oracle12SqlOptimizer(SqlProviderFlags);
}
SetProviderField(Adapter.OracleBFileType, Adapter.OracleBFileType, Adapter.GetOracleBFileReaderMethod, dataReaderType: Adapter.DataReaderType);
SetProviderField(Adapter.OracleBinaryType, Adapter.OracleBinaryType, Adapter.GetOracleBinaryReaderMethod, dataReaderType: Adapter.DataReaderType);
SetProviderField(Adapter.OracleBlobType, Adapter.OracleBlobType, Adapter.GetOracleBlobReaderMethod, dataReaderType: Adapter.DataReaderType);
SetProviderField(Adapter.OracleClobType, Adapter.OracleClobType, Adapter.GetOracleClobReaderMethod, dataReaderType: Adapter.DataReaderType);
SetProviderField(Adapter.OracleDateType, Adapter.OracleDateType, Adapter.GetOracleDateReaderMethod, dataReaderType: Adapter.DataReaderType);
SetProviderField(Adapter.OracleDecimalType, Adapter.OracleDecimalType, Adapter.GetOracleDecimalReaderMethod, dataReaderType: Adapter.DataReaderType);
SetProviderField(Adapter.OracleIntervalDSType, Adapter.OracleIntervalDSType, Adapter.GetOracleIntervalDSReaderMethod, dataReaderType: Adapter.DataReaderType);
SetProviderField(Adapter.OracleIntervalYMType, Adapter.OracleIntervalYMType, Adapter.GetOracleIntervalYMReaderMethod, dataReaderType: Adapter.DataReaderType);
SetProviderField(Adapter.OracleStringType, Adapter.OracleStringType, Adapter.GetOracleStringReaderMethod, dataReaderType: Adapter.DataReaderType);
SetProviderField(Adapter.OracleTimeStampType, Adapter.OracleTimeStampType, Adapter.GetOracleTimeStampReaderMethod, dataReaderType: Adapter.DataReaderType);
SetProviderField(Adapter.OracleTimeStampLTZType, Adapter.OracleTimeStampLTZType, Adapter.GetOracleTimeStampLTZReaderMethod, dataReaderType: Adapter.DataReaderType);
SetProviderField(Adapter.OracleTimeStampTZType, Adapter.OracleTimeStampTZType, Adapter.GetOracleTimeStampTZReaderMethod, dataReaderType: Adapter.DataReaderType);
SetProviderField(Adapter.OracleXmlTypeType, Adapter.OracleXmlTypeType, Adapter.GetOracleXmlTypeReaderMethod, dataReaderType: Adapter.DataReaderType);
// native provider only
if (Adapter.OracleRefType != null)
{
SetProviderField(Adapter.OracleRefType, Adapter.OracleRefType, Adapter.GetOracleRefReaderMethod !, dataReaderType: Adapter.DataReaderType);
}
ReaderExpressions[new ReaderInfo {
ToType = typeof(DateTimeOffset), ProviderFieldType = Adapter.OracleTimeStampTZType, DataReaderType = Adapter.DataReaderType
}]
= Adapter.ReadDateTimeOffsetFromOracleTimeStampTZ;
ReaderExpressions[new ReaderInfo {
ToType = typeof(decimal), ProviderFieldType = Adapter.OracleDecimalType, DataReaderType = Adapter.DataReaderType
}] = Adapter.ReadOracleDecimalToDecimalAdv;
ReaderExpressions[new ReaderInfo {
ToType = typeof(decimal), FieldType = typeof(decimal), DataReaderType = Adapter.DataReaderType
}] = Adapter.ReadOracleDecimalToDecimalAdv;
ReaderExpressions[new ReaderInfo {
ToType = typeof(int), FieldType = typeof(decimal), DataReaderType = Adapter.DataReaderType
}] = Adapter.ReadOracleDecimalToInt;
ReaderExpressions[new ReaderInfo {
ToType = typeof(long), FieldType = typeof(decimal), DataReaderType = Adapter.DataReaderType
}] = Adapter.ReadOracleDecimalToLong;
ReaderExpressions[new ReaderInfo {
FieldType = typeof(decimal), DataReaderType = Adapter.DataReaderType
}] = Adapter.ReadOracleDecimalToDecimal;
ReaderExpressions[new ReaderInfo {
ToType = typeof(DateTimeOffset), ProviderFieldType = Adapter.OracleTimeStampLTZType, DataReaderType = Adapter.DataReaderType
}] = Adapter.ReadDateTimeOffsetFromOracleTimeStampLTZ;
}
