/// <summary>
/// Executa as várias consultas.
/// </summary>
/// <param name="session"></param>
/// <param name="queryInfo"></param>
/// <returns></returns>
protected virtual IQueryResult Execute(GDASession session, QueryInfo queryInfo)
{
if (session.State == GDASessionState.Closed)
{
throw new QueryException("Database connection is closed to execute query");
}
queryInfo.Require("queries").NotNull();
string providerName = ProviderLocator.GetProviderName(queryInfo);
var providerConfiguration = GDASettings.GetProviderConfiguration(providerName);
if (queryInfo.StoredProcedureName == null)
{
SqlQueryParser parser = CreateParser(queryInfo);
string queryString = parser.GetText();
try
{
return(ExecuteQuery(session, queryString, queryInfo));
}
catch (GDAException ex)
{
throw new QueryException(string.Format("{0}. Query: {1}", ex.Message, queryInfo.ToString()), ex.InnerException);
}
}
else
{
return(ExecuteStoredProcedure(session, queryInfo));
}
}
/// <summary>
/// Construtor padrão.
/// </summary>
static MappingManager()
{
try
{
GDASettings.LoadConfiguration();
}
catch
{
}
}
/// <summary>
/// Realiza um refactor no mapeamento do sistema.
/// </summary>
/// <returns></returns>
public static XmlDocument RefactorSystemMapping(System.Reflection.Assembly assembly)
{
var doc = new XmlDocument();
var baseNamespace = assembly.FullName;
baseNamespace = baseNamespace.Substring(0, baseNamespace.IndexOf(','));
var root = doc.CreateElement("gda-mapping");
root.SetAttribute("assembly", assembly.FullName);
root.SetAttribute("namespace", baseNamespace);
root.SetAttribute("xmlns", "urn:gda-mapping-1.0");
var mnElement = doc.CreateElement("modelsNamespace");
foreach (var i in GDASettings.ModelsNamespaces)
{
var nElement = doc.CreateElement("namespace");
nElement.SetAttribute("name", i.Namespace);
nElement.SetAttribute("assembly", i.AssemblyName);
mnElement.AppendChild(nElement);
}
root.AppendChild(mnElement);
#if !PocketPC
if (GDAOperations.GlobalGenerateKey != null)
{
var mi = GDAOperations.GlobalGenerateKey.Method;
var ggkElement = doc.CreateElement("generateKeyHandler");
ggkElement.SetAttribute("methodName", mi.Name);
ggkElement.SetAttribute("classType", mi.DeclaringType.FullName);
}
#endif
var gkElement = doc.CreateElement("generatorsKey");
foreach (var i in GDASettings.GetGeneratorsKey())
{
var gElement = doc.CreateElement("generator");
gElement.SetAttribute("name", i.Key);
gElement.SetAttribute("classType", i.Value.GetType().FullName);
gkElement.AppendChild(gElement);
}
root.AppendChild(gkElement);
foreach (var i in assembly.GetTypes())
{
var classElement = RefactorClass(i, baseNamespace, doc);
if (classElement != null)
{
root.AppendChild(classElement);
}
}
doc.AppendChild(root);
return(doc);
}
/// <summary>
/// Retorna o parâmetro correspondente a chave primária
/// </summary>
/// <param name="transaction">Transação.</param>
/// <param name="entityName">Nome da entidade</param>
/// <returns>Pâremetro correspondente a chave primária</returns>
public object GetPrimaryKey(IPersistenceTransactionExecuter transaction, string entityName)
{
var metadata = _typeSchema.GetTypeMetadata(entityName);
var identityMetadata = metadata.GetKeyProperties().FirstOrDefault();
GDAStoredProcedure procedure = new GDAStoredProcedure("control.GetIdentityProcedure");
procedure.AddParameter("?schemaname", metadata.TableName.Schema);
procedure.AddParameter("?tablename", metadata.TableName.Name);
procedure.AddParameter("?columnname", identityMetadata.ColumnName);
using (GDASession session = new GDASession(GDASettings.GetProviderConfiguration(ProviderName)))
{
var da = new DataAccess();
return(da.ExecuteScalar(session, procedure));
}
}
/// <summary>
/// Cria a sessão de conexão com base no dados do grupo de execução.
/// </summary>
/// <param name="group"></param>
/// <returns></returns>
protected virtual GDASession CreateSession(QueryExecutionGroup group)
{
IProviderConfiguration providerConfiguration = null;
if (string.IsNullOrEmpty(group.ProviderName))
{
providerConfiguration = GDASettings.DefaultProviderConfiguration;
}
else
{
providerConfiguration = GDASettings.GetProviderConfiguration(group.ProviderName);
}
if (group.IsolationLevel == System.Transactions.IsolationLevel.Unspecified)
{
return(new GDASession(providerConfiguration));
}
else
{
var transaction = new GDATransaction(providerConfiguration, Convert(group.IsolationLevel));
transaction.BeginTransaction();
return(transaction);
}
}
/// <summary>
/// Retorna o parâmetro correspondente a chave primária
/// </summary>
/// <param name="transaction"></param>
/// <param name="entityName">Nome da entidade</param>
/// <returns>Pâremetro correspondente a chave primária</returns>
public object GetPrimaryKey(IPersistenceTransactionExecuter transaction, string entityName)
{
var metadata = _typeSchema.GetTypeMetadata(entityName);
var identityMetadata = metadata.GetKeyProperties().FirstOrDefault();
using (var session = new GDASession(GDASettings.GetProviderConfiguration(ProviderName)))
{
DataAccess da = session != null ? new DataAccess(session.ProviderConfiguration) : new DataAccess();
var indexes = new List <int>();
var script = "BEGIN \"CONTROL\".\"GETIDENTITY\"(:1,:2,:3,:4); END;";
var parameters = new GDA.Collections.GDAParameterCollection();
parameters.Add(new GDAParameter(":1", metadata.TableName.Schema, System.Data.ParameterDirection.Input));
parameters.Add(new GDAParameter(":2", metadata.TableName.Name, System.Data.ParameterDirection.Input));
parameters.Add(new GDAParameter(":3", identityMetadata.ColumnName, System.Data.ParameterDirection.Input));
var resultParameter = new GDAParameter(":4", null)
{
DbType = System.Data.DbType.Int32,
Direction = System.Data.ParameterDirection.Output
};
parameters.Add(resultParameter);
da.ExecuteCommand(session, script, parameters.ToArray());
return(resultParameter.Value);
}
}
/// <summary>
/// Importa um namespace para ser trabalhado pelo SqlBuilder.
/// </summary>
/// <param name="assembly">Assembly onde o namespace está introduzido.</param>
/// <param name="namesSpace">Namespace importado.</param>
public static void ImportNamespace(Assembly assembly, string namesSpace)
{
GDASettings.AddModelsNamespace(assembly, namesSpace);
}
/// <summary>
/// Carrega o tipo relacionado ao nome do tipo da model passado.
/// </summary>
/// <param name="modelTypeName">Nome do tipo da model</param>
internal static Type LoadModel(string modelTypeName)
{
GDASettings.LoadConfiguration();
string tReturn = null;
foreach (KeyValuePair <string, Dictionary <string, string> > k in ModelsNamespaceLoaded)
{
if (k.Value.TryGetValue(modelTypeName, out tReturn))
{
return(Type.GetType(tReturn));
}
}
foreach (ModelsNamespaceInfo ns in GDASettings.ModelsNamespaces)
{
string nn = modelTypeName;
if (nn.IndexOf(ns.Namespace) < 0)
{
nn = ns.Namespace + "." + modelTypeName;
}
var currentAssembly = ns.CurrentAssembly;
if (currentAssembly == null)
{
throw new GDAException("Fail on load assembly \"{0}\" for model namespace.", ns.AssemblyName);
}
Type t = ns.CurrentAssembly.GetType(nn);
if (t == null)
{
t = ns.CurrentAssembly.GetType(modelTypeName);
}
if (t != null)
{
if (!ModelsNamespaceLoaded.ContainsKey(ns.Namespace))
{
ModelsNamespaceLoaded.Add(ns.Namespace, new Dictionary <string, string>());
}
ModelsNamespaceLoaded[ns.Namespace].Add(modelTypeName, t.FullName + ", " + t.Assembly.FullName);
return(t);
}
}
Type rt = null;
#if PocketPC
if (Assembly.GetExecutingAssembly() != null)
{
rt = Assembly.GetExecutingAssembly().GetType(modelTypeName);
}
#else
var entry = Assembly.GetEntryAssembly();
if (entry != null)
{
rt = entry.GetType(modelTypeName);
}
else
{
entry = Assembly.GetCallingAssembly();
if (entry != null)
{
rt = entry.GetType(modelTypeName);
}
else
{
entry = Assembly.GetExecutingAssembly();
if (entry != null)
{
rt = entry.GetType(modelTypeName);
}
}
}
#endif
if (rt != null)
{
GDASettings.AddModelsNamespace(rt.Assembly, rt.Namespace);
if (!ModelsNamespaceLoaded.ContainsKey(rt.Namespace))
{
ModelsNamespaceLoaded.Add(rt.Namespace, new Dictionary <string, string>());
}
ModelsNamespaceLoaded[rt.Namespace].Add(modelTypeName, rt.FullName);
return(rt);
}
return(Type.GetType(modelTypeName, false));
}
/// <summary>
/// Importa os dados do mapeamento contido na stream.
/// </summary>
/// <param name="inputStream"></param>
public static void Import(System.IO.Stream inputStream)
{
if (inputStream == null)
{
throw new ArgumentNullException("inputStream");
}
try
{
var reader = XmlReader.Create(inputStream, new XmlReaderSettings {
IgnoreWhitespace = true,
IgnoreComments = true,
});
var doc = new System.Xml.XmlDocument();
doc.Load(reader);
var root = doc.DocumentElement;
if (!(root.LocalName == "gda-mapping" && root.NamespaceURI == "urn:gda-mapping-1.0"))
{
return;
}
var mappingNamespace = ElementMapping.GetAttributeString(root, "namespace");
var mappingAssembly = ElementMapping.GetAttributeString(root, "assembly");
var defaultProviderName = ElementMapping.GetAttributeString(root, "defaultProviderName");
var defaultProviderConfigurationName = ElementMapping.GetAttributeString(root, "defaultProviderConfigurationName");
var defaultConnectionString = ElementMapping.GetAttributeString(root, "defaultConnectionString");
var defaultSchema = ElementMapping.GetAttributeString(root, "defaultSchema");
foreach (XmlElement referencesElement in root.GetElementsByTagName("references"))
{
foreach (XmlElement i in referencesElement.GetElementsByTagName("reference"))
{
var refMapping = new ReferenceMapping(i);
bool exists = false;
lock (objLock)
exists = _references.Exists(f => f.Equals(refMapping));
if (!exists)
{
lock (objLock)
_references.Add(refMapping);
if (!string.IsNullOrEmpty(refMapping.FileName))
{
Import(refMapping.FileName);
}
else
{
Import(refMapping.AssemblyName, refMapping.ResourceName);
}
}
}
break;
}
lock (objLock)
{
foreach (XmlElement i in root.GetElementsByTagName("class"))
{
var classMap = new ClassMapping(i, mappingNamespace, mappingAssembly, defaultProviderName, defaultProviderConfigurationName, defaultConnectionString, defaultSchema);
if (!_classes.ContainsKey(classMap.TypeInfo.Fullname))
{
_classes.Add(classMap.TypeInfo.Fullname, classMap);
}
}
foreach (XmlElement i in root.GetElementsByTagName("sql-query"))
{
var queryMap = new SqlQueryMapping(i);
if (!_queries.ContainsKey(queryMap.Name))
{
_queries.Add(queryMap.Name, queryMap);
}
}
var modelsNamespace = ElementMapping.FirstOrDefault <XmlElement>(root.GetElementsByTagName("modelsNamespace"));
if (modelsNamespace != null)
{
foreach (XmlElement i in modelsNamespace.GetElementsByTagName("namespace"))
{
var ns = new ModelsNamespaceMapping(i);
GDASettings.AddModelsNamespace(ns.Assembly, ns.Namespace);
}
}
XmlElement generateKeyHandlerElement = ElementMapping.FirstOrDefault <XmlElement>(root.GetElementsByTagName("generateKeyHandler"));
if (generateKeyHandlerElement != null)
{
GDASettings.DefineGenerateKeyHandler(ElementMapping.GetAttributeString(generateKeyHandlerElement, "classType", true), ElementMapping.GetAttributeString(generateKeyHandlerElement, "methodName", true));
}
var generatorsElement = ElementMapping.FirstOrDefault <XmlElement>(root.GetElementsByTagName("generatorsKey"));
if (generatorsElement != null)
{
foreach (XmlElement i in generatorsElement.GetElementsByTagName("generator"))
{
var gk = new GeneratorKeyMapping(i);
IGeneratorKey instance = null;
try
{
instance = Activator.CreateInstance(gk.ClassType) as IGeneratorKey;
}
catch (Exception ex)
{
if (ex is System.Reflection.TargetInvocationException)
{
ex = ex.InnerException;
}
throw new GDAMappingException("Fail on create instance for \"{0}\".", gk.ClassType.FullName);
}
if (instance == null)
{
throw new GDAMappingException("\"{0}\" not inherits of {1}.", gk.ClassType.FullName, typeof(IGeneratorKey).FullName);
}
GDASettings.AddGeneratorKey(gk.Name, instance);
}
}
}
}
catch (Exception ex)
{
if (ex is GDAMappingException)
{
throw ex;
}
else
{
throw new GDAMappingException("Fail on load mapping", ex);
}
}
}
