internal FluentSqlBuilder(FluentSqlQueryBuilder sqlQueryBuilder, LambdaResolver resolver, TargetToSelect targetToSelect)
{
_sqlQueryBuilder = sqlQueryBuilder;
_resolver = resolver;
DefineTargetToSelect(targetToSelect);
}
public SqlLamBase(SqlAdapter adater, string tableName)
{
_type = SqlType.Query;
_adapter = adater;
_builder = new Builder(_type, tableName, GetAdapterInstance(_adapter));
_resolver = new LambdaResolver(_builder);
}
public GenericResolver(Type[] genericDefs, Type[] hints, LambdaResolver lambdaResolver)
{
_GenericDefs = genericDefs;
_GenericValues = hints ?? new Type[_GenericDefs.Length];
_LambdaResolver = lambdaResolver;
}
public GenericResolver(Type[] genericDefs, Type[] hints, LambdaResolver lambdaResolver)
{
_genericDefs = genericDefs;
_genericValues = hints ?? new Type[_genericDefs.Length];
_lambdaResolver = lambdaResolver;
}
private void DefineSqlAdapter(SqlAdapterType sqlAdapterType, Type typeTable, SqlBuilderFormatting formatting, string tableAlias)
{
var sqlAdapter = GetInstanceSqlAdapter(sqlAdapterType);
_sqlQueryBuilder = new FluentSqlQueryBuilder(sqlAdapter, typeTable, formatting, null, tableAlias);
_resolver = new LambdaResolver(_sqlQueryBuilder, tableAlias);
}
public SqlExpBase(SqlAdapterType adater, Type entityType)
{
_type = SqlType.Query;
_adapter = adater;
_entityType = entityType;
_builder = new Builder.Builder(_type, entityType, AdapterFactory.GetAdapterInstance(_adapter));
_resolver = new LambdaResolver(_builder);
}
public SqlExpBase(SqlAdapterType adater, SqlTableDefine tableDefine, List <SqlColumnDefine> columnDefines)
{
_type = SqlType.Query;
_adapter = adater;
_builder = new Builder.Builder(_type, tableDefine, columnDefines, AdapterFactory.GetAdapterInstance(_adapter));
_resolver = new LambdaResolver(_builder);
}
public SqlLam(SqlAdapter type = SqlAdapter.SqlServer2005)
: base(type, LambdaResolver.GetTableName <T>())
{
//_type = SqlType.Query;
//GetAdapterInstance(type);
//_builder = new Builder(_type, LambdaResolver.GetTableName<T>(), _defaultAdapter);
//_resolver = new LambdaResolver(_builder);
}
public SqlLam(SqlAdapter adapterType = SqlAdapter.SqlServer2008)
: base()
{
_type = SqlType.Query;
_adapter = adapterType;
_builder = new SqlQueryBuilder(_type, LambdaResolver.GetTableName <T>(), _defaultAdapter);
_resolver = new LambdaResolver(_builder);
}
internal Query(IDbProvider provider)
{
this.resolver = provider.CreateResolver();
var cnn = provider.CreateConnection();
var cmd = provider.CreateCommand();
cmd.Connection = cnn;
this.context = new QueryContext(resolver, cmd);
}
public SqlExpBase(SqlAdapterType adater, Type entityType, string specialSchema)
{
_type = SqlType.Query;
_adapter = adater;
_entityType = entityType;
SqlAdapter = AdapterFactory.GetAdapterInstance(_adapter);
_builder = new Builder.Builder(_type, entityType, SqlAdapter, specialSchema);
//_builder = new Builder.Builder(_type, entityType, AdapterFactory.GetAdapterInstance(_adapter));
_resolver = new LambdaResolver(_builder);
}
public void ResolveStatement(SqlQueryBuilder builder,
MethodCallExpression callExpression,
object[] arguments)
{
if (arguments.Length != 2)
{
throw new ArgumentException($"REPLACE Sql query requires 2 arguments for replacing old_string with new_string");
}
var columnName = LambdaResolver.GetColumnName(callExpression.Object);
builder.UpdateFieldReplaceString(columnName, arguments[0], arguments[1]);
}
public SqlLam()
{
_builder = new SqlQueryBuilder(LambdaResolver.GetTableName <T>(), _defaultAdapter);
_resolver = new LambdaResolver(_builder);
}
/// <summary>
/// Finds an extension method for current type.
/// </summary>
public MethodWrapper ResolveExtensionMethod(Type type, string name, Type[] argTypes, Type[] hints = null, LambdaResolver lambdaResolver = null)
{
return(ReflectionHelper.ResolveExtensionMethod(_extensionResolver, type, name, argTypes, hints, lambdaResolver));
}
/// <summary>
/// Resolves a method by its name and argument types. If generic arguments are passed, they are also applied.
/// Generic arguments whose values can be inferred from argument types can be skipped.
/// </summary>
public MethodWrapper ResolveMethod(Type type, string name, Type[] argTypes, Type[] hints = null, LambdaResolver resolver = null)
{
if (!(type is TypeBuilder))
{
return(ReflectionHelper.ResolveMethod(type, name, argTypes, hints, resolver));
}
var typeEntity = _definedTypes[type.Name];
try
{
var method = typeEntity.ResolveMethod(name, argTypes);
var mw = WrapMethod(method, ReflectionHelper.IsPartiallyApplied(argTypes));
var isGeneric = method.IsImported && method.MethodInfo.IsGenericMethod;
if (isGeneric)
{
var argTypeDefs = method.MethodInfo.GetParameters().Select(p => p.ParameterType).ToArray();
var genericDefs = method.MethodInfo.GetGenericArguments();
var genericValues = GenericHelper.ResolveMethodGenericsByArgs(argTypeDefs, argTypes, genericDefs, hints, resolver);
mw.MethodInfo = method.MethodInfo.MakeGenericMethod(genericValues);
mw.ArgumentTypes = method.GetArgumentTypes(this).Select(t => GenericHelper.ApplyGenericArguments(t, genericDefs, genericValues)).ToArray();
mw.GenericArguments = genericValues;
mw.ReturnType = GenericHelper.ApplyGenericArguments(method.MethodInfo.ReturnType, genericDefs, genericValues);
}
else
{
if (hints != null)
{
Error(CompilerMessages.GenericArgsToNonGenericMethod, name);
}
}
return(mw);
}
catch (KeyNotFoundException)
{
return(ResolveMethod(type.BaseType, name, argTypes, hints));
}
}
internal SqlExp(Builder.Builder builder, LambdaResolver resolver)
{
_builder = builder;
_resolver = resolver;
}
internal Query(QueryContext context)
{
this.resolver = context.Resolver;
this.context = context;
}
/// <summary>
/// Finds an extension method for current type.
/// </summary>
public MethodWrapper ResolveExtensionMethod(Type type, string name, Type[] argTypes, Type[] hints = null, LambdaResolver lambdaResolver = null)
{
return ReflectionHelper.ResolveExtensionMethod(_ExtensionResolver, type, name, argTypes, hints, lambdaResolver);
}
/// <summary>
/// Resolves an extension method by arguments.
/// </summary>
public static MethodWrapper ResolveExtensionMethod(ExtensionMethodResolver resolver, Type type, string name, Type[] argTypes, Type[] hints, LambdaResolver lambdaResolver)
{
var method = resolver.ResolveExtensionMethod(type, name, argTypes);
var args = method.GetParameters();
var info = new MethodWrapper
{
Name = name,
Type = method.DeclaringType,
MethodInfo = method,
IsStatic = true,
IsVirtual = false,
ReturnType = method.ReturnType,
ArgumentTypes = args.Select(p => p.ParameterType).ToArray(),
IsPartiallyApplied = IsPartiallyApplied(argTypes),
IsVariadic = IsVariadic(method),
};
if (method.IsGenericMethod)
{
var expectedTypes = method.GetParameters().Select(p => p.ParameterType).ToArray();
var genericDefs = method.GetGenericArguments();
var extMethodArgs = argTypes.ToList();
extMethodArgs.Insert(0, type);
var genericValues = GenericHelper.ResolveMethodGenericsByArgs(
expectedTypes,
extMethodArgs.ToArray(),
genericDefs,
hints,
lambdaResolver
);
info.GenericArguments = genericValues;
info.MethodInfo = info.MethodInfo.MakeGenericMethod(genericValues);
info.ReturnType = GenericHelper.ApplyGenericArguments(info.ReturnType, genericDefs, genericValues);
info.ArgumentTypes = expectedTypes.Select(t => GenericHelper.ApplyGenericArguments(t, genericDefs, genericValues)).ToArray();
}
else if (hints != null)
{
error(CompilerMessages.GenericArgsToNonGenericMethod, name);
}
return(info);
}
/// <summary>
/// Resolves a method by its name and argument types. If generic arguments are passed, they are also applied.
/// Generic arguments whose values can be inferred from argument types can be skipped.
/// </summary>
public MethodWrapper ResolveMethod(Type type, string name, Type[] argTypes, Type[] hints = null, LambdaResolver resolver = null)
{
if (!(type is TypeBuilder))
return ReflectionHelper.ResolveMethod(type, name, argTypes, hints, resolver);
var typeEntity = _DefinedTypes[type.Name];
try
{
var method = typeEntity.ResolveMethod(name, argTypes);
var mw = wrapMethod(method, ReflectionHelper.IsPartiallyApplied(argTypes));
var isGeneric = method.IsImported && method.MethodInfo.IsGenericMethod;
if (isGeneric)
{
var argTypeDefs = method.MethodInfo.GetParameters().Select(p => p.ParameterType).ToArray();
var genericDefs = method.MethodInfo.GetGenericArguments();
var genericValues = GenericHelper.ResolveMethodGenericsByArgs(argTypeDefs, argTypes, genericDefs, hints);
mw.MethodInfo = method.MethodInfo.MakeGenericMethod(genericValues);
mw.ArgumentTypes = method.GetArgumentTypes(this).Select(t => GenericHelper.ApplyGenericArguments(t, genericDefs, genericValues)).ToArray();
mw.GenericArguments = genericValues;
mw.ReturnType = GenericHelper.ApplyGenericArguments(method.MethodInfo.ReturnType, genericDefs, genericValues);
}
else
{
if (hints != null)
Error(CompilerMessages.GenericArgsToNonGenericMethod, name);
}
return mw;
}
catch (KeyNotFoundException)
{
return ResolveMethod(type.BaseType, name, argTypes, hints);
}
}
public DML(IDbProvider dbProvider)
{
this.dbProvider = dbProvider;
this.resolver = dbProvider.CreateResolver();
}
internal SqlLam(SqlQueryBuilder builder, LambdaResolver resolver)
{
_builder = builder;
_resolver = resolver;
}
public void InsertTo <TTo>()
{
TableNames.Add(LambdaResolver.GetTableName <TTo>());
}
public SqlJoinBuilder(int paramCount = 0)
{
Builder = new SqlQueryBuilder(LambdaResolver.GetTableName <T2>(), DefaultAdapter, paramCount);
Resolver = new LambdaResolver(Builder);
}
/// <summary>
/// Resolves the generic values for a specified type.
/// </summary>
/// <param name="expectedTypes">Parameter types from method definition.</param>
/// <param name="actualTypes">Argument types from method invocation site. </param>
/// <param name="genericDefs">Generic parameters from method definition.</param>
/// <param name="hints">Extra hints that are specified explicitly.</param>
/// <param name="lambdaResolver">
/// Callback for Lambda`T resolution.
/// Passed arguments are:
/// 1. Lambda's position in the argument list (to find a corresponding NodeBase)
/// 2. Already resolved list of types
/// Return value is the inferred type of lambda return.
/// </param>
/// <returns></returns>
public static Type[] ResolveMethodGenericsByArgs(Type[] expectedTypes, Type[] actualTypes, Type[] genericDefs, Type[] hints = null, LambdaResolver lambdaResolver = null)
{
if(hints != null && hints.Length != genericDefs.Length)
throw new ArgumentException("hints");
var resolver = new GenericResolver(genericDefs, hints, lambdaResolver);
return resolver.Resolve(expectedTypes, actualTypes);
}
public SqlBuilderFluentExtension(LambdaResolver resolver, FluentSqlQueryBuilder sqlQueryBuilder)
{
_resolver = resolver;
_sqlQueryBuilder = sqlQueryBuilder;
}
public QueryContext(LambdaResolver resolver, IDbCommand command)
{
Resolver = resolver;
Command = command;
}
/// <summary>
/// Resolves the generic values for a specified type.
/// </summary>
/// <param name="expectedTypes">Parameter types from method definition.</param>
/// <param name="actualTypes">Argument types from method invocation site. </param>
/// <param name="genericDefs">Generic parameters from method definition.</param>
/// <param name="hints">Extra hints that are specified explicitly.</param>
/// <param name="lambdaResolver">
/// Callback for Lambda`T resolution.
/// Passed arguments are:
/// 1. Lambda's position in the argument list (to find a corresponding NodeBase)
/// 2. Already resolved list of types
/// Return value is the inferred type of lambda return.
/// </param>
public static Type[] ResolveMethodGenericsByArgs(Type[] expectedTypes, Type[] actualTypes, Type[] genericDefs, Type[] hints = null, LambdaResolver lambdaResolver = null)
{
if (hints != null && hints.Length != genericDefs.Length)
{
throw new ArgumentException("hints");
}
var resolver = new GenericResolver(genericDefs, hints, lambdaResolver);
return(resolver.Resolve(expectedTypes, actualTypes));
}
/// <summary>
/// Resolves a method by its name and argument types. If generic arguments are passed, they are also applied.
/// Generic arguments whose values can be inferred from argument types can be skipped.
/// </summary>
public static MethodWrapper ResolveMethod(Type type, string name, Type[] argTypes, Type[] hints, LambdaResolver lambdaResolver)
{
var mw = new MethodWrapper {
Name = name, Type = type
};
try
{
var method = ResolveMethodByArgs(
getMethodsByName(type, name),
m => m.GetParameters().Select(p => p.ParameterType).ToArray(),
IsVariadic,
argTypes
);
var mInfo = method.Method;
if (mInfo.IsGenericMethod)
{
var genericDefs = mInfo.GetGenericArguments();
var genericValues = GenericHelper.ResolveMethodGenericsByArgs(method.ArgumentTypes, argTypes, genericDefs, hints);
mInfo = mInfo.MakeGenericMethod(genericValues);
mw.GenericArguments = genericValues;
}
else if (hints != null)
{
error(CompilerMessages.GenericArgsToNonGenericMethod, name);
}
mw.MethodInfo = mInfo;
mw.IsStatic = mInfo.IsStatic;
mw.IsVirtual = mInfo.IsVirtual;
mw.ArgumentTypes = method.ArgumentTypes;
mw.ReturnType = mInfo.ReturnType;
mw.IsPartiallyApplied = IsPartiallyApplied(argTypes);
mw.IsVariadic = IsVariadic(mInfo);
return(mw);
}
catch (NotSupportedException)
{
if (!type.IsGenericType)
{
throw new KeyNotFoundException();
}
var genType = type.GetGenericTypeDefinition();
var genMethod = ResolveMethodByArgs(
getMethodsByName(genType, name),
m => m.GetParameters().Select(p => GenericHelper.ApplyGenericArguments(p.ParameterType, type, false)).ToArray(),
IsVariadic,
argTypes
);
var mInfoOriginal = genMethod.Method;
var declType = resolveActualDeclaringType(type, mInfoOriginal.DeclaringType);
var mInfo = getMethodVersionForType(declType, mInfoOriginal);
if (mInfoOriginal.IsGenericMethod)
{
var genericDefs = mInfoOriginal.GetGenericArguments();
var genericValues = GenericHelper.ResolveMethodGenericsByArgs(genMethod.ArgumentTypes, argTypes, genericDefs, hints, lambdaResolver);
mInfo = mInfo.MakeGenericMethod(genericValues);
var totalGenericDefs = genericDefs.Union(genType.GetGenericTypeDefinition().GetGenericArguments()).ToArray();
var totalGenericValues = genericValues.Union(type.GetGenericArguments()).ToArray();
mw.GenericArguments = genericValues;
mw.ReturnType = GenericHelper.ApplyGenericArguments(mInfoOriginal.ReturnType, totalGenericDefs, totalGenericValues);
mw.ArgumentTypes = mInfoOriginal.GetParameters().Select(p => GenericHelper.ApplyGenericArguments(p.ParameterType, totalGenericDefs, totalGenericValues)).ToArray();
}
else
{
if (hints != null)
{
error(CompilerMessages.GenericArgsToNonGenericMethod, name);
}
mw.ArgumentTypes = mInfoOriginal.GetParameters().Select(p => GenericHelper.ApplyGenericArguments(p.ParameterType, type)).ToArray();
mw.ReturnType = GenericHelper.ApplyGenericArguments(mInfoOriginal.ReturnType, type, false);
}
mw.MethodInfo = mInfo;
mw.IsStatic = mInfoOriginal.IsStatic;
mw.IsVirtual = mInfoOriginal.IsVirtual;
mw.IsPartiallyApplied = IsPartiallyApplied(argTypes);
mw.IsVariadic = IsVariadic(mInfoOriginal);
}
return(mw);
}
