/// <summary>
/// 指定された型情報から、対象となるテーブルのレコードを指定されたプロパティにマッピングされている列に絞って更新するクエリを生成します。
/// </summary>
/// <param name="targetDatabase">対象データベース</param>
/// <param name="type">テーブルの型</param>
/// <param name="propertyNames">プロパティ名のコレクション。指定がない場合はすべての列を抽出対象とします。</param>
/// <param name="setIdentity">自動採番のID列に値を設定するかどうか</param>
/// <returns>生成されたSQL</returns>
public static string CreateUpdate(DbKind targetDatabase, Type type, IEnumerable <string> propertyNames = null, bool setIdentity = false)
{
if (type == null)
{
throw new ArgumentNullException(nameof(type));
}
if (propertyNames == null)
{
propertyNames = Enumerable.Empty <string>();
}
var prefix = targetDatabase.GetBindParameterPrefix();
var table = TableMappingInfo.Create(type);
var columns = table.Columns.Where(x => setIdentity ? true : !x.IsAutoIncrement);
if (propertyNames.Any())
{
columns = columns.Join(propertyNames, x => x.PropertyName, y => y, (x, y) => x);
}
var setters = columns.Select(x => $" {x.ColumnName} = {prefix}{x.PropertyName}");
var builder = new StringBuilder();
builder.AppendLine($"update {table.FullName}");
builder.AppendLine("set");
builder.Append(string.Join($",{Environment.NewLine}", setters));
return(builder.ToString());
}
/// <summary>
/// 指定された型情報から、対象となるテーブルのレコードを指定されたプロパティにマッピングされている列に絞って更新するクエリを生成します。
/// </summary>
/// <typeparam name="T">テーブルの型</typeparam>
/// <param name="targetDatabase">対象データベース</param>
/// <param name="properties">抽出する列にマッピングされるプロパティのコレクション。指定がない場合はすべての列を抽出対象とします。</param>
/// <param name="setIdentity">自動採番のID列に値を設定するかどうか</param>
/// <returns>生成されたSQL</returns>
public static string CreateUpdate <T>(DbKind targetDatabase, Expression <Func <T, object> > properties = null, bool setIdentity = false)
{
var propertyNames = properties == null
? null
: ExpressionHelper.GetMemberNames(properties);
return(This.CreateUpdate(targetDatabase, typeof(T), propertyNames, setIdentity));
}
public static string CreateUpdate <T>(DbKind targetDatabase, bool setIdentity, params Expression <Func <T, object> >[] properties)
{
var propertyNames = properties == null || properties.Length == 0
? null
: ExpressionHelper.GetMemberNames(properties);
return(This.CreateUpdate(targetDatabase, typeof(T), propertyNames, setIdentity));
}
public static IEnumerable <Cliente> ObtenerRegistros(DbKind dbKind)
{
var db = Utilidades.ObtenerConexionPorTipo(dbKind);
ClienteRepository clienteRepository = new ClienteRepository(db);
var dbResult = clienteRepository.ObtenerTodos();
return(dbResult);
}
public DbContextContainer(DbKind dbKind, DbName dbName)
{
var builder = new ContainerBuilder();
builder.Register(o => BuildInstance(dbKind, dbName));
_DataAccess = builder.Build().Resolve <DbContextEx>();
_DataAccess.OpenConnection();
_DataAccess._DbKind = dbKind;
}
/// <summary>
/// バインド変数の接頭辞を取得します。
/// </summary>
/// <param name="kind">データベースの種類</param>
/// <returns>バインド変数の接頭辞</returns>
public static char GetBindParameterPrefix(this DbKind kind)
{
var prefix = This.cache[kind].BindParameterPrefix;
if (!prefix.HasValue)
{
throw new NotSupportedException();
}
return(prefix.Value);
}
/// <summary>
/// データベースの種類ごとに初期化する。
/// </summary>
/// <param name="kind">データベース種類</param>
private void PrepareDbKind(DbKind kind)
{
switch (DbKind)
{
case DbKind.SQLServer:
{
this.Connection = new SQLServer.DbConnection();
break;
}
}
}
/// <summary>
/// 指定されたデータベースに対する接続管理機能を生成します。
/// </summary>
/// <param name="dbKind">データーベースの種類</param>
/// <param name="connectionString">接続文字列</param>
/// <returns>データーベース接続</returns>
public static IDbConnection CreateConnection(this DbKind dbKind, string connectionString)
{
if (connectionString == null)
{
throw new ArgumentNullException(nameof(connectionString));
}
var connection = dbKind.CreateConnection();
connection.ConnectionString = connectionString;
return(connection);
}
/// <summary>
/// データベースの種類ごとに初期化する。
/// </summary>
/// <param name="kind">データベース種類</param>
private void PrepareDbKind(DbKind kind)
{
switch (DbKind)
{
case DbKind.SQLServer:
{
this.AccessBase = new SQLServer.DbAccessBase();
this.Transaction = this.AccessBase;
this.Connection = this.AccessBase;
break;
}
}
}
public static void ExportarRegistros(DbKind dbKind)
{
try
{
StreamWriter sw = new StreamWriter(@"C:\Users\DESARROLLADOR 9\Documents\DatabaseClientes.txt");
var dbResult = ObtenerRegistros(dbKind);
dbResult.ToList().ForEach(sw.WriteLine);
sw.Close();
Console.WriteLine("Los registro se han exportado al archivo DatabaseClientes.txt");
}
catch (Exception e)
{
Console.WriteLine("Exception: " + e.Message);
}
}
public DbContextEx BuildInstance(DbKind dbKind, DbName dbName)
{
if ("IsDesDataLink".ConfigValue("NO") == "YES")
{
if (dbKind == DbKind.MySql)
{
return(new DbContextEx(new MySqlConnection(Init(dbName)), true));
}
if (dbKind == DbKind.Oracle)
{
return(new DbContextEx(new EntityConnection(Init(dbName)), true));
}
if (dbKind == DbKind.SqlServer)
{
return(new DbContextEx(new SqlConnection(Init(dbName)), true));
}
}
return(new DbContextEx(dbName.ToString()));
}
//Static hace que un elemento no sea instanciable(New).
//Se puede acceder al metodo mediante la clase (Utilidades.ObtenerConexion();).
public static DataBase ObtenerConexionPorTipo(DbKind dbKind)
{
DataBase dataBase;
switch (dbKind)
{
case DbKind.SqlServer:
dataBase = new SqlServerDataBase
{
DatabaseName = "BASE DE DATOS",
Host = "AZDESAR9\\SQLEXPRESS",
User = "******",
Password = "******"
};
dataBase.CrearConexion();
break;
case DbKind.PostgreSql:
dataBase = new PostgreSqlDataBase
{
DatabaseName = "dvdrental",
Host = "127.0.0.1",
User = "******",
Password = "******"
};
dataBase.CrearConexion();
break;
default:
dataBase = new SqlServerDataBase
{
DatabaseName = "BASE DE DATOS",
Host = "AZDESAR9\\SQLEXPRESS",
User = "******",
Password = "******"
};
dataBase.CrearConexion();
break;
}
return(dataBase);
}
/// <summary>
/// 指定された型情報から対象となるテーブルにレコードを挿入するクエリを生成します。
/// </summary>
/// <param name="targetDatabase">対象データベース</param>
/// <param name="type">テーブルの型</param>
/// <param name="useSequence">シーケンスを利用するかどうか</param>
/// <param name="setIdentity">自動採番のID列に値を設定するかどうか</param>
/// <returns>生成されたSQL</returns>
public static string CreateInsert(DbKind targetDatabase, Type type, bool useSequence = true, bool setIdentity = false)
{
if (type == null)
{
throw new ArgumentNullException(nameof(type));
}
var prefix = targetDatabase.GetBindParameterPrefix();
var table = TableMappingInfo.Create(type);
var columns = table.Columns.Where(x => setIdentity ? true : !x.IsAutoIncrement);
var values = columns.Select(x =>
{
if (useSequence)
{
if (x.Sequence != null)
{
switch (targetDatabase)
{
case DbKind.SqlServer: return($"next value for {x.Sequence.FullName}");
case DbKind.Oracle: return($"{x.Sequence.FullName}.nextval");
case DbKind.PostgreSql: return($"nextval('{x.Sequence.FullName}')");
}
}
}
return($"{prefix}{x.PropertyName}");
})
.Select(x => " " + x);
var columnNames = columns.Select(x => " " + x.ColumnName);
var builder = new StringBuilder();
builder.AppendLine($"insert into {table.FullName}");
builder.AppendLine("(");
builder.AppendLine(string.Join($",{Environment.NewLine}", columnNames));
builder.AppendLine(")");
builder.AppendLine("values");
builder.AppendLine("(");
builder.AppendLine(string.Join($",{Environment.NewLine}", values));
builder.Append(")");
return(builder.ToString());
}
public static void EjecutarOpcion(int opcion, DbKind dbKind)
{
switch (opcion)
{
case 1:
InsertarCliente(dbKind);
Console.WriteLine();
CargarMenu();
break;
case 2:
ObtenerRegistros(dbKind).ToList().ForEach(Console.WriteLine);
Console.WriteLine();
CargarMenu();
break;
case 3:
ExportarRegistros(dbKind);
Console.WriteLine();
CargarMenu();
break;
case 4:
SalirConsola();
break;
case 5:
SeleccionarDB();
SeleccionarOpcion();
EjecutarOpcion(opcion, dbKind);
break;
default:
Console.WriteLine("Debe seleccionar una opcion.");
CargarMenu();
break;
}
}
public static string CreateUpdate <T>(DbKind targetDatabase, params Expression <Func <T, object> >[] properties) => This.CreateUpdate <T>(targetDatabase, false, properties);
/// <summary> /// 指定されたデータベースに対する接続管理機能を生成します。 /// </summary> /// <param name="dbKind">データーベースの種類</param> /// <returns>データーベース接続</returns> public static IDbConnection CreateConnection(this DbKind dbKind) => This.GetFactory(dbKind).CreateConnection();
/// <summary>
/// 指定されたデータベースの種類に応じたデータベース機能を提供します。
/// </summary>
/// <param name="dbKind">データベースの種類</param>
/// <returns>データベース機能</returns>
public static DbProviderFactory GetFactory(DbKind dbKind)
{
var name = dbKind.GetProviderName();
return(DbProviderFactories.GetFactory(name));
}
/// <summary>
/// コンストラクタ
/// </summary>
/// <param name="kind">データベースの種類</param>
public DbTransaction(DbKind kind)
{
this.PrepareDbKind(kind);
}
public AiplugsDbContext(DbContextOptions options, DbKind kind = DbKind.Sqlite) : base(options)
{
DbKind = kind;
}
/// <summary> /// DbConnection属性からDbConnectionの型名を取得します。 /// </summary> /// <param name="kind">データベースの種類</param> /// <returns>DbConnectionの型名</returns> public static string GetDbConnectionTypeName(this DbKind kind) => This.cache[kind].DbConnectionTypeName;
/// <summary>
/// コンストラクタ
/// </summary>
/// <param name="kind">DB種類</param>
public DbConnection(DbKind kind)
{
this.PrepareDbKind(kind);
}
/// <summary> /// ProviderInvariantName属性からデータソースのデータプロバイダー名を取得します。 /// </summary> /// <param name="kind">データベースの種類</param> /// <returns>データプロバイダー名</returns> public static string GetProviderName(this DbKind kind) => This.cache[kind].ProviderName;
public static string CreateUpdate(DbKind targetDatabase, Type type, bool setIdentity, params string[] propertyNames) => This.CreateUpdate(targetDatabase, type, propertyNames, setIdentity);
/// <summary> /// 指定された型情報から対象となるテーブルにレコードを挿入するクエリを生成します。 /// </summary> /// <typeparam name="T">テーブルの型</typeparam> /// <param name="targetDatabase">対象データベース</param> /// <param name="useSequence">シーケンスを利用するかどうか</param> /// <param name="setIdentity">自動採番のID列に値を設定するかどうか</param> /// <returns>生成されたSQL</returns> public static string CreateInsert <T>(DbKind targetDatabase, bool useSequence = true, bool setIdentity = false) => This.CreateInsert(targetDatabase, typeof(T), useSequence, setIdentity);
public static string CreateUpdate(DbKind targetDatabase, Type type, params string[] propertyNames) => This.CreateUpdate(targetDatabase, type, propertyNames, false);
public static void InsertarCliente(DbKind dbKind)
{
while (true)
{
Cliente cliente = new Cliente();
List <string> errors = new List <string>();
Console.Write("Ingrese Nombre: ");
cliente.Nombre = Console.ReadLine();
if (string.IsNullOrEmpty(cliente.Nombre) || string.IsNullOrWhiteSpace(cliente.Nombre))
{
errors.Add("=>El nombre no puede quedar vacio.");
}
if (cliente.Nombre.Length < 5)
{
errors.Add("=>El nombre debe tener al menos 5 caracteres.");
}
bool result = Regex.IsMatch(cliente.Nombre, @"^[a-zA-Z\sa-zA-ZZñÑáéíóúÁÉÍÓÚ]+$");
if (!result)
{
errors.Add("=>El nombre solo debe contener letras del alfabeto.");
}
Console.Write("Ingrese Telefono:");
bool EsTelefono = decimal.TryParse(Console.ReadLine(), out decimal telefono);
if (!EsTelefono)
{
errors.Add("=>El telefono no debe tener caracteres diferentes a los numericos.");
}
cliente.Telefono = telefono;
Console.Write("Ingrese Email: ");
cliente.Email = Console.ReadLine();
if (string.IsNullOrEmpty(cliente.Email) || string.IsNullOrWhiteSpace(cliente.Email))
{
errors.Add("=>El formato de email es incorrecto.");
}
if (!EsEmail(cliente.Email))
{
errors.Add("=>Ingrese un email valido.");
}
Console.Write("Ingrese Fecha de nacimiento (yyyy-mm-dd):");
bool EsFecha = DateTime.TryParse(Console.ReadLine(), out DateTime fechaNacimiento);
if (!EsFecha)
{
errors.Add("=>Ingrese una fecha valida (yyyy-mm-dd).");
}
DateTime max = new DateTime(2015, 12, 31);
if (fechaNacimiento >= max)
{
errors.Add("=>La fecha no debe contener datos superiores al año 2015.");
}
DateTime min = new DateTime(1800, 12, 31);
if (fechaNacimiento <= min)
{
errors.Add("=>La fecha no debe contener datos inferiores al año 1880.");
}
cliente.FechaNacimiento = fechaNacimiento;
if (errors.Count > 0)
{
Console.ForegroundColor = ConsoleColor.Red;
Console.WriteLine("Su regitro no fue exitoso, verifique los datos ingresados:");
Console.ResetColor();
Console.ForegroundColor = ConsoleColor.Blue;
errors.ForEach(Console.WriteLine);
Console.ResetColor();
continue;
}
var db = Utilidades.ObtenerConexionPorTipo(dbKind);
ClienteRepository clienteRepository = new ClienteRepository(db);
clienteRepository.Insertar(cliente);
Console.WriteLine("¡Su nuevo registro se ha guardado en la base de datos!");
break;
}
}
/// <summary>
/// 指定されたデータベースの種類に応じたデータベース機能を提供します。
/// </summary>
/// <param name="dbKind">データベースの種類</param>
/// <returns>データベース機能</returns>
public static DbProviderFactory GetFactory(DbKind dbKind)
{
var name = dbKind.GetProviderName();
return DbProviderFactories.GetFactory(name);
}
/// <summary>
/// 条件を表す式からSQLを生成します
/// </summary>
/// <typeparam name="T">テーブルの型</typeparam>
/// <param name="targetDatabase">対象となるデータベース</param>
/// <param name="predicate">条件式</param>
/// <returns>条件SQL</returns>
public static This From <T>(DbKind targetDatabase, Expression <Func <T, bool> > predicate)
{
//--- 解析実行
var root = PredicateParser.Parse(predicate);
//--- SQL文 / パラメーター生成の定義
uint index = 0;
var columnMap = TableMappingInfo.Create <T>().Columns.ToDictionary(x => x.PropertyName);
var prefix = targetDatabase.GetBindParameterPrefix();
var parameterCount = root.DescendantsAndSelf().Count(x =>
{
return(x.Operator != PredicateOperator.AndAlso &&
x.Operator != PredicateOperator.OrElse &&
x.Value != null);
});
var digit = (parameterCount - 1).ToString().Length;
var digitFormat = $"D{digit}";
IDictionary <string, object> parameter = new ExpandoObject();
Func <PredicateElement, string> sqlBuilder = null;
sqlBuilder = element =>
{
if (element.HasChildren)
{
var left = sqlBuilder(element.Left);
var right = sqlBuilder(element.Right);
if (element.Operator != element.Left.Operator && element.Left.HasChildren)
{
left = $"({left})";
}
if (element.Operator != element.Right.Operator && element.Right.HasChildren)
{
right = $"({right})";
}
if (element.Operator == PredicateOperator.AndAlso)
{
return($"{left} and {right}");
}
if (element.Operator == PredicateOperator.OrElse)
{
return($"{left} or {right}");
}
throw new InvalidOperationException();
}
else
{
var builder = new StringBuilder();
builder.Append(columnMap[element.PropertyName].ColumnName);
switch (element.Operator)
{
case PredicateOperator.Equal:
if (element.Value == null)
{
builder.Append(" is null");
return(builder.ToString());
}
builder.Append(" = ");
break;
case PredicateOperator.NotEqual:
if (element.Value == null)
{
builder.Append(" is not null");
return(builder.ToString());
}
builder.Append(" <> ");
break;
case PredicateOperator.LessThan: builder.Append(" < "); break;
case PredicateOperator.LessThanOrEqual: builder.Append(" <= "); break;
case PredicateOperator.GreaterThan: builder.Append(" > "); break;
case PredicateOperator.GreaterThanOrEqual: builder.Append(" >= "); break;
case PredicateOperator.Contains: builder.Append(" in "); break;
default: throw new InvalidOperationException();
}
var parameterName = $"p{index.ToString(digitFormat)}";
++index;
parameter.Add(parameterName, element.Value); //--- cache parameter
builder.Append($"{prefix}{parameterName}");
return(builder.ToString());
}
};
//--- 組み立て
return(new This(sqlBuilder(root), parameter as ExpandoObject));
}
