[Test, NorthwindDataContext(true)] // SQLite returns Int64 for column instead of Int32 public void Test1(string context) { var connectionString = DataConnection.GetConnectionString(context); var dataProvider = DataConnection.GetDataProvider(context); using (var conn = new DataConnection(dataProvider, connectionString)) { conn.InitCommand(CommandType.Text, "SELECT 1", null, null); var rd = conn.Command.ExecuteReader(); if (rd.Read()) { var dp = conn.DataProvider; var p = Expression.Parameter(typeof(IDataReader)); var dr = Expression.Convert(p, dp.DataReaderType); var ex = (Expression<Func<IDataReader,int,int>>)dp.GetReaderExpression(conn.MappingSchema, rd, 0, dr, typeof(int)); var func = ex.Compile(); do { var value = func(rd, 0); Assert.AreEqual(1, value); } while (rd.Read()); } else { Assert.Fail(); } } }
public void Test1(string context) { var connectionString = ConfigurationManager.ConnectionStrings["Northwind"].ConnectionString; using (var conn = new DataConnection(SqlServerTools.GetDataProvider(), connectionString)) { conn.SetCommand("SELECT 1"); var rd = conn.Command.ExecuteReader(); if (rd.Read()) { var dp = conn.DataProvider; var p = Expression.Parameter(typeof(IDataReader)); var dr = Expression.Convert(p, dp.DataReaderType); var ex = (Expression<Func<IDataReader,int,int>>)dp.GetReaderExpression(conn.MappingSchema, rd, 0, dr, typeof(int)); var func = ex.Compile(); do { var value = func(rd, 0); Assert.AreEqual(1, value); } while (rd.Read()); } else { Assert.Fail(); } } }
public void TestChar([IncludeDataContexts(CurrentProvider)] string context) { using (var conn = new DataConnection(context)) { Assert.That(conn.Execute<char> ("SELECT Cast('1' as char)"), Is.EqualTo('1')); Assert.That(conn.Execute<char?>("SELECT Cast('1' as char)"), Is.EqualTo('1')); Assert.That(conn.Execute<char> ("SELECT Cast('1' as char(1))"), Is.EqualTo('1')); Assert.That(conn.Execute<char?>("SELECT Cast('1' as char(1))"), Is.EqualTo('1')); Assert.That(conn.Execute<char> ("SELECT @p", DataParameter.Char("p", '1')), Is.EqualTo('1')); Assert.That(conn.Execute<char?>("SELECT @p", DataParameter.Char("p", '1')), Is.EqualTo('1')); Assert.That(conn.Execute<char> ("SELECT Cast(@p as char)", DataParameter.Char("p", '1')), Is.EqualTo('1')); Assert.That(conn.Execute<char?>("SELECT Cast(@p as char)", DataParameter.Char("p", '1')), Is.EqualTo('1')); Assert.That(conn.Execute<char> ("SELECT Cast(@p as char(1))", DataParameter.Char("@p", '1')), Is.EqualTo('1')); Assert.That(conn.Execute<char?>("SELECT Cast(@p as char(1))", DataParameter.Char("@p", '1')), Is.EqualTo('1')); Assert.That(conn.Execute<char> ("SELECT @p", DataParameter.VarChar ("p", '1')), Is.EqualTo('1')); Assert.That(conn.Execute<char?>("SELECT @p", DataParameter.VarChar ("p", '1')), Is.EqualTo('1')); Assert.That(conn.Execute<char> ("SELECT @p", DataParameter.NChar ("p", '1')), Is.EqualTo('1')); Assert.That(conn.Execute<char?>("SELECT @p", DataParameter.NChar ("p", '1')), Is.EqualTo('1')); Assert.That(conn.Execute<char> ("SELECT @p", DataParameter.NVarChar("p", '1')), Is.EqualTo('1')); Assert.That(conn.Execute<char?>("SELECT @p", DataParameter.NVarChar("p", '1')), Is.EqualTo('1')); Assert.That(conn.Execute<char> ("SELECT @p", DataParameter.Create ("p", '1')), Is.EqualTo('1')); Assert.That(conn.Execute<char?>("SELECT @p", DataParameter.Create ("p", '1')), Is.EqualTo('1')); Assert.That(conn.Execute<char> ("SELECT @p", new DataParameter { Name = "p", Value = '1' }), Is.EqualTo('1')); Assert.That(conn.Execute<char?>("SELECT @p", new DataParameter { Name = "p", Value = '1' }), Is.EqualTo('1')); } }
public void Test(string context) { SqlServerTools.ResolveSqlTypes(""); using (var conn = new DataConnection(context)) { var sp = conn.DataProvider.GetSchemaProvider(); var dbSchema = sp.GetSchema(conn); dbSchema.Tables.ToDictionary( t => t.IsDefaultSchema ? t.TableName : t.SchemaName + "." + t.TableName, t => t.Columns.ToDictionary(c => c.ColumnName)); var table = dbSchema.Tables.SingleOrDefault(t => t.TableName.ToLower() == "parent"); Assert.That(table, Is.Not.Null); Assert.That(table.Columns.Count, Is.EqualTo(2)); // Assert.That(dbSchema.Tables.Single(t => t.TableName.ToLower() == "doctor").ForeignKeys.Count, Is.EqualTo(1)); switch (context) { case ProviderName.SqlServer2000 : case ProviderName.SqlServer2005 : case ProviderName.SqlServer2008 : case ProviderName.SqlServer2012 : var indexTable = dbSchema.Tables.Single(t => t.TableName == "IndexTable"); Assert.That(indexTable.ForeignKeys.Count, Is.EqualTo(1)); Assert.That(indexTable.ForeignKeys[0].ThisColumns.Count, Is.EqualTo(2)); break; } } }
public void TestDataTypes(string context) { using (var conn = new DataConnection(context)) { Assert.That(TestType<long?> (conn, "bigintDataType", DataType.Int64), Is.EqualTo(1000000L)); Assert.That(TestType<long?> (conn, "int8DataType", DataType.Int64), Is.EqualTo(1000001L)); Assert.That(TestType<int?> (conn, "intDataType", DataType.Int32), Is.EqualTo(7777777)); Assert.That(TestType<short?> (conn, "smallintDataType", DataType.Int16), Is.EqualTo(100)); Assert.That(TestType<decimal?> (conn, "decimalDataType", DataType.Decimal), Is.EqualTo(9999999m)); Assert.That(TestType<IfxDecimal?> (conn, "decimalDataType", DataType.Decimal), Is.EqualTo(new IfxDecimal(9999999m))); Assert.That(TestType<decimal?> (conn, "moneyDataType", DataType.Money), Is.EqualTo(8888888m)); Assert.That(TestType<float?> (conn, "realDataType", DataType.Single), Is.EqualTo(20.31f)); Assert.That(TestType<double?> (conn, "floatDataType", DataType.Double), Is.EqualTo(16.2d)); Assert.That(TestType<bool?> (conn, "boolDataType", DataType.Boolean), Is.EqualTo(true)); Assert.That(TestType<string> (conn, "charDataType", DataType.Char), Is.EqualTo("1")); Assert.That(TestType<string> (conn, "varcharDataType", DataType.VarChar), Is.EqualTo("234")); Assert.That(TestType<string> (conn, "ncharDataType", DataType.NChar), Is.EqualTo("55645")); Assert.That(TestType<string> (conn, "nvarcharDataType", DataType.NVarChar), Is.EqualTo("6687")); Assert.That(TestType<string> (conn, "lvarcharDataType", DataType.NVarChar), Is.EqualTo("AAAAA")); Assert.That(TestType<DateTime?> (conn, "dateDataType", DataType.Date), Is.EqualTo(new DateTime(2012, 12, 12))); Assert.That(TestType<DateTime?> (conn, "datetimeDataType", DataType.DateTime2), Is.EqualTo(new DateTime(2012, 12, 12, 12, 12, 12))); Assert.That(TestType<IfxDateTime?>(conn, "datetimeDataType", DataType.DateTime), Is.EqualTo(new IfxDateTime(new DateTime(2012, 12, 12, 12, 12, 12)))); Assert.That(TestType<TimeSpan?> (conn, "intervalDataType", DataType.Time), Is.EqualTo(new TimeSpan(12, 12, 12))); Assert.That(TestType<IfxTimeSpan?>(conn, "intervalDataType", DataType.Time), Is.EqualTo(new IfxTimeSpan(new TimeSpan(12, 12, 12)))); Assert.That(TestType<string> (conn, "textDataType", DataType.Text, skipPass:true), Is.EqualTo("BBBBB")); Assert.That(TestType<string> (conn, "textDataType", DataType.NText, skipPass:true), Is.EqualTo("BBBBB")); Assert.That(TestType<byte[]> (conn, "byteDataType", DataType.Binary, skipPass:true), Is.EqualTo(new byte[] { 1, 2 })); Assert.That(TestType<byte[]> (conn, "byteDataType", DataType.VarBinary, skipPass:true), Is.EqualTo(new byte[] { 1, 2 })); } }
public void Test3([IncludeDataContexts( ProviderName.SqlServer, ProviderName.SqlServer2008, ProviderName.SqlServer2008 + ".1", ProviderName.SqlServer2005, ProviderName.SqlServer2005 + ".1", ProviderName.Access )] string context) { using (var conn = new DataConnection(context)) { Assert.That(conn.Connection.State, Is.EqualTo(ConnectionState.Open)); Assert.That(conn.ConfigurationString, Is.EqualTo(context)); if (context.EndsWith(".2005")) { var sdp = conn.DataProvider; Assert.That(sdp.Name, Is.EqualTo("SqlServer.2005")); } if (context.EndsWith(".2008")) { var sdp = conn.DataProvider; Assert.That(sdp.Name, Is.EqualTo("SqlServer.2008")); } } }
protected override void TearDown() { using (var dbManager = new DataConnection("PerformanceTest")) dbManager .SetCommand("TRUNCATE TABLE Simplests") .Execute(); }
public void Test1([IncludeDataContexts("Northwind")] string context) { using (var conn = new DataConnection(SqlServerFactory.GetDataProvider(), "Server=.;Database=Northwind;Integrated Security=SSPI")) { conn.SetCommand("SELECT 1"); var rd = conn.Command.ExecuteReader(); if (rd.Read()) { var dp = conn.DataProvider; var p = Expression.Parameter(typeof(IDataReader)); var dr = Expression.Convert(p, dp.DataReaderType); var ex = (Expression<Func<IDataReader,int,int>>)dp.GetReaderExpression(conn.MappingSchema, rd, 0, dr, typeof(int)); var func = ex.Compile(); do { var value = func(rd, 0); Assert.AreEqual(1, value); } while (rd.Read()); } else { Assert.Fail(); } } }
public void NorthwindTest([IncludeDataContexts("Northwind")] string context) { using (var conn = new DataConnection(context)) { var sp = conn.DataProvider.GetSchemaProvider(); var dbSchema = sp.GetSchema(conn); } }
public void Test2() { using (var conn = new DataConnection()) { Assert.That(conn.Connection.State, Is.EqualTo(ConnectionState.Open)); Assert.That(conn.ConfigurationString, Is.EqualTo(DataConnection.DefaultConfiguration)); } }
public void Test1([IncludeDataContexts("Northwind")] string context) { using (var conn = new DataConnection(SqlServerFactory.GetDataProvider(), "Server=.;Database=Northwind;Integrated Security=SSPI")) { Assert.That(conn.Connection.State, Is.EqualTo(ConnectionState.Open)); Assert.That(conn.ConfigurationString, Is.Null); } }
public ReplaceDataObjectsInBulkActorFactory( IReadOnlyCollection<Type> dataObjectTypes, DataConnection sourceDataConnection, DataConnection targetDataConnection) { _dataObjectTypes = dataObjectTypes; _sourceDataConnection = sourceDataConnection; _targetDataConnection = targetDataConnection; }
public void TestScalar3(string context) { using (var conn = new DataConnection(context)) { var list = conn.Query<DateTimeOffset>("SELECT CURRENT_TIMESTAMP").ToList(); Assert.That(list.Count, Is.EqualTo(1)); } }
public void TestScalar2([IncludeDataContexts(ProviderName.SqlServer)] string context) { using (var conn = new DataConnection(context)) { var list = conn.Query<int>("SELECT 1").ToList(); Assert.That(new[] { 1 }, Is.EquivalentTo(list)); } }
public void TestObject1(string context) { using (var conn = new DataConnection(context)) { var list = conn.Query<QueryObject>("SELECT 1 as Column1, CURRENT_TIMESTAMP as Column2").ToList(); Assert.That(list.Count, Is.EqualTo(1)); } }
static void Main(string[] args) { SqlServerTypes.Utilities.LoadNativeAssemblies(AppDomain.CurrentDomain.BaseDirectory); using (var db = new DataConnection()) { var list = db.GetTable<AllTypes2>().ToList(); } }
public void TestScalar2(string context) { using (var conn = new DataConnection(context)) { var list = conn.Query<int>("SELECT 1").ToList(); Assert.That(new[] { 1 }, Is.EquivalentTo(list)); } }
public IWritingStrategy Create(DataConnection dataConnection, int changesAmount) { if (dataConnection.DataProvider.Name == ProviderName.SqlServer2012 || dataConnection.DataProvider.Name == ProviderName.SqlServer2014) { return changesAmount < ThresholdValue ? (IWritingStrategy)new IterativeWritingStrategy(dataConnection) : new BulkWritingStrategy(dataConnection); } return new IterativeWritingStrategy(dataConnection); }
public DatabaseUpgrader(DataConnection conn) { connection = conn; upgrades = new Dictionary<string, Func<string>> { ["1.1"] = UpgradeFrom1_1, ["1.2"] = UpgradeFrom1_2 }; }
public void Test1(string context) { var connectionString = ConfigurationManager.ConnectionStrings["Northwind"].ConnectionString; using (var conn = new DataConnection(SqlServerTools.GetDataProvider(), connectionString)) { Assert.That(conn.Connection.State, Is.EqualTo(ConnectionState.Open)); Assert.That(conn.ConfigurationString, Is.Null); } }
public void Test([IncludeDataContexts(ProviderName.SqlServer2008)] string context) { using (var db = new DataConnection(context)) { var p1 = PersonSelectByKey(db, 1).First(); var p2 = db.Query<Person>("SELECT * FROM Person WHERE PersonID = @id", new { id = 1 }).First(); Assert.AreEqual(p1, p2); } }
// [Fact] public void Test() { if (TestBase.UserProviders.ContainsKey("SqlServer.2012")) { using (var db = new DataConnection("SqlServer.2012")) { var count = db.GetTable<Parent>().Count(); } } }
public void Test(string context) { using (var db = new DataConnection(context)) { var p1 = PersonSelectByKey(db, 1).First(); var p2 = db.Query<Person>("SELECT * FROM Person WHERE PersonID = @id", new { id = 1 }).First(); Assert.AreEqual(p1, p2); } }
public void Test() { //var conn = new System.Data.SQLite.SQLiteConnection(); //var conn = new IBM.Data.Informix.IfxConnection(); using (var db = new DataConnection("SqlServer.2012")) { var count = db.GetTable<Parent>().Count(); } }
public void TestDataTypes(string context) { using (var conn = new DataConnection(context)) { Assert.That(TestType<long?> (conn, "bigintDataType", DataType.Int64), Is.EqualTo(123456789123456789)); Assert.That(TestType<short?> (conn, "smallintDataType", DataType.Int16), Is.EqualTo(12345)); Assert.That(TestType<decimal?>(conn, "decimalDataType", DataType.Decimal), Is.EqualTo(1234.567m)); Assert.That(TestType<decimal?>(conn, "smalldecimalDataType", DataType.Decimal), Is.EqualTo(123.456m)); Assert.That(TestType<int?> (conn, "intDataType", DataType.Int32), Is.EqualTo(123456789)); Assert.That(TestType<byte?> (conn, "tinyintDataType", DataType.Byte), Is.EqualTo(123)); Assert.That(TestType<double?> (conn, "floatDataType", DataType.Double), Is.EqualTo(1234.567)); //Assert.That(TestType<float?>(conn, "realDataType", DataType.Single), Is.EqualTo(1234.567f)); Assert.That(TestType<DateTime?>(conn, "dateDataType", DataType.Date), Is.EqualTo(new DateTime(2012, 12, 12))); Assert.That(TestType<TimeSpan?>(conn, "timeDataType", DataType.Time), Is.EqualTo(new TimeSpan(12, 12, 12))); Assert.That(TestType<DateTime?>(conn, "seconddateDataType", DataType.DateTime), Is.EqualTo(new DateTime(2012, 12, 12, 12, 12, 12))); Assert.That(TestType<DateTime?>(conn, "timestampDataType", DataType.Timestamp), Is.EqualTo(new DateTime(2012, 12, 12, 12, 12, 12, 123))); Assert.That(TestType<char?>(conn, "charDataType", DataType.Char), Is.EqualTo('a')); Assert.That(TestType<string>(conn, "charDataType", DataType.Char), Is.EqualTo("a")); Assert.That(TestType<string>(conn, "charDataType", DataType.NChar), Is.EqualTo("a")); Assert.That(TestType<string>(conn, "varcharDataType", DataType.VarChar), Is.EqualTo("bcd")); Assert.That(TestType<string>(conn, "varcharDataType", DataType.NVarChar), Is.EqualTo("bcd")); Assert.That(TestType<string>(conn, "shorttextDataType", DataType.Text), Is.EqualTo("def")); Assert.That(TestType<char?>(conn, "ncharDataType", DataType.NChar), Is.EqualTo('ą')); Assert.That(TestType<string>(conn, "nvarcharDataType", DataType.NVarChar), Is.EqualTo("ąčęėįš")); Assert.That(TestType<string>(conn, "alphanumDataType", DataType.Text), Is.EqualTo("qwert123QWE")); Assert.That(TestType<byte[]>(conn, "binaryDataType", DataType.Binary), Is.EqualTo(new byte[] { 97, 98, 99, 100, 101, 102, 103, 104 })); Assert.That(TestType<byte[]>(conn, "binaryDataType", DataType.VarBinary), Is.EqualTo(new byte[] { 97, 98, 99, 100, 101, 102, 103, 104 })); Assert.That(TestType<byte[]>(conn, "varbinaryDataType", DataType.Binary), Is.EqualTo(new byte[] { 97, 98, 99, 100, 101, 102, 103, 104 })); Assert.That(TestType<byte[]>(conn, "varbinaryDataType", DataType.VarBinary), Is.EqualTo(new byte[] { 97, 98, 99, 100, 101, 102, 103, 104 })); Assert.That(TestType<Binary>(conn, "varbinaryDataType", DataType.VarBinary).ToArray(), Is.EqualTo(new byte[] { 97, 98, 99, 100, 101, 102, 103, 104 })); //field types, than cannot be included in where clause //Assert.That(TestType<string>(conn, "textDataType", DataType.Text), Is.EqualTo("abcdefgh")); //Assert.That(TestType<byte[]>(conn, "blobDataType", DataType.Binary), Is.EqualTo(new byte[] { 97, 98, 99, 100, 101, 102, 103, 104 })); //Assert.That(TestType<byte[]>(conn, "blobDataType", DataType.VarBinary), Is.EqualTo(new byte[] { 97, 98, 99, 100, 101, 102, 103, 104 })); //Assert.That(TestType<byte[]>(conn, "blobDataType", DataType.Blob), Is.EqualTo(new byte[] { 97, 98, 99, 100, 101, 102, 103, 104 })); //Assert.That(TestType<string>(conn, "clobDataType", DataType.Text), Is.EqualTo("qwertyuiop")); //Assert.That(TestType<string>(conn, "clobDataType", DataType.NText), Is.EqualTo("qwertyuiop")); //Assert.That(TestType<string>(conn, "clobDataType", DataType.VarChar), Is.EqualTo("qwertyuiop")); //Assert.That(TestType<string>(conn, "clobDataType", DataType.NVarChar), Is.EqualTo("qwertyuiop")); //Assert.That(TestType<string>(conn, "nclobDataType", DataType.Text), Is.EqualTo("ąčęėįšqwerty123456")); //Assert.That(TestType<string>(conn, "nclobDataType", DataType.NText), Is.EqualTo("ąčęėįšqwerty123456")); //Assert.That(TestType<string>(conn, "nclobDataType", DataType.VarChar), Is.EqualTo("ąčęėįšqwerty123456")); //Assert.That(TestType<string>(conn, "nclobDataType", DataType.NVarChar), Is.EqualTo("ąčęėįšqwerty123456")); } }
public void Test1(string context) { var connectionString = DataConnection.GetConnectionString(context); var dataProvider = DataConnection.GetDataProvider(context); using (var conn = new DataConnection(dataProvider, connectionString)) { Assert.That(conn.Connection.State, Is.EqualTo(ConnectionState.Open)); Assert.That(conn.ConfigurationString, Is.Null); } }
public void CloneTest(string context) { using (var con = new DataConnection(context)) { var dbName = con.Connection.Database; for (var i = 0; i < 150; i++) using (var clone = (DataConnection)con.Clone()) dbName = clone.Connection.Database; } }
public void TestParameters(string context) { using (var conn = new DataConnection(context)) { Assert.That(conn.Execute<string>("SELECT @p", new { p = 1 }), Is.EqualTo("1")); Assert.That(conn.Execute<string>("SELECT @p", new { p = "1" }), Is.EqualTo("1")); Assert.That(conn.Execute<int> ("SELECT @p", new { p = new DataParameter { Value = 1 } }), Is.EqualTo(1)); Assert.That(conn.Execute<string>("SELECT @p1", new { p1 = new DataParameter { Value = "1" } }), Is.EqualTo("1")); Assert.That(conn.Execute<int> ("SELECT @p1 + ?p2", new { p1 = 2, p2 = 3 }), Is.EqualTo(5)); Assert.That(conn.Execute<int> ("SELECT @p2 + ?p1", new { p2 = 2, p1 = 3 }), Is.EqualTo(5)); } }
public void MySqlPKTest(string context) { using (var conn = new DataConnection(context)) { var sp = conn.DataProvider.GetSchemaProvider(); var dbSchema = sp.GetSchema(conn); var table = dbSchema.Tables.Single(t => t.TableName == "person"); var pk = table.Columns.FirstOrDefault(t => t.IsPrimaryKey); Assert.That(pk, Is.Not.Null); } }
static Func <IDataReader, T> CreateObjectReader <T>( DataConnection dataConnection, IDataReader dataReader, Func <Type, int, Expression, Expression> getMemberExpression) { var parameter = Expression.Parameter(typeof(IDataReader)); var dataReaderExpr = Expression.Convert(parameter, dataReader.GetType()); Expression expr; if (dataConnection.MappingSchema.IsScalarType(typeof(T))) { expr = getMemberExpression(typeof(T), 0, dataReaderExpr); } else { var td = dataConnection.MappingSchema.GetEntityDescriptor(typeof(T)); var names = new List <string>(dataReader.FieldCount); for (var i = 0; i < dataReader.FieldCount; i++) { names.Add(dataReader.GetName(i)); } expr = null; var ctors = typeof(T).GetConstructors().Select(c => new { c, ps = c.GetParameters() }).ToList(); if (ctors.Count > 0 && ctors.All(c => c.ps.Length > 0)) { var q = from c in ctors let count = c.ps.Count(p => names.Contains(p.Name)) orderby count descending select c; var ctor = q.FirstOrDefault(); if (ctor != null) { expr = Expression.New( ctor.c, ctor.ps.Select(p => names.Contains(p.Name) ? getMemberExpression(p.ParameterType, names.IndexOf(p.Name), dataReaderExpr) : Expression.Constant(dataConnection.MappingSchema.GetDefaultValue(p.ParameterType), p.ParameterType))); } } if (expr == null) { var members = ( from n in names.Select((name, idx) => new { name, idx }) let member = td.Columns.FirstOrDefault(m => string.Compare(m.ColumnName, n.name, dataConnection.MappingSchema.ColumnComparisonOption) == 0) where member != null select new { Member = member, Expr = getMemberExpression(member.MemberType, n.idx, dataReaderExpr), } ).ToList(); expr = Expression.MemberInit( Expression.New(typeof(T)), members.Select(m => Expression.Bind(m.Member.MemberInfo, m.Expr))); } } if (expr.GetCount(e => e == dataReaderExpr) > 1) { var dataReaderVar = Expression.Variable(dataReaderExpr.Type, "dr"); var assignment = Expression.Assign(dataReaderVar, dataReaderExpr); expr = expr.Transform(e => e == dataReaderExpr ? dataReaderVar : e); expr = Expression.Block(new[] { dataReaderVar }, new[] { assignment, expr }); } var lex = Expression.Lambda <Func <IDataReader, T> >(expr, parameter); return(lex.Compile()); }
public QueryRunner(Query query, int queryNumber, DataConnection dataConnection, Expression expression, object[] parameters) : base(query, queryNumber, dataConnection, expression, parameters) { _dataConnection = dataConnection; }
public static IEnumerable <T> Query <T>(this DataConnection connection, Func <IDataReader, T> objectReader, string sql, object parameters) { return(new CommandInfo(connection, sql, parameters).Query(objectReader)); }
public static T Execute <T>(this DataConnection connection, string sql) { return(new CommandInfo(connection, sql).Execute <T>()); }
public static int Merge <T>(this DataConnection dataConnection, IEnumerable <T> source, string tableName = null, string databaseName = null, string schemaName = null) where T : class { return(dataConnection.DataProvider.Merge(dataConnection, null, false, source, tableName, databaseName, schemaName)); }
/// <summary> /// Creates database command instance using provided database connection and command text. /// </summary> /// <param name="dataConnection">Database connection instance.</param> /// <param name="commandText">Command text.</param> public CommandInfo(DataConnection dataConnection, string commandText) { DataConnection = dataConnection; CommandText = commandText; }
public QueryRunner(Query query, int queryNumber, DataConnection dataConnection, Expression expression, object?[]?parameters, object?[]?preambles) : base(query, queryNumber, dataConnection, expression, parameters, preambles) { _dataConnection = dataConnection; _executionScope = _dataConnection.DataProvider.ExecuteScope(_dataConnection); }
public static IEnumerable <T> Query <T>(this DataConnection connection, T template, string sql, object parameters) { return(new CommandInfo(connection, sql, parameters).Query(template)); }
/// <summary> /// Creates database command instance using provided database connection, command text and single parameter. /// </summary> /// <param name="dataConnection">Database connection instance.</param> /// <param name="commandText">Command text.</param> /// <param name="parameter">Command parameter.</param> public CommandInfo(DataConnection dataConnection, string commandText, DataParameter parameter) { DataConnection = dataConnection; CommandText = commandText; Parameters = new[] { parameter }; }
/// <summary> /// Creates database command instance using provided database connection, command text and parameters. /// </summary> /// <param name="dataConnection">Database connection instance.</param> /// <param name="commandText">Command text.</param> /// <param name="parameters">List of command parameters.</param> public CommandInfo(DataConnection dataConnection, string commandText, params DataParameter[] parameters) { DataConnection = dataConnection; CommandText = commandText; Parameters = parameters; }
static DataParameter[] GetDataParameters(DataConnection dataConnection, object parameters) { if (parameters == null) { return(null); } if (parameters is DataParameter[]) { return((DataParameter[])parameters); } if (parameters is DataParameter) { return new[] { (DataParameter)parameters } } ; Func <object, DataParameter[]> func; var type = parameters.GetType(); var key = new ParamKey(type, dataConnection.ID); if (!_parameterReaders.TryGetValue(key, out func)) { var td = dataConnection.MappingSchema.GetEntityDescriptor(type); var p = Expression.Parameter(typeof(object), "p"); var obj = Expression.Parameter(parameters.GetType(), "obj"); var expr = Expression.Lambda <Func <object, DataParameter[]> >( Expression.Block( new[] { obj }, new Expression[] { Expression.Assign(obj, Expression.Convert(p, type)), Expression.NewArrayInit( typeof(DataParameter), td.Columns.Select(m => { if (m.MemberType == typeof(DataParameter)) { var pobj = Expression.Parameter(typeof(DataParameter)); return(Expression.Block( new[] { pobj }, new Expression[] { Expression.Assign(pobj, Expression.PropertyOrField(obj, m.MemberName)), Expression.MemberInit( Expression.New(typeof(DataParameter)), Expression.Bind( _dataParameterName, Expression.Coalesce( Expression.MakeMemberAccess(pobj, _dataParameterName), Expression.Constant(m.ColumnName))), Expression.Bind( _dataParameterDataType, Expression.MakeMemberAccess(pobj, _dataParameterDataType)), Expression.Bind( _dataParameterValue, Expression.Convert( Expression.MakeMemberAccess(pobj, _dataParameterValue), typeof(object)))) })); } var memberType = m.MemberType.ToNullableUnderlying(); var valueGetter = Expression.PropertyOrField(obj, m.MemberName) as Expression; var mapper = dataConnection.MappingSchema.GetConvertExpression(memberType, typeof(DataParameter), createDefault: false); if (mapper != null) { return(Expression.Call( MemberHelper.MethodOf(() => PrepareDataParameter(null, null)), mapper.GetBody(valueGetter), Expression.Constant(m.ColumnName))); } if (memberType.IsEnumEx()) { var mapType = ConvertBuilder.GetDefaultMappingFromEnumType(dataConnection.MappingSchema, memberType); var convExpr = dataConnection.MappingSchema.GetConvertExpression(m.MemberType, mapType); memberType = mapType; valueGetter = convExpr.GetBody(valueGetter); } return((Expression)Expression.MemberInit( Expression.New(typeof(DataParameter)), Expression.Bind( _dataParameterName, Expression.Constant(m.ColumnName)), Expression.Bind( _dataParameterDataType, Expression.Constant(dataConnection.MappingSchema.GetDataType(memberType).DataType)), Expression.Bind( _dataParameterValue, Expression.Convert(valueGetter, typeof(object))))); })) } ), p); _parameterReaders[key] = func = expr.Compile(); } return(func(parameters)); }
public static CommandInfo SetCommand(DataConnection dataConnection, string commandText, object parameters) { return(new CommandInfo(dataConnection, commandText, parameters)); }
public static CommandInfo SetCommand(this DataConnection dataConnection, string commandText) { return(new CommandInfo(dataConnection, commandText)); }
public static DataReader ExecuteReader(this DataConnection connection, string sql, object parameters) { return(new CommandInfo(connection, sql, parameters).ExecuteReader()); }
public DataReaderAsync(DataConnection dataConnection, Func <int> skipAction, Func <int> takeAction) { _dataConnection = dataConnection; _skipAction = skipAction; _takeAction = takeAction; }
public static DataReader ExecuteReader(this DataConnection connection, string sql) { return(new CommandInfo(connection, sql).ExecuteReader()); }
public static T Execute <T>(this DataConnection connection, string sql, DataParameter parameter) { return(new CommandInfo(connection, sql, parameter).Execute <T>()); }
public static T ExecuteProc <T>(this DataConnection connection, string sql, params DataParameter[] parameters) { return(new CommandInfo(connection, sql, parameters).ExecuteProc <T>()); }
public static IEnumerable <T> Query <T>(this DataConnection connection, string sql, DataParameter parameter) { return(new CommandInfo(connection, sql, parameter).Query <T>()); }
public static int Merge <T>(this DataConnection dataConnection, Expression <Func <T, bool> > predicate, IEnumerable <T> source, string tableName = null, string databaseName = null, string schemaName = null) where T : class { return(dataConnection.DataProvider.Merge(dataConnection, predicate, true, source, tableName, databaseName, schemaName)); }
/// <summary> /// Creates database command instance using provided database connection, command text and parameters. /// </summary> /// <param name="dataConnection">Database connection instance.</param> /// <param name="commandText">Command text.</param> /// <param name="parameters">Command parameters. Supported values: /// <para> - <c>null</c> for command without parameters;</para> /// <para> - single <see cref="DataParameter"/> instance;</para> /// <para> - array of <see cref="DataParameter"/> parameters;</para> /// <para> - mapping class entity.</para> /// <para>Last case will convert all mapped columns to <see cref="DataParameter"/> instances using following logic:</para> /// <para> - if column is of <see cref="DataParameter"/> type, column value will be used. If parameter name (<see cref="DataParameter.Name"/>) is not set, column name will be used;</para> /// <para> - if converter from column type to <see cref="DataParameter"/> is defined in mapping schema, it will be used to create parameter with colum name passed to converter;</para> /// <para> - otherwise column value will be converted to <see cref="DataParameter"/> using column name as parameter name and column value will be converted to parameter value using conversion, defined by mapping schema.</para> /// </param> public CommandInfo(DataConnection dataConnection, string commandText, object parameters) { DataConnection = dataConnection; CommandText = commandText; Parameters = GetDataParameters(dataConnection, parameters); }
/// <summary> /// Creates new transaction controller for data connection. /// </summary> /// <param name="dataConnection">Data connection instance.</param> public DataConnectionTransaction(DataConnection dataConnection) { DataConnection = dataConnection ?? throw new ArgumentNullException(nameof(dataConnection)); }
public void EnumExecuteScalarTest() { using (var dbm = new DataConnection()) { var gender = dbm.Execute<Gender>("select 'M'"); Assert.That(gender, Is.EqualTo(Gender.Male)); } }