private void SetDbParams(System.Data.Common.DbConnection conn)
{
if (conn.GetType().Name.ToLower().IndexOf("oracle") > -1 || conn.GetType().Name.ToLower().IndexOf("pgsql") > -1)
{
dbParamChar = ':';
}
}
/// <summary>
/// Creates data adapter for specifided database connection.
/// </summary>
/// <param name="connection">Database connection for detection specialization.</param>
/// <returns>Relatived data adapter.</returns>
public static DbDataAdapter CreateDataAdapter(DbConnection connection)
{
Debug.Assert(null != connection); // created
Debug.Assert((connection.GetType() == typeof(OleDbConnection)) ||
(connection.GetType() == typeof(OdbcConnection))); // supported type
// select DB provider factory by connection type
DbProviderFactory factory = (connection.GetType() == typeof(OleDbConnection)) ?
(DbProviderFactory)OleDbFactory.Instance :
(DbProviderFactory)OdbcFactory.Instance;
return _CreateDataAdapter(factory);
}
public static string GenerateAllTables(this System.Data.Common.DbConnection connection, GeneratorBehavior generatorBehavior = GeneratorBehavior.Default)
{
if (connection.State != ConnectionState.Open)
{
connection.Open();
}
var conneciontName = connection.GetType().Name.ToLower();
var tables = new List <string>();
var sql = generatorBehavior.HasFlag(GeneratorBehavior.View) ? TableSchemaSqls[conneciontName].Split("where")[0] : TableSchemaSqls[conneciontName];
using (var command = connection.CreateCommand(sql))
using (var reader = command.ExecuteReader())
{
while (reader.Read())
{
tables.Add(reader.GetString(0));
}
}
var sb = new StringBuilder();
sb.AppendLine("namespace Models { ");
tables.ForEach(table => sb.Append(connection.GenerateClass(
string.Format(QuerySqls[conneciontName], table), table, generatorBehavior: generatorBehavior
)));
sb.AppendLine("}");
return(sb.ToString());
}
public DbProviderFactory GetProviderFactory(DbConnection connection)
{
Check.NotNull(connection, "connection");
#if NET40
var connectionType = connection.GetType();
return _cache.GetOrAdd(
connectionType,
t =>
{
var row = _finder.FindRow(t, r => ExactMatch(r, t))
?? _finder.FindRow(null, r => ExactMatch(r, t))
?? _finder.FindRow(t, r => AssignableMatch(r, t))
?? _finder.FindRow(null, r => AssignableMatch(r, t));
if (row == null)
{
throw new NotSupportedException(Strings.ProviderNotFound(connection.ToString()));
}
return DbProviderFactories.GetFactory(row);
});
#else
return DbProviderFactories.GetFactory(connection);
#endif
}
public string ResolveManifestToken(DbConnection connection)
{
return (!string.IsNullOrWhiteSpace(connection.Database) // Some negative cases require the provider to fail
&& connection is SqlConnection)
|| connection.GetType().FullName.StartsWith("Castle.Proxies.")
? "2008"
: _defaultManifestTokenResolver.ResolveManifestToken(connection);
}
//#if COREFX
public SchemaParameters(System.Data.Common.DbConnection dbConnection)
{
DbConnection = dbConnection;
ProviderName = DbConnection.GetType().Namespace;
ConnectionString = dbConnection.ConnectionString;
SqlType = ProviderToSqlType.Convert(ProviderName);
Exclusions = new Exclusions();
}
protected override string GetDbProviderManifestToken(DbConnection connection)
{
if (connection.GetType()
!= typeof(EntityConnection))
{
throw new ArgumentException(Strings.Mapping_Provider_WrongConnectionType(typeof(EntityConnection)));
}
return MetadataItem.EdmProviderManifest.Token;
}
protected override string GetDbProviderManifestToken(DbConnection connection)
{
EntityUtil.CheckArgumentNull(connection, "connection");
if (connection.GetType() != typeof(EntityConnection))
{
throw EntityUtil.Argument(System.Data.Entity.Strings.Mapping_Provider_WrongConnectionType(typeof(EntityConnection)));
}
return MetadataItem.EdmProviderManifest.Token;
}
/// <inheritdoc />
public string ResolveManifestToken(DbConnection connection)
{
Check.NotNull(connection, "connection");
var interceptionContext = new DbInterceptionContext();
var key = Tuple.Create(connection.GetType(),
DbInterception.Dispatch.Connection.GetDataSource(connection, interceptionContext),
DbInterception.Dispatch.Connection.GetDatabase(connection, interceptionContext));
return _cachedTokens.GetOrAdd(
key,
k => DbProviderServices.GetProviderServices(connection).GetProviderManifestTokenChecked(connection));
}
public static ISchemaBuilder For(DbConnection connection)
{
string connectionName = connection.GetType().Name.ToLower();
if (!SchemaBuilders.ContainsKey(connectionName))
{
throw new ArgumentException("Unknown connection name: " + connectionName);
}
var dialect = SqlDialectFactory.For(connection);
return SchemaBuilders[connectionName](dialect);
}
/// <summary>
/// Factory method
/// </summary>
/// <param name="connection"></param>
/// <param name="doInjectFaultAction"></param>
/// <returns></returns>
public static ChaosDbConnection Create(DbConnection connection, Func<bool> doInjectFaultAction = null)
{
ChaosDbConnection result = null;
if (connection != null)
{
var connType = connection.GetType();
if (connType == typeof(System.Data.SqlClient.SqlConnection))
{
result = new Sql.SqlChaosDbConnection(connection, doInjectFaultAction ?? ChaosHelper.DefaultDoInjectFault);
}
else
{
// default
result = new ChaosDbConnection(connection, doInjectFaultAction ?? ChaosHelper.DefaultDoInjectFault);
}
}
return result;
}
public static DbDataAdapter CreateDataAdapter(DbCommand dbCommand, DbConnection connection)
{
DbDataAdapter adapter; //we can't construct an adapter directly
//So let's run around the block 3 times, before potentially crashing
if (connection is System.Data.SqlClient.SqlConnection)
adapter = new System.Data.SqlClient.SqlDataAdapter(dbCommand.CommandText, connection as SqlConnection);
else if (connection is System.Data.OleDb.OleDbConnection)
adapter = new System.Data.OleDb.OleDbDataAdapter(dbCommand.CommandText, connection as System.Data.OleDb.OleDbConnection);
else if (connection is System.Data.Odbc.OdbcConnection)
adapter = new System.Data.Odbc.OdbcDataAdapter(dbCommand.CommandText, connection as System.Data.Odbc.OdbcConnection);
else if (connection is System.Data.SqlServerCe.SqlCeConnection)
adapter = new System.Data.SqlServerCe.SqlCeDataAdapter(dbCommand.CommandText, connection as System.Data.SqlServerCe.SqlCeConnection);
//TODO: Add more DbConnection kinds as they become invented
else
{
throw new Exception("[CreateDataAdapter] Unknown DbConnection type: " + connection.GetType().FullName);
}
return adapter;
}
public DbProviderFactory GetProviderFactory(DbConnection connection, IEnumerable<DataRow> dataRows)
{
DebugCheck.NotNull(connection);
DebugCheck.NotNull(dataRows);
var connectionType = connection.GetType();
return _cache.GetOrAdd(
connectionType,
t =>
{
var row = _finder.FindRow(t, r => ExactMatch(r, t), dataRows)
?? _finder.FindRow(null, r => ExactMatch(r, t), dataRows)
?? _finder.FindRow(t, r => AssignableMatch(r, t), dataRows)
?? _finder.FindRow(null, r => AssignableMatch(r, t), dataRows);
if (row == null)
{
throw new NotSupportedException(Strings.ProviderNotFound(connection.ToString()));
}
return DbProviderFactories.GetFactory(row);
});
}
/// <summary>
/// 根据连接类型建立联接
/// </summary>
/// <param name="connection">所需建立的连接，目前有OleConnection和SqlConnection</param>
public static void BuildConnection(DbConnection connection)
{
if (connection.GetType().FullName.Equals("System.Data.SqlClient.SqlConnection"))
{
ExcelUtility.sqlConnectionString = "Data Source=.; database=JXT; uid=sa; pwd=123456";
ExcelUtility.sqlConnection = new SqlConnection(ExcelUtility.sqlConnectionString);
}
else if (connection.GetType().FullName.Equals("System.Data.OleDb.OleDbConnection"))
{
ExcelUtility.oleConnectionString = @"Provider=Microsoft.Jet.OLEDB.4.0;Data Source=" + ExcelUtility.excelItem.Path + @";Extended Properties=""Excel 8.0;HDR=YES;IMEX=1;""";
ExcelUtility.OleConnection = new OleDbConnection(ExcelUtility.oleConnectionString);
}
}
private void MultipleErrorHandling(DbConnection connection)
{
try
{
Console.WriteLine("MultipleErrorHandling {0}", connection.GetType().Name);
Type expectedException = null;
if (connection is SqlConnection)
{
((SqlConnection)connection).InfoMessage += delegate (object sender, SqlInfoMessageEventArgs args)
{
Console.WriteLine("*** SQL CONNECTION INFO MESSAGE : {0} ****", args.Message);
};
expectedException = typeof(SqlException);
}
connection.Open();
using (DbCommand command = connection.CreateCommand())
{
command.CommandText =
"PRINT N'0';\n" +
"SELECT num = 1, str = 'ABC';\n" +
"PRINT N'1';\n" +
"RAISERROR('Error 1', 15, 1);\n" +
"PRINT N'3';\n" +
"SELECT num = 2, str = 'ABC';\n" +
"PRINT N'4';\n" +
"RAISERROR('Error 2', 15, 1);\n" +
"PRINT N'5';\n" +
"SELECT num = 3, str = 'ABC';\n" +
"PRINT N'6';\n" +
"RAISERROR('Error 3', 15, 1);\n" +
"PRINT N'7';\n" +
"SELECT num = 4, str = 'ABC';\n" +
"PRINT N'8';\n" +
"RAISERROR('Error 4', 15, 1);\n" +
"PRINT N'9';\n" +
"SELECT num = 5, str = 'ABC';\n" +
"PRINT N'10';\n" +
"RAISERROR('Error 5', 15, 1);\n" +
"PRINT N'11';\n";
try
{
Console.WriteLine("**** ExecuteNonQuery *****");
command.ExecuteNonQuery();
}
catch (Exception e)
{
PrintException(expectedException, e);
}
try
{
Console.WriteLine("**** ExecuteScalar ****");
command.ExecuteScalar();
}
catch (Exception e)
{
PrintException(expectedException, e);
}
try
{
Console.WriteLine("**** ExecuteReader ****");
using (DbDataReader reader = command.ExecuteReader())
{
bool moreResults = true;
do
{
try
{
Console.WriteLine("NextResult");
moreResults = reader.NextResult();
}
catch (Exception e)
{
PrintException(expectedException, e);
}
} while (moreResults);
}
}
catch (Exception e)
{
PrintException(null, e);
}
}
}
catch (Exception e)
{
PrintException(null, e);
}
try
{
connection.Dispose();
}
catch (Exception e)
{
PrintException(null, e);
}
}
/// <summary>Retrieves the DbProviderFactory based on the specified DbConnection.</summary>
/// <returns>The retrieved DbProviderFactory.</returns>
/// <param name="connection">The connection to use.</param>
public static DbProviderFactory GetProviderFactory(DbConnection connection)
{
Check.NotNull(connection, "connection");
var factory = connection.GetProviderFactory();
if (factory == null)
{
throw new ProviderIncompatibleException(
Strings.EntityClient_ReturnedNullOnProviderMethod(
"get_ProviderFactory",
connection.GetType().ToString()));
}
return factory;
}
internal void Run(DbConnection cnn)
{
frm = new Form1();
frm.Show();
frm.WriteLine("\r\nBeginning Test on " + cnn.GetType().ToString());
try { CreateTable(cnn); frm.WriteLine("SUCCESS - CreateTable"); }
catch (Exception) { frm.WriteLine("FAIL - CreateTable"); }
try { DataTypeTest(cnn); frm.WriteLine("SUCCESS - DataType Test"); }
catch (Exception) { frm.WriteLine("FAIL - DataType Test"); }
try { FullTextTest(cnn); frm.WriteLine("SUCCESS - Full Text Search"); }
catch (Exception) { frm.WriteLine("FAIL - Full Text Search"); }
try { KeyInfoTest(cnn); frm.WriteLine("SUCCESS - KeyInfo Fetch"); }
catch (Exception) { frm.WriteLine("FAIL - KeyInfo Fetch"); }
try { InsertTable(cnn); frm.WriteLine("SUCCESS - InsertTable"); }
catch (Exception) { frm.WriteLine("FAIL - InsertTable"); }
try { VerifyInsert(cnn); frm.WriteLine("SUCCESS - VerifyInsert"); }
catch (Exception) { frm.WriteLine("FAIL - VerifyInsert"); }
try { CoersionTest(cnn); frm.WriteLine("FAIL - CoersionTest"); }
catch (Exception) { frm.WriteLine("SUCCESS - CoersionTest"); }
try { ParameterizedInsert(cnn); frm.WriteLine("SUCCESS - ParameterizedInsert"); }
catch (Exception) { frm.WriteLine("FAIL - ParameterizedInsert"); }
try { BinaryInsert(cnn); frm.WriteLine("SUCCESS - BinaryInsert"); }
catch (Exception) { frm.WriteLine("FAIL - BinaryInsert"); }
try { VerifyBinaryData(cnn); frm.WriteLine("SUCCESS - VerifyBinaryData"); }
catch (Exception) { frm.WriteLine("FAIL - VerifyBinaryData"); }
try { LockTest(cnn); frm.WriteLine("SUCCESS - LockTest"); }
catch (Exception) { frm.WriteLine("FAIL - LockTest"); }
try { ParameterizedInsertMissingParams(cnn); frm.WriteLine("FAIL - ParameterizedInsertMissingParams"); }
catch (Exception) { frm.WriteLine("SUCCESS - ParameterizedInsertMissingParams"); }
try { InsertMany(cnn, false); frm.WriteLine("SUCCESS - InsertMany"); }
catch (Exception) { frm.WriteLine("FAIL - InsertMany"); }
try { InsertMany(cnn, true); frm.WriteLine("SUCCESS - InsertManyWithIdentityFetch"); }
catch (Exception) { frm.WriteLine("FAIL - InsertManyWithIdentityFetch"); }
try { FastInsertMany(cnn); frm.WriteLine("SUCCESS - FastInsertMany"); }
catch (Exception) { frm.WriteLine("FAIL - FastInsertMany"); }
try { IterationTest(cnn); frm.WriteLine("SUCCESS - Iteration Test"); }
catch (Exception) { frm.WriteLine("FAIL - Iteration Test"); }
try { UserFunction(cnn); frm.WriteLine("SUCCESS - UserFunction"); }
catch (Exception) { frm.WriteLine("FAIL - UserFunction"); }
try { UserAggregate(cnn); frm.WriteLine("SUCCESS - UserAggregate"); }
catch (Exception) { frm.WriteLine("FAIL - UserAggregate"); }
try { UserCollation(cnn); frm.WriteLine("SUCCESS - UserCollation"); }
catch (Exception) { frm.WriteLine("FAIL - UserCollation"); }
try { DropTable(cnn); frm.WriteLine("SUCCESS - DropTable"); }
catch (Exception) { frm.WriteLine("FAIL - DropTable"); }
frm.WriteLine("\r\nTests Finished.");
}
public static IDatabaseFactory FindFactory(DbConnection connection)
{
if (_factoryByType.ContainsKey(connection.GetType())) return _factoryByType[connection.GetType()];
return null;
}
/// <summary>
/// 通过DbConnection对象创建DbConfiguration对象
/// </summary>
/// <param name="conn"></param>
/// <returns></returns>
public static DbConfiguration Configure(DbConnection conn)
{
Guard.NotNull(conn, "conn");
var providerType = conn.GetType()
.Assembly
.GetTypes()
.Where(t => typeof(System.Data.Common.DbProviderFactory).IsAssignableFrom(t)
&& t.Namespace == conn.GetType().Namespace)
.FirstOrDefault()
;
if (providerType == null)
throw new NotSupportedException("not found 'DbProviderFactory'");
var factory = providerType.GetField("Instance", BindingFlags.Public | BindingFlags.Static).GetValue(null) as DbProviderFactory;
Guard.NotNull(factory, "factory");
var providerName = providerType.Namespace;
var cfg = new DbConfiguration(providerName, Guid.NewGuid().ToString(), conn.ConnectionString, factory);
if (!Options.ContainsKey(providerName))
{
var dbtype = conn.GetType().Name;
if (dbtype.StartsWith("MySql")) providerName = DbProviderNames.MySQL;
else if (dbtype.StartsWith("SqlCe")) providerName = DbProviderNames.SqlCe35;
else if (dbtype.StartsWith("Oledb")) providerName = DbProviderNames.Oledb;
else if (dbtype.StartsWith("Oracle")) providerName = DbProviderNames.Oracle;
else if (dbtype.StartsWith("SQLite")) providerName = DbProviderNames.SQLite;
else if (dbtype.StartsWith("System.Data.SqlClient.")) providerName = DbProviderNames.SqlServer;
}
if (Options.ContainsKey(providerName))
{
cfg.Option = Options[providerName];
}
PopulateSqlServer2000(conn, factory, cfg);
cfg.connection = conn;
return cfg;
}
// The provider manifest token helps to distinguish between store versions.
// We have only one backend version.
// However, use the connection passed in to determine whether
// the provider is local provider or remote provider
//
protected override string GetDbProviderManifestToken(DbConnection connection)
{
// vamshikb: Do we need to validate the connection and connection string
// before returning the ProviderManifestToken????
// Determine the type of DbConnection
// This method should never be called at runtime, so the provider
// must be remote provider.
// Throw if it is none.
//
if (connection.GetType()
== typeof(SqlCeConnection))
{
_isLocalProvider = true;
}
else if (RemoteProviderHelper.CompareObjectEqualsToType(connection, RemoteProvider.SqlCeConnection))
{
_isLocalProvider = false;
}
else
{
throw ADP1.Argument(EntityRes.GetString(EntityRes.Mapping_Provider_WrongConnectionType, "SqlCeConnection"));
}
return SqlCeProviderManifest.Token40;
}
//
// : IDbTransaction
//
internal static Exception ParallelTransactionsNotSupported(DbConnection obj)
{
return(InvalidOperation(SR.GetString(SR.ADP_ParallelTransactionsNotSupported, obj.GetType().Name)));
}
public static DbParameter[] GetCachedParameters(DbConnection dbConnection, string name)
{
if (dbConnection == null)
{
throw new ArgumentNullException("dbConn");
}
if (string.IsNullOrEmpty(name))
{
throw new ArgumentNullException("spName");
}
string str = name + "###" + dbConnection.ConnectionString + "###" + dbConnection.GetType().ToString();
DbParameter[] parameterArray = hashtable[str] as DbParameter[];
if (parameterArray == null)
{
lock (hashtable.SyncRoot)
{
parameterArray = hashtable[str] as DbParameter[];
if (parameterArray == null)
{
parameterArray = DeriveParameters(dbConnection, name);
hashtable[str] = parameterArray;
}
}
}
return CloneParameters(parameterArray);
}
private static MetadataWorkspace GetProviderSchemaMetadataWorkspace(DbProviderServices providerServices, DbConnection providerConnection, Version targetEntityFrameworkVersion)
{
XmlReader csdl = null;
XmlReader ssdl = null;
XmlReader msl = null;
Debug.Assert(EntityFrameworkVersions.IsValidVersion(targetEntityFrameworkVersion), "EntityFrameworkVersions.IsValidVersion(targetEntityFrameworkVersion)");
string csdlName;
string ssdlName;
string mslName;
if (targetEntityFrameworkVersion >= EntityFrameworkVersions.Version3)
{
csdlName = DbProviderManifest.ConceptualSchemaDefinitionVersion3;
ssdlName = DbProviderManifest.StoreSchemaDefinitionVersion3;
mslName = DbProviderManifest.StoreSchemaMappingVersion3;
}
else
{
csdlName = DbProviderManifest.ConceptualSchemaDefinition;
ssdlName = DbProviderManifest.StoreSchemaDefinition;
mslName = DbProviderManifest.StoreSchemaMapping;
}
try
{
// create the metadata workspace
MetadataWorkspace workspace = new MetadataWorkspace();
string manifestToken = providerServices.GetProviderManifestToken(providerConnection);
DbProviderManifest providerManifest = providerServices.GetProviderManifest(manifestToken);
// create the EdmItemCollection
IList<EdmSchemaError> errors;
ssdl = providerManifest.GetInformation(ssdlName);
string location = Strings.DbProviderServicesInformationLocationPath(providerConnection.GetType().Name, ssdlName);
List<string> ssdlLocations = new List<string>(1);
ssdlLocations.Add(location);
StoreItemCollection storeItemCollection = new StoreItemCollection(new XmlReader[] { ssdl }, ssdlLocations.AsReadOnly(), out errors);
ThrowOnError(errors);
workspace.RegisterItemCollection(storeItemCollection);
csdl = DbProviderServices.GetConceptualSchemaDefinition(csdlName);
location = Strings.DbProviderServicesInformationLocationPath(typeof(DbProviderServices).Name, csdlName);
List<string> csdlLocations = new List<string>(1);
csdlLocations.Add(location);
EdmItemCollection edmItemCollection = new EdmItemCollection(new XmlReader[] { csdl }, csdlLocations.AsReadOnly(), out errors);
ThrowOnError(errors);
workspace.RegisterItemCollection(edmItemCollection);
msl = providerManifest.GetInformation(mslName);
location = Strings.DbProviderServicesInformationLocationPath(providerConnection.GetType().Name, DbProviderManifest.StoreSchemaMapping);
List<string> mslLocations = new List<string>(1);
mslLocations.Add(location);
StorageMappingItemCollection mappingItemCollection = new StorageMappingItemCollection(edmItemCollection,
storeItemCollection,
new XmlReader[] { msl },
mslLocations,
out errors);
ThrowOnError(errors);
workspace.RegisterItemCollection(mappingItemCollection);
// make the views generate here so we can wrap the provider schema problems
// in a ProviderIncompatibleException
ForceViewGeneration(workspace);
return workspace;
}
catch (ProviderIncompatibleException)
{
// we don't really want to catch this one, just rethrow it
throw;
}
catch (Exception e)
{
if (MetadataUtil.IsCatchableExceptionType(e))
{
throw EDesignUtil.ProviderIncompatible(Strings.ProviderSchemaErrors, e);
}
throw;
}
finally
{
if (csdl != null) ((IDisposable)csdl).Dispose();
if (ssdl != null) ((IDisposable)ssdl).Dispose();
if (msl != null) ((IDisposable)msl).Dispose();
}
}
private void btnOpen_Click(object sender, EventArgs e)
{
btnClose_Click(sender, null);
// main.
string sFactory = cboProvider.Text.Trim();
try {
m_provider = DbProviderFactories.GetFactory(sFactory);
}
catch (Exception ex) {
OutLog(ex.Message);
MessageBox.Show(this, ex.ToString(), this.Text, MessageBoxButtons.OK, MessageBoxIcon.Error);
return;
}
if (null == m_provider) return;
try {
// DbConnection.
try {
OutLog("Create DbConnection:");
m_conn = m_provider.CreateConnection();
OutLog(string.Format("\t{0}", m_conn.GetType().ToString()));
}
catch (Exception ex) {
OutLog(ex.Message);
MessageBox.Show(this, ex.ToString(), this.Text, MessageBoxButtons.OK, MessageBoxIcon.Error);
try {
m_conn.Dispose();
}
catch (Exception ex2) {
OutLog(ex2.ToString());
}
m_conn = null;
return;
}
if (null == m_conn) return;
// open.
try {
m_conn.ConnectionString = txtConnstr.Text.Trim();
m_conn.Open();
}
catch (Exception ex) {
OutLog(ex.Message);
MessageBox.Show(this, ex.ToString(), this.Text, MessageBoxButtons.OK, MessageBoxIcon.Error);
try {
m_conn.Dispose();
}
catch (Exception ex2) {
OutLog(ex2.ToString());
}
m_conn = null;
return;
}
}
finally {
if (null == m_conn) {
m_provider = null;
}
}
// done.
bool isconn = true;
btnOpen.Enabled = !isconn;
btnClose.Enabled = isconn;
btnExec.Enabled = isconn;
cboProvider.Enabled = !isconn;
txtConnstr.ReadOnly = isconn;
OutLog("Db opened.");
// show tables.
DataTable dt = m_conn.GetSchema("Tables");
grdTable.DataSource = dt;
m_CurTableName = null;
tbcInput.SelectedIndex = 1;
}
protected override DataTable StoredProcedureArguments(string storedProcedureName, DbConnection connection)
{
//for latest Devart (8.4.254.0, possibly some earlier versions)
//the GetSchema for ALL_ARGUMENTS doesn't get package parameters unless specified
//Devart.Data.Oracle.a4, method m
if (connection.GetType().FullName.StartsWith("Devart", StringComparison.OrdinalIgnoreCase))
{
//don't filter by package. This is approximately the same as System.Data.OracleClient
const string sqlCommand = @"SELECT
OWNER, PACKAGE_NAME, OBJECT_NAME, ARGUMENT_NAME, POSITION, SEQUENCE, DEFAULT_VALUE, DEFAULT_LENGTH,
IN_OUT, DATA_LENGTH, DATA_PRECISION, DATA_SCALE , DATA_TYPE
FROM ALL_ARGUMENTS
WHERE
(OWNER= :schemaOwner OR :schemaOwner is null) AND
(OBJECT_NAME = :PROCEDURENAME OR :PROCEDURENAME is null)";
var dt = CreateDataTable("Arguments");
using (DbDataAdapter da = Factory.CreateDataAdapter())
{
using (DbCommand cmd = connection.CreateCommand())
{
cmd.CommandText = sqlCommand;
EnsureOracleBindByName(cmd);
cmd.Parameters.Add(
AddDbParameter("schemaOwner", Owner));
cmd.Parameters.Add(
AddDbParameter("PROCEDURENAME", storedProcedureName));
da.SelectCommand = cmd;
da.Fill(dt);
}
}
return dt;
}
return base.StoredProcedureArguments(storedProcedureName, connection);
}
public static ISqlDialect For(DbConnection connection)
{
string connectionName = connection.GetType().Name.ToLower();
ISqlDialect dialect = null;
if (!SqlDialects.TryGetValue(connectionName, out dialect))
{
throw new ArgumentException("Unknown connection name: " + connectionName);
}
return dialect;
}
internal static void Run(DbProviderFactory fact, DbConnection cnn)
{
Console.WriteLine("\r\nBeginning Test on " + cnn.GetType().ToString());
try { CreateTable(cnn); Console.WriteLine("SUCCESS - CreateTable"); }
catch (Exception) { Console.WriteLine("FAIL - CreateTable"); }
try { TransactionTest(cnn); Console.WriteLine("SUCCESS - Transaction Enlistment"); }
catch (Exception) { Console.WriteLine("FAIL - Transaction Enlistment"); }
try { GuidTest(cnn); Console.WriteLine("SUCCESS - Guid Test"); }
catch (Exception) { Console.WriteLine("FAIL - Guid Test"); }
try { InsertTable(cnn); Console.WriteLine("SUCCESS - InsertTable"); }
catch (Exception) { Console.WriteLine("FAIL - InsertTable"); }
try { VerifyInsert(cnn); Console.WriteLine("SUCCESS - VerifyInsert"); }
catch (Exception) { Console.WriteLine("FAIL - VerifyInsert"); }
try { CoersionTest(cnn); Console.WriteLine("FAIL - CoersionTest"); }
catch (Exception) { Console.WriteLine("SUCCESS - CoersionTest"); }
try { ParameterizedInsert(cnn); Console.WriteLine("SUCCESS - ParameterizedInsert"); }
catch (Exception) { Console.WriteLine("FAIL - ParameterizedInsert"); }
try { BinaryInsert(cnn); Console.WriteLine("SUCCESS - BinaryInsert (using named parameter)"); }
catch (Exception) { Console.WriteLine("FAIL - BinaryInsert"); }
try { VerifyBinaryData(cnn); Console.WriteLine("SUCCESS - VerifyBinaryData"); }
catch (Exception) { Console.WriteLine("FAIL - VerifyBinaryData"); }
try { LockTest(cnn); Console.WriteLine("SUCCESS - LockTest"); }
catch (Exception) { Console.WriteLine("FAIL - LockTest"); }
try { ParameterizedInsertMissingParams(cnn); Console.WriteLine("FAIL - ParameterizedInsertMissingParams\r\n"); }
catch (Exception) { Console.WriteLine("SUCCESS - ParameterizedInsertMissingParams\r\n"); }
// try { TimeoutTest(cnn); Console.WriteLine("SUCCESS - TimeoutTest"); }
// catch (Exception) { Console.WriteLine("FAIL - TimeoutTest"); }
try { DataAdapter(fact, cnn, false); Console.WriteLine(""); }
catch (Exception) { Console.WriteLine("FAIL - DataAdapter"); }
try { DataAdapter(fact, cnn, true); Console.WriteLine(""); }
catch (Exception) { Console.WriteLine("FAIL - DataAdapterWithIdentityFetch"); }
try { FastInsertMany(cnn); Console.WriteLine(""); }
catch (Exception) { Console.WriteLine("FAIL - FastInsertMany"); }
try { IterationTest(cnn); Console.WriteLine(""); }
catch (Exception) { Console.WriteLine("FAIL - Iteration Test"); }
try { UserFunction(cnn); Console.WriteLine(""); }
catch (Exception) { Console.WriteLine("FAIL - UserFunction"); }
try { UserAggregate(cnn); Console.WriteLine(""); }
catch (Exception) { Console.WriteLine("FAIL - UserAggregate"); }
try { UserCollation(cnn); Console.WriteLine("SUCCESS - UserCollation"); }
catch (Exception) { Console.WriteLine("FAIL - UserCollation"); }
try { DropTable(cnn); Console.WriteLine("SUCCESS - DropTable"); }
catch (Exception) { Console.WriteLine("FAIL - DropTable"); }
Console.WriteLine("\r\nTests Finished.");
}
/// <summary>
/// Retrieve the DbProviderFactory based on the specified DbConnection
/// </summary>
/// <param name="connection"> The DbConnection to use </param>
/// <returns> An instance of DbProviderFactory </returns>
public static DbProviderFactory GetProviderFactory(DbConnection connection)
{
Contract.Requires(connection != null);
var factory = DbProviderFactories.GetFactory(connection);
if (factory == null)
{
throw new ProviderIncompatibleException(
Strings.EntityClient_ReturnedNullOnProviderMethod(
"get_ProviderFactory",
connection.GetType().ToString()));
}
Contract.Assert(factory != null, "Should have thrown on null");
return factory;
}
private void CreateDBConnectionFieldAndProperty (CodeTypeDeclaration t, DbConnection conn)
{
CodeExpression expr;
CodeStatement setStmt;
CodeStatement stmt;
CodeMemberField f = new CodeMemberField ();
f.Name = "_connection";
f.Type = TypeRef (conn.GetType ());
t.Members.Add (f);
CodeMemberProperty p = new CodeMemberProperty ();
p.Name = "Connection";
p.Attributes = MemberAttributes.Assembly;
p.Type = f.Type;
expr = FieldRef ("_connection");
setStmt = Eval (MethodInvoke ("InitConnection"));
stmt = new CodeConditionStatement (Equals (expr, Const (null)),
new CodeStatement [] {setStmt},
new CodeStatement [] {});
p.GetStatements.Add (stmt);
p.GetStatements.Add (Return (expr));
p.SetStatements.Add (Let (expr, new CodePropertySetValueReferenceExpression()));
// update connection in Insert/Delete/Update commands of adapter
// insert command
string cmdStr = "InsertCommand";
string connStr = "Connection";
setStmt = null;
stmt = null;
expr = null;
expr = PropRef (PropRef ("Adapter"), cmdStr);
setStmt = Let (PropRef (expr, connStr), new CodePropertySetValueReferenceExpression());
stmt = new CodeConditionStatement (Inequals (expr, Const (null)),
new CodeStatement [] {setStmt},
new CodeStatement [] {});
p.SetStatements.Add (stmt);
// delete command
setStmt = null;
stmt = null;
expr = null;
cmdStr = "DeleteCommand";
expr = PropRef (PropRef ("Adapter"), cmdStr);
setStmt = Let (PropRef (expr, connStr), new CodePropertySetValueReferenceExpression());
stmt = new CodeConditionStatement (Inequals (expr, Const (null)),
new CodeStatement [] {setStmt}, new CodeStatement [] {});
p.SetStatements.Add (stmt);
// update command
setStmt = null;
stmt = null;
cmdStr = "UpdateCommand";
expr = PropRef (PropRef ("Adapter"), cmdStr);
setStmt = Let (PropRef (expr, connStr), new CodePropertySetValueReferenceExpression());
stmt = new CodeConditionStatement (Inequals (expr, Const (null)),
new CodeStatement [] {setStmt}, new CodeStatement [] {});
p.SetStatements.Add (stmt);
// iterate through command collection and update it
setStmt = null;
expr = null;
stmt = null;
setStmt = VarDecl (typeof (int), "i", Const (0));
expr = LessThan (Local ("i"), PropRef (PropRef ("CommandCollection"), "Length"));
stmt = Let (Local ("i"), Compute (Local ("i"), Const (1), CodeBinaryOperatorType.Add));
// statements to execute in the loop
CodeExpression expr1 = IndexerRef (PropRef ("CommandCollection"), Local ("i"));
CodeStatement setStmt1 = Let (PropRef (expr1, "Connection"), new CodePropertySetValueReferenceExpression());
CodeStatement stmt1 = new CodeConditionStatement (Inequals (expr1, Const (null)),
new CodeStatement [] {setStmt1}, new CodeStatement [] {});
CodeIterationStatement forLoop = new CodeIterationStatement (setStmt, expr, stmt,
new CodeStatement[] {stmt1});
p.SetStatements.Add (forLoop);
t.Members.Add (p);
}
//
// : IDbTransaction
//
static internal Exception ParallelTransactionsNotSupported(DbConnection obj)
{
return InvalidOperation(Res.GetString(Res.ADP_ParallelTransactionsNotSupported, obj.GetType().Name));
}
/// <summary>
/// Retrieve the DbProviderFactory based on the specified DbConnection
/// </summary>
/// <param name="connection">The DbConnection to use</param>
/// <returns>An instance of DbProviderFactory</returns>
public static DbProviderFactory GetProviderFactory(DbConnection connection)
{
EntityUtil.CheckArgumentNull(connection, "connection");
DbProviderFactory factory = DbProviderFactories.GetFactory(connection);
if (factory == null)
{
throw EntityUtil.ProviderIncompatible(System.Data.Entity.Strings.EntityClient_ReturnedNullOnProviderMethod(
"get_ProviderFactory",
connection.GetType().ToString()));
}
Debug.Assert(factory != null, "Should have thrown on null");
return factory;
}
/// <summary>
/// 关闭连接
/// </summary>
/// <param name="connection"></param>
public static void CloseConnection(DbConnection connection)
{
if (connection != null && connection.State != ConnectionState.Closed)
{
connection.Close();
if (connection.GetType().FullName.Equals("System.Data.SqlClient.SqlConnection"))
{
ExcelUtility.sqlConnection.Dispose();
ExcelUtility.sqlConnectionString = String.Empty;
}
else if (connection.GetType().FullName.Equals("System.Data.OleDb.OleDbConnection"))
{
ExcelUtility.oleConnection.Dispose();
ExcelUtility.oleConnectionString = String.Empty;
}
}
}
public DbProviderFactory GetProviderFactory(DbConnection connection)
{
return connection.GetType().FullName.StartsWith("Castle.Proxies.")
? (DbProviderFactory)_factoryProperty.GetValue(connection, null)
: _originalProviderFactoryService.GetProviderFactory(connection);
}
public DbProviderFactory GetProviderFactory(DbConnection cx)
{
if (cx == null)
{
return this.GetProviderFactory();
}
PropertyInfo property = cx.GetType().GetProperty("DbProviderFactory", BindingFlags.NonPublic | BindingFlags.Instance);
if (property == null)
{
return this.GetProviderFactory();
}
try
{
return (((DbProviderFactory) property.GetValue(cx, null)) ?? this.GetProviderFactory());
}
catch
{
return this.GetProviderFactory();
}
}