ADO.NET distinct data bases - ado.net

Question

What programmers needed was a way to generalize different data systems
in a standard, consistent, and powerful way. In the world of .NET
application development, Microsoft ADO.NET meets that need. Instead of
worrying about the minutiae associated with the different database
systems, programmers using ADO.NET focus on the data content itself.
From the book "ADO.NET 4 Step by Step"
Always thinking the next structure.
ADO.NET can be sepearated on two parts:
1. Classic ADO.NET (DataSets, DataTables, etc.). In classic variant there are distinct DB connection providers, every which translates DB internal data to the .NET. For example MS SQL Server holds data in one way and Oracle in another. So we can change the data base with changing provider.
Seems as magic pill, however all ADO.NET statements are hard coded.
For MS SQL top 10 select statement is SELECT TOP 10 ROWS FROM TABLE, and for Oracle SELECT ROWS FROM TABELE WHERE ROWNUM <= 10. It seems that changing DB and provider will not help, isnt' it?
2. Entity Framework. This framework has internal independent language statements that is transformed to the choosen DB statesment, which looks as truely magic pill:
LINQ -> Internal EF statement -> MS SQL DB,
LINQ -> Internal EF statement -> Oracle DB.
So can one simply change the DB and be almost independent from DB in classic ADO.NET?

Answer 1

So can one simply change the DB and be almost independent from DB in classic ADO.NET?
Of course you can, but to be able to do that we have to debunk this statement.
Seems as magic pill, however all ADO.NET statements are hard coded.
That's not a byproduct of ADO.NET - that's a byproduct of your architecture. You're building the SQL statements in the wrong place. You need concrete, provider specific models, that are capable of building statements that differ between providers. This isn't as bad as it sounds - most statements can be auto-generated leveraging reflection - it's just the special cases.
For example, let's say I had a model like this:
public class Employee
{
public int ID { get; set; }
public string Name { get; set; }
public DateTime DateOfBirth { get; set; }
}
and let's say I wanted to generate a SELECT statement out of that. Well, I'm going to first need a couple attributes to tell me what property is the PK and what properties are data fields:
[AttributeUsage(AttributeTargets.Property, Inherited = false, AllowMultiple = false)]
internal sealed class DataFieldAttribute : Attribute
{
public DataFieldAttribute()
{
}
}
[AttributeUsage(AttributeTargets.Property, Inherited = false, AllowMultiple = false)]
sealed class PrimaryKeyAttribute : Attribute
{
public PrimaryKeyAttribute()
{
}
}
and now I need to decorate that class:
public class Employee
{
[PrimaryKey]
public int ID { get; set; }
[DataField]
public string Name { get; set; }
[DataField]
public DateTime DateOfBirth { get; set; }
}
and now I just need a simple process to create a SELECT statement, so first let's build a base data model class:
public abstract class DataModelBase
{
protected string _primaryKeyField;
protected List<string> _props = new List<string>();
public DataModelBase()
{
PropertyInfo pkProp = this.GetType().GetProperties().Where(p => p.GetCustomAttributes(typeof(PrimaryKeyAttribute), false).Length > 0).FirstOrDefault();
if (pkProp != null)
{
_primaryKeyField = pkProp.Name;
}
foreach (PropertyInfo prop in this.GetType().GetProperties().Where(p => p.GetCustomAttributes(typeof(DataFieldAttribute), false).Length > 0))
{
_props.Add(prop.Name);
}
}
public virtual string TableName { get { return this.GetType().Name; } }
public virtual string InsertStatement
{
get
{
return string.Format("INSERT INTO [{0}] ({1}) VALUES ({2})",
this.TableName,
GetDelimitedSafeFieldList(", "),
GetDelimitedSafeParamList(", "));
}
}
public virtual string UpdateStatement
{
get
{
return string.Format("UPDATE [{0}] SET {1} WHERE [{2}] = #{2}",
this.TableName,
GetDelimitedSafeSetList(", "),
_primaryKeyField);
}
}
public virtual string DeleteStatement
{
get
{
return string.Format("DELETE [{0}] WHERE [{1}] = #{1}",
this.TableName,
_primaryKeyField);
}
}
public virtual string SelectStatement
{
get
{
return string.Format("SELECT [{0}], {1} FROM [{2}]",
_primaryKeyField,
GetDelimitedSafeFieldList(", "),
this.TableName);
}
}
protected string GetDelimitedSafeParamList(string delimiter)
{
return string.Join(delimiter, _props.Select(k => string.Format("#{0}", k)));
}
protected string GetDelimitedSafeFieldList(string delimiter)
{
return string.Join(delimiter, _props.Select(k => string.Format("[{0}]", k)));
}
protected string GetDelimitedSafeSetList(string delimiter)
{
return string.Join(delimiter, _props.Select(k => string.Format("[{0}] = #{0}", k)));
}
}
and now let's inherit from that data model:
public class Employee : DataModelBase
and boom, now I can get those statements any time I need them, and those statements work for any concrete provider right now.
And then I'll use Dapper to get the data because it leverages the IDbConnection interface like what you need and it's ridiculously fast - and there you go - a provider independent solution that would easily be extended to build an Oracle version of Employee if necessary.
This framework has internal independent language statements that is transformed to the choosen DB statesment, which looks as truely magic pill
Sure, it may look like a magic pill, but it's really a curse in a lot of ways. You have no flexibility (at least it's not easy) to build statements that are optimized for your needs to support high transaction and volume databases. You truly are subject to the master here. The .NET Entity Framework builds those statements for you, and I can't even count how many questions on StackOverflow have been over how can I change the SQL that's being generated by this LINQ statement leveraging the .NET Entity Framework.

Answer 2

was staring to play with this. I know this is a old post. thanks to the above example herewith little modified. Still lots to be done
using System.Collections.Generic;
using System.Reflection;
using Dapper;
using System.Linq;
using AppAttributes;
using System.ComponentModel.DataAnnotations;
using System;
public abstract class DataModelBase
{
protected string _primaryKeyField;
protected List<string> _props = new List<string>();
protected List<BuildClass> _class = new List<BuildClass>();
public DataModelBase()
{
PropertyInfo pkProp = this.GetType().GetProperties().Where(p => p.GetCustomAttributes(typeof(KeyAttribute), false).Length > 0).FirstOrDefault();
if (pkProp != null)
{
_primaryKeyField = pkProp.Name;
}
foreach (PropertyInfo prop in this.GetType().GetProperties().Where(p => p.GetCustomAttributes(typeof(DataFieldAttribute), false).Length > 0))
{
_props.Add(prop.Name);
}
foreach(PropertyInfo prop in this.GetType().GetProperties())
{
if(prop.GetCustomAttributes<ExcludeAttribute>().Count<ExcludeAttribute>() > 0) continue;
MaxLengthAttribute maxLength = prop.GetCustomAttribute<MaxLengthAttribute>();
MinLengthAttribute minLength = prop.GetCustomAttribute< MinLengthAttribute>();
StringLengthAttribute stringLength = prop.GetCustomAttribute< StringLengthAttribute>();
RequiredAttribute required = prop.GetCustomAttribute<RequiredAttribute>();
RangeAttribute range = prop.GetCustomAttribute<RangeAttribute>();
DataTypeAttribute dataType = prop.GetCustomAttribute<DataTypeAttribute>();
KeyAttribute key = prop.GetCustomAttribute<KeyAttribute>();
var kyk = prop.PropertyType;
//var sss = kyk.FullName.;
var cl = new BuildClass
{
Name = prop.Name,
MaxLength = maxLength != null
? (int?)maxLength.Length
: stringLength != null
? (int?)stringLength.MaximumLength : null,
MinLength = minLength != null
? (int?)minLength.Length
: stringLength != null
? (int?)stringLength.MinimumLength : null,
PrimaryKey = key != null ? true : false,
Type = prop.PropertyType.Name.ToString()
};
_class.Add(cl);
}
}
[Exclude]
public virtual string TableName { get { return this.GetType().Name; } }
[Exclude]
public virtual string InsertStatement
{
get {
return string.Format("INSERT INTO [{0}] ({1}) VALUES ({2})",
this.TableName,
GetDelimitedSafeFieldList(", "),
GetDelimitedSafeParamList(", "));
}
}
[Exclude]
public virtual string UpdateStatement
{
get {
return string.Format("UPDATE [{0}] SET {1} WHERE [{2}] = #{2}",
this.TableName,
GetDelimitedSafeSetList(", "),
_primaryKeyField);
}
}
[Exclude]
public virtual string DeleteStatement
{
get {
return string.Format("DELETE [{0}] WHERE [{1}] = #{1}",
this.TableName,
_primaryKeyField);
}
}
[Exclude]
public virtual string SelectStatement
{
get {
return string.Format("SELECT [{0}], {1} FROM [{2}]",
_primaryKeyField,
GetDelimitedSafeFieldList(", "),
this.TableName);
}
}
[Exclude]
public virtual string CreateStatement
{
get {
return "CREATE TABLE " + TableName+" (" + GetDelimetedCreateParamList(",")
+ ", CONSTRAINT PK_"
+ _class.Where(c=>c.PrimaryKey).FirstOrDefault().Name
+ " PRIMARY KEY("
+ string.Join(",", _class.Where(c=>c.PrimaryKey).Select(c=>c.Name)) + ") )";
}
}
protected string GetDelimetedCreateParamList(string delimeter)
{
return string.Join(delimeter, _class.Select(k => string.Format(" {0} {1} ({2}) {3}" + Environment.NewLine,
k.Name,
GetSqlType(k.Type),
k.MaxLength,
k.NotNull == true || k.PrimaryKey == true ? "NOT NULL " : ""
//k.PrimaryKey == true ? "PRIMARY KEY" : ""
).Replace("()", ""))
);
}
protected string GetSqlType(string type)
{
switch(type.ToUpper())
{
case "INT16":
return "smallint";
case "INT16?":
return "smallint";
case "INT32":
return "int";
case "INT32?":
return "int";
case "INT64":
return "bigint";
case "INT64?":
return "bigint";
case "STRING":
return "NVARCHAR";
case "XML":
return "Xml";
case "BYTE":
return "binary";
case "BYTE?":
return "binary";
case "BYTE[]":
return "varbinary";
case "GUID":
return "uniqueidentifier";
case "GUID?":
return "uniqueidentifier";
case "TIMESPAN":
return "time";
case "TIMESPAN?":
return "time";
case "DECIMAL":
return "money";
case "DECIMAL?":
return "money";
case "bool":
return "bit";
case "bool?":
return "but";
case "DateTime":
return "datetime";
case "datetime?":
return "datetime";
case "double":
return "float";
case "double?":
return "float";
case "char[]":
return "nchar";
}
return "UNKNOWN";
}
private string CreateField(BuildClass column)
{
return " " + column.Name + " " + column.Type + " (" + column.MaxLength + ") ";
}
protected string GetDelimitedSafeParamList(string delimiter)
{
return string.Join(delimiter, _props.Select(k => string.Format("#{0}", k)));
}
protected string GetDelimitedSafeFieldList(string delimiter)
{
return string.Join(delimiter, _props.Select(k => string.Format("[{0}]", k)));
}
protected string GetDelimitedSafeSetList(string delimiter)
{
return string.Join(delimiter, _props.Select(k => string.Format("[{0}] = #{0}", k)));
}
}
public class BuildClass
{
public string Name { get; set; }
public string Type { get; set; }
public bool PrimaryKey { get; set; }
//public bool ForeignKey { get; set; }
public int? MinLength { get; set; }
public int? MaxLength { get; set; }
public bool NotNull { get; set; } = false;
}