albert/kreta
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity

init

Browse source
This commit is contained in:
skidoodle 2024-03-13 00:33:46 +01:00
commit e124a47765
19374 changed files with 9806149 additions and 0 deletions
Download patch file Download diff file Expand all files Collapse all files

31
Sda.DataProvider/CommandExecutedEventArgs.cs Normal file
View file

@ -0,0 +1,31 @@
using System;
namespace SDA.DataProvider
{
/// <summary>
/// Adatbázis-parancs végrehastása után kiváltodó esemény argumentum osztálya.
/// </summary>
public class CommandExecutedEventArgs : EventArgs
{
/// <summary>
/// Létrehoz egy új <see cref="CommandExecutedEventArgs"/> objektum példányt.
/// </summary>
/// <param name="executionTime">A párancs futási ideje</param>
/// <param name="executionType">A végrehajtás típusa</param>
public CommandExecutedEventArgs(TimeSpan executionTime, ExecutionType executionType)
{
ExecutionTime = executionTime;
ExecutionType = executionType;
}
/// <summary>
/// A párancs futási ideje
/// </summary>
public TimeSpan ExecutionTime { get; }
/// <summary>
/// A végrehajtás típusa
/// </summary>
public ExecutionType ExecutionType { get; }
}
}

28
Sda.DataProvider/Configuration.cs Normal file
View file

@ -0,0 +1,28 @@
using System.Diagnostics.CodeAnalysis;
namespace SDA.DataProvider
{
/// <summary>
/// Általános működési beállítások.
/// </summary>
[SuppressMessage("Microsoft.Naming", "CA1724:TypeNamesShouldNotMatchNamespaces")]
public static class Configuration
{
/// <summary>
/// Hiba esetén próbálkozzon-e újból a szolgáltató?
/// </summary>
[SuppressMessage("Microsoft.Usage", "CA2211:NonConstantFieldsShouldNotBeVisible")]
public static bool ErrorRecovery = false;
/// <summary>
/// Ismételt próbálkozások száma.
/// </summary>
[SuppressMessage("Microsoft.Usage", "CA2211:NonConstantFieldsShouldNotBeVisible")]
public static int MaxTries = 10;
/// <summary>
/// Új csatlakozás esetén hány másodpercig várjon a Connection Pool szolgáltatásra, mielőtt hibával elszáll
/// </summary>
public static int? ConnectionTimeout { get; set; }
}
}

25
Sda.DataProvider/Core/SDACommandBuilderWrapper.cs Normal file
View file

@ -0,0 +1,25 @@
using System;
namespace SDA.DataProvider.Core
{
public abstract class SDACommandBuilderWrapper : IDisposable
{
protected abstract SDADataAdapterWrapper DataAdapter
{
get;
set;
}
public abstract void DeriveParameters(SDACommandWrapper command);
public abstract SDACommandWrapper GetDeleteCommand();
public abstract SDACommandWrapper GetInsertCommand();
public abstract SDACommandWrapper GetUpdateCommand();
public abstract void RefreshSchema();
#region IDisposable Members
public abstract void Dispose();
#endregion
}
}

161
Sda.DataProvider/Core/SDACommandParameterCollectionWrapper.cs Normal file
View file

@ -0,0 +1,161 @@
using System;
using System.Data;
namespace SDA.DataProvider.Core
{
public abstract class SDACommandParameterCollectionWrapper : IDataParameterCollection
{
public abstract SDACommandParameterWrapper Add(SDACommandParameterWrapper parameter);
public abstract SDACommandParameterWrapper Add(string name, SDADBType type);
public abstract SDACommandParameterWrapper Add(string name, SDADBType type, int size);
public abstract SDACommandParameterWrapper Add(string name, object value);
public abstract void Remove(SDACommandParameterWrapper parameter);
public abstract bool Contains(SDACommandParameterWrapper parameter);
public abstract int IndexOf(SDACommandParameterWrapper parameter);
public abstract void Clear();
public abstract int Count
{
get;
}
public abstract SDACommandParameterWrapper this[string name]
{
get;
set;
}
public abstract SDACommandParameterWrapper this[int index]
{
get;
set;
}
public int IndexOf(string parameterName)
{
return IndexOf(this[parameterName]);
}
public bool Contains(string parameterName)
{
return Contains(this[parameterName]);
}
public void RemoveAt(string parameterName)
{
Remove(this[parameterName]);
}
public void RemoveAt(int index)
{
Remove(this[index]);
}
#region IDataParameterCollection Members
object IDataParameterCollection.this[string parameterName]
{
get
{
return this[parameterName];
}
set
{
this[parameterName] = (SDACommandParameterWrapper)value;
}
}
#endregion
#region IList Members
bool System.Collections.IList.IsReadOnly
{
get
{
return false;
}
}
object System.Collections.IList.this[int index]
{
get
{
return this[index];
}
set
{
this[index] = (SDACommandParameterWrapper)value;
}
}
void System.Collections.IList.Insert(int index, object value)
{
throw new NotImplementedException();
}
void System.Collections.IList.Remove(object value)
{
Remove((SDACommandParameterWrapper)value);
}
bool System.Collections.IList.Contains(object value)
{
return Contains((SDACommandParameterWrapper)value);
}
int System.Collections.IList.IndexOf(object value)
{
return IndexOf((SDACommandParameterWrapper)value);
}
int System.Collections.IList.Add(object value)
{
return IndexOf(Add((SDACommandParameterWrapper)value));
}
bool System.Collections.IList.IsFixedSize
{
get
{
return false;
}
}
#endregion
#region ICollection Members
bool System.Collections.ICollection.IsSynchronized
{
get
{
return false;
}
}
void System.Collections.ICollection.CopyTo(Array array, int index)
{
throw new NotImplementedException();
}
object System.Collections.ICollection.SyncRoot
{
get
{
throw new NotImplementedException();
}
}
#endregion
#region IEnumerable Members
public virtual System.Collections.IEnumerator GetEnumerator()
{
throw new NotImplementedException();
}
#endregion
}
}

136
Sda.DataProvider/Core/SDACommandParameterWrapper.cs Normal file
View file

@ -0,0 +1,136 @@
using System;
using System.Data;
namespace SDA.DataProvider.Core
{
public abstract class SDACommandParameterWrapper : IDbDataParameter
{
public abstract SDADBType DBType { get; set; }
protected abstract IDbDataParameter WrappedParameter { get; }
#region IDataParameter Members
DbType IDataParameter.DbType
{
get
{
throw new NotImplementedException();
}
set
{
throw new NotImplementedException();
}
}
public virtual ParameterDirection Direction
{
get
{
return WrappedParameter.Direction;
}
set
{
WrappedParameter.Direction = value;
}
}
public virtual bool IsNullable
{
get
{
return WrappedParameter.IsNullable;
}
}
public virtual string ParameterName
{
get
{
return WrappedParameter.ParameterName;
}
set
{
WrappedParameter.ParameterName = value;
}
}
public virtual string SourceColumn
{
get
{
return WrappedParameter.SourceColumn;
}
set
{
WrappedParameter.SourceColumn = value;
}
}
public virtual DataRowVersion SourceVersion
{
get
{
return WrappedParameter.SourceVersion;
}
set
{
WrappedParameter.SourceVersion = value;
}
}
public virtual object Value
{
get
{
return WrappedParameter.Value;
}
set
{
WrappedParameter.Value = value;
}
}
#endregion
#region IDbDataParameter Members
public virtual byte Precision
{
get
{
return WrappedParameter.Precision;
}
set
{
WrappedParameter.Precision = value;
}
}
public virtual byte Scale
{
get
{
return WrappedParameter.Scale;
}
set
{
WrappedParameter.Scale = value;
}
}
public virtual int Size
{
get
{
return WrappedParameter.Size;
}
set
{
WrappedParameter.Size = value;
}
}
#endregion
}
}

167
Sda.DataProvider/Core/SDACommandWrapper.cs Normal file
View file

@ -0,0 +1,167 @@
using System;
using System.Data;
using System.Diagnostics.CodeAnalysis;
using JetBrains.Annotations;
namespace SDA.DataProvider.Core
{
public abstract class SDACommandWrapper : IDbCommand
{
[CanBeNull]
public abstract SDAConnectionWrapper Connection { get; set; }
[CanBeNull]
public abstract SDATransactionWrapper Transaction { get; set; }
[NotNull]
public abstract SDADataReaderWrapper ExecuteReader();
[NotNull]
public abstract SDADataReaderWrapper ExecuteReader(CommandBehavior commandBehavior);
[NotNull]
public abstract SDACommandParameterCollectionWrapper Parameters { get; }
[NotNull]
protected abstract IDbCommand WrappedCommand { get; }
#region IDisposable Members
bool _disposed;
protected virtual void Dispose(bool disposing)
{
if (_disposed)
{
return;
}
_disposed = true;
}
public void Dispose()
{
Dispose(true);
GC.SuppressFinalize(this);
}
#endregion
#region IDbCommand Members
[SuppressMessage("Microsoft.Security", "CA2100:Review SQL queries for security vulnerabilities")]
[CanBeNull]
public virtual string CommandText
{
get
{
return WrappedCommand.CommandText;
}
set
{
WrappedCommand.CommandText = value;
}
}
public virtual int CommandTimeout
{
get
{
return WrappedCommand.CommandTimeout;
}
set
{
WrappedCommand.CommandTimeout = value;
}
}
public virtual CommandType CommandType
{
get
{
return WrappedCommand.CommandType;
}
set
{
WrappedCommand.CommandType = value;
}
}
[CanBeNull]
IDbConnection IDbCommand.Connection
{
get
{
return Connection;
}
set
{
Connection = (SDAConnectionWrapper)value;
}
}
[NotNull]
IDataParameterCollection IDbCommand.Parameters
{
get
{
throw new NotSupportedException();
}
}
[CanBeNull]
IDbTransaction IDbCommand.Transaction
{
get
{
return Transaction;
}
set
{
Transaction = (SDATransactionWrapper)value;
}
}
public virtual UpdateRowSource UpdatedRowSource
{
get
{
return WrappedCommand.UpdatedRowSource;
}
set
{
WrappedCommand.UpdatedRowSource = value;
}
}
public virtual void Cancel()
{
WrappedCommand.Cancel();
}
public virtual IDbDataParameter CreateParameter()
{
return WrappedCommand.CreateParameter();
}
public abstract int ExecuteNonQuery();
IDataReader IDbCommand.ExecuteReader()
{
return ExecuteReader();
}
IDataReader IDbCommand.ExecuteReader(CommandBehavior behavior)
{
return ExecuteReader(behavior);
}
public abstract object ExecuteScalar();
public virtual void Prepare()
{
WrappedCommand.Prepare();
}
#endregion
}
}

99
Sda.DataProvider/Core/SDAConnectionWrapper.cs Normal file
View file

@ -0,0 +1,99 @@
using System.Data;
using System.Data.SqlClient;
using JetBrains.Annotations;
namespace SDA.DataProvider.Core
{
public abstract class SDAConnectionWrapper : IDbConnection
{
[NotNull]
public abstract SDACommandWrapper CreateCommand();
/// <summary>
/// Létrehoz egy <see cref="SDABulkAdapter"/>-t nagyon gyors adatbeszúrásokhoz.
/// </summary>
/// <param name="transaction">
/// Opcionális <see cref="SDATransaction"/> objektum, ha nincs megadva, akkor a bulk
/// művelet _nem_ fut tranzakcióban, azaz ha megáll egy hiba miatt,
/// akkor a már beszúrt sorok nem görgetődnek vissza!
/// </param>
/// <returns>
/// Egy új <see cref="SDABulkAdapter"/>.
/// </returns>
[NotNull]
public abstract SDABulkAdapter CreateBulkAdapter(SDATransaction transaction = null);
/// <summary>
/// Üresre törli az adatbázis-szerver connection pool-ját.
/// </summary>
/// <param name="all">
/// True érték esetén az összes pool-t alaphelyzetbe hozza,
/// False érték esetén csak az adott kapcsolathoz tartozót.
/// </param>
public abstract void ResetConnectionPool(bool all = false);
[NotNull]
public abstract SDATransactionWrapper BeginTransaction();
[NotNull]
public abstract SDATransactionWrapper BeginTransaction(IsolationLevel isolationLevel);
[NotNull]
protected abstract IDbConnection WrappedConnection { get; }
public SqlConnection SqlConnection
{
get { return (SqlConnection)WrappedConnection; }
}
#region IDisposable Members
public abstract void Dispose();
#endregion
#region IDbConnection Members
[CanBeNull]
public abstract string ConnectionString { get; set; }
public abstract int ConnectionTimeout { get; }
[CanBeNull]
public virtual string Database => WrappedConnection.Database;
public virtual ConnectionState State => WrappedConnection.State;
[NotNull]
IDbTransaction IDbConnection.BeginTransaction(IsolationLevel il)
{
return BeginTransaction(il);
}
[NotNull]
IDbTransaction IDbConnection.BeginTransaction()
{
return BeginTransaction();
}
public abstract void ChangeDatabase(string databaseName);
public virtual void Close()
{
WrappedConnection.Close();
}
IDbCommand IDbConnection.CreateCommand()
{
return CreateCommand();
}
public virtual void Open()
{
WrappedConnection.Open();
}
#endregion
}
}

108
Sda.DataProvider/Core/SDADataAdapterWrapper.cs Normal file
View file

@ -0,0 +1,108 @@
using System;
using System.Data;
using System.Data.Common;
namespace SDA.DataProvider.Core
{
public abstract class SDADataAdapterWrapper : IDisposable, IDbDataAdapter
{
public abstract SDACommandWrapper DeleteCommand { get; set; }
public abstract SDACommandWrapper InsertCommand { get; set; }
public abstract SDACommandWrapper SelectCommand { get; set; }
public abstract SDACommandWrapper UpdateCommand { get; set; }
public abstract DataTableMappingCollection TableMappings { get; }
public abstract bool AcceptChangesDuringFill { get; set; }
public abstract bool ContinueUpdateOnError { get; set; }
public abstract int Fill(DataTable dataTable);
public abstract int Fill(DataSet dts, int startRecord, int endRecord, string srcTable);
public abstract DataTable FillSchema(DataTable dataTable, SchemaType schemaType);
public abstract DataTable[] FillSchema(DataSet dataSet, SchemaType schemaType, string srcTable);
public abstract int Update(DataRow[] dataRows);
public abstract int Update(DataTable dataTable);
#region IDisposable Members
public abstract void Dispose();
#endregion
#region IDbDataAdapter Members
IDbCommand IDbDataAdapter.UpdateCommand
{
get
{
return UpdateCommand;
}
set
{
UpdateCommand = (SDACommandWrapper)value;
}
}
IDbCommand IDbDataAdapter.SelectCommand
{
get
{
return SelectCommand;
}
set
{
SelectCommand = (SDACommandWrapper)value;
}
}
IDbCommand IDbDataAdapter.DeleteCommand
{
get
{
return DeleteCommand;
}
set
{
DeleteCommand = (SDACommandWrapper)value;
}
}
IDbCommand IDbDataAdapter.InsertCommand
{
get
{
return InsertCommand;
}
set
{
InsertCommand = (SDACommandWrapper)value;
}
}
#endregion
#region IDataAdapter Members
public abstract MissingMappingAction MissingMappingAction { get; set; }
public abstract MissingSchemaAction MissingSchemaAction { get; set; }
ITableMappingCollection IDataAdapter.TableMappings
{
get
{
return TableMappings;
}
}
public abstract int Fill(DataSet dataSet);
public abstract DataTable[] FillSchema(DataSet dataSet, SchemaType schemaType);
public IDataParameter[] GetFillParameters()
{
throw new NotImplementedException();
}
public abstract int Update(DataSet dataSet);
#endregion
}
}

119
Sda.DataProvider/Core/SDADataReaderWrapper.cs Normal file
View file

@ -0,0 +1,119 @@
using System;
using System.Data;
namespace SDA.DataProvider.Core
{
public abstract class SDADataReaderWrapper : IDataReader
{
protected abstract IDataReader WrappedDataReader { get; }
#region IDisposable Members
protected abstract void Dispose(bool disposing);
public void Dispose()
{
Dispose(true);
GC.SuppressFinalize(this);
}
#endregion
#region IDataReader Members
public int Depth
{
get
{
return WrappedDataReader.Depth;
}
}
public bool IsClosed
{
get
{
return WrappedDataReader.IsClosed;
}
}
public int RecordsAffected
{
get
{
return WrappedDataReader.RecordsAffected;
}
}
public abstract void Close();
public abstract DataTable GetSchemaTable();
public abstract bool NextResult();
public abstract bool Read();
#endregion
#region IDataRecord Members
public abstract int FieldCount { get; }
public abstract object this[string name] { get; }
public abstract object this[int index] { get; }
public abstract bool GetBoolean(int index);
public abstract byte GetByte(int index);
public long GetBytes(int i, long fieldOffset, byte[] buffer, int bufferoffset, int length)
{
throw new NotImplementedException();
}
public abstract char GetChar(int index);
public long GetChars(int i, long fieldoffset, char[] buffer, int bufferoffset, int length)
{
throw new NotImplementedException();
}
public IDataReader GetData(int i)
{
throw new NotImplementedException();
}
public string GetDataTypeName(int i)
{
throw new NotImplementedException();
}
public abstract DateTime GetDateTime(int index);
public abstract decimal GetDecimal(int index);
public abstract double GetDouble(int index);
public Type GetFieldType(int i)
{
throw new NotImplementedException();
}
public float GetFloat(int i)
{
throw new NotImplementedException();
}
public abstract short GetInt16(int index);
public abstract int GetInt32(int index);
public abstract long GetInt64(int index);
public string GetName(int i)
{
throw new NotImplementedException();
}
public abstract Guid GetGuid(int i);
public abstract int GetOrdinal(string filedname);
public abstract string GetString(int index);
public abstract object GetValue(int index);
public abstract int GetValues(object[] values);
public abstract bool IsDBNull(int index);
public abstract string GetLongString(int index);
#endregion
}
}

87
Sda.DataProvider/Core/SDAFactory.cs Normal file
View file

@ -0,0 +1,87 @@
using System;
using System.Globalization;
using JetBrains.Annotations;
using SDA.DataProvider.Core;
namespace SDA.DataProvider
{
/// <summary>
/// Az databázis-kiszolgálóval való működéshez szükséges osztálygyár.
/// </summary>
public abstract class SDAFactory
{
/// <summary>
/// SDAFactory konstruktora.
/// </summary>
/// <param name="commandTimeout">Command alapértelmezett timeout-ja.</param>
public SDAFactory(int? commandTimeout)
{
CommandTimeout = commandTimeout;
}
private const bool UseOptimizations = false;
//ORA bulk insert (arrray dml) impl. needed
public bool UseOptimizedDataAccessLayer { get; set; } = UseOptimizations;
//ORA work needed to create a range sequence sp
public bool UseOptimizedIdGeneration { get; set; } = UseOptimizations;
//ORA ok
public bool UseOptimizedPrintName { get; set; } = UseOptimizations;
//ORA ok
public bool UseOptimizedOrgName { get; set; } = UseOptimizations;
//ORA ?
public bool UseOptimizedUpdateIratState { get; set; } = UseOptimizations;
//ORA ?
public bool UseOptimizedUserHandling { get; set; } = UseOptimizations;
//ORA ?
public bool UseOptimizedInteriorOrganizationHandling { get; set; } = UseOptimizations;
public bool UseOptimizedEntityCache { get; set; } = UseOptimizations;
/// <summary>
/// Általános command-k alapértelmezett timeout paramétere. Egy sql művelet hány másodpercig tartson.
///
/// Nem kötelező. Jelenleg MSSQL 300 sec-re van állítva, Oracle nincs beállítva.
/// </summary>
public int? CommandTimeout { get; internal set; }
[NotNull]
internal abstract SDAConnectionWrapper CreateConnection();
[NotNull]
internal abstract SDACommandWrapper CreateCommand();
[NotNull]
internal abstract SDADataAdapterWrapper CreateDataAdapter();
[NotNull]
internal abstract SDACommandBuilderWrapper CreateCommandBuilder();
[NotNull]
internal abstract SDACommandBuilderWrapper CreateCommandBuilder([NotNull] SDADataAdapterWrapper dataAdapter);
/// <summary>
/// Az adatbázis-kiszolgáló specifikus osztálygyár példány.
/// </summary>
[CanBeNull]
public static SDAFactory Instance { get; set; }
[NotNull]
internal static SDAFactory GetByDatabaseType(DatabaseType databaseType, int? commandTimeout)
{
switch (databaseType)
{
case DatabaseType.NativeMSSQL:
return new Factories.MSSQLFactory(commandTimeout);
default:
throw new NotSupportedException(string.Format(CultureInfo.InvariantCulture, "Database '{0}' not supported.", databaseType));
}
}
}
}

32
Sda.DataProvider/Core/SDATransactionWrapper.cs Normal file
View file

@ -0,0 +1,32 @@
using System.Data;
namespace SDA.DataProvider.Core
{
public abstract class SDATransactionWrapper : IDbTransaction
{
public abstract SDAConnectionWrapper Connection { get; }
internal abstract IDbTransaction NativeTransaction { get; }
#region IDisposable Members
public abstract void Dispose();
#endregion
#region IDbTransaction Members
IDbConnection IDbTransaction.Connection
{
get
{
return Connection;
}
}
public abstract IsolationLevel IsolationLevel { get; }
public abstract void Commit();
public abstract void Rollback();
#endregion
}
}

18
Sda.DataProvider/DatabaseType.cs Normal file
View file

@ -0,0 +1,18 @@
namespace SDA.DataProvider
{
/// <summary>
/// Adatbázis-típusok
/// </summary>
public enum DatabaseType
{
/// <summary>
/// Ismeretlen.
/// </summary>
Unknown = 0,
/// <summary>
/// System.Data.SqlClient névtér
/// </summary>
NativeMSSQL = 21,
}
}

469
Sda.DataProvider/Exceptions.cs Normal file
View file

@ -0,0 +1,469 @@
using System;
using System.Globalization;
using System.Runtime.Serialization;
namespace SDA.DataProvider
{
/// <summary>
/// Hibakódok
/// </summary>
public enum SDADataProviderError
{
/// <summary>
/// Ismeretlen hiba
/// </summary>
Unknown,
/// <summary>
/// Egyedi kulcs megsértése
/// </summary>
UniqueKeyViolation,
/// <summary>
/// Idegen kulcs megsértése
/// </summary>
ForeignKeyViolation,
/// <summary>
/// A tábla vagy nézet nem létezik
/// </summary>
TableOrViewNotExists,
/// <summary>
/// Érvénytelen oszlopnév
/// </summary>
InvalidColumnName,
/// <summary>
/// Null érték nem beszúrható
/// </summary>
CannotInsertNull,
/// <summary>
/// Adatbázis-kapcsolati hiba
/// </summary>
CommunicationError,
/// <summary>
/// Táblaterekkel, rendelkezésre álló hellyel kapcsolatos hiba
/// </summary>
TableSpaceError,
/// <summary>
/// Deadlock történt
/// </summary>
DeadlockDetected,
/// <summary>
/// Adatbázis művelet időtúllépés történt
/// </summary>
CommandTimeout
}
/// <summary>
/// Adatbázis hibát jelző kivétel.
/// </summary>
[Serializable]
public class SDADataProviderException : Exception
{
const string DefaultMessage = "SQL error!";
const string DefaultCommand = "";
const int DefaultDatabaseNumber = -1;
readonly string _commandText = DefaultCommand;
/// <summary>
/// Mező annak jelzésére, hogy a művelet végrehajtását célszerű-e
/// újra megpróbálni, mielőtt a kivételt továbbdobjuk.
/// </summary>
internal readonly bool MustRetry = false;
/// <summary>
/// Hibakód.
/// </summary>
public SDADataProviderError Error { get; protected set; }
/// <summary>
/// Az eredeti - adatbázisfüggő - hibakód.
/// </summary>
public int DatabaseSpecificNumber { get; protected set; }
/// <summary>
/// Szabványos konstruktor.
/// </summary>
public SDADataProviderException()
: base(DefaultMessage)
{
Error = SDADataProviderError.Unknown;
DatabaseSpecificNumber = DefaultDatabaseNumber;
}
/// <summary>
/// Szabványos konstruktor.
/// </summary>
public SDADataProviderException(string message)
: base(message ?? DefaultMessage)
{
Error = SDADataProviderError.Unknown;
DatabaseSpecificNumber = DefaultDatabaseNumber;
}
/// <summary>
/// Szabványos konstruktor.
/// </summary>
public SDADataProviderException(string message, Exception innerException)
: base(message ?? DefaultMessage, innerException)
{
Error = SDADataProviderError.Unknown;
DatabaseSpecificNumber = DefaultDatabaseNumber;
}
internal SDADataProviderException(Exception innerException)
: this(innerException == null ? DefaultMessage : innerException.Message, innerException) { }
/// <summary>
/// Szabványos konstruktor.
/// </summary>
protected SDADataProviderException(SerializationInfo info, StreamingContext context)
: base(info, context)
{
if (info == null)
{
throw new ArgumentNullException(nameof(info));
}
Error = (SDADataProviderError)info.GetValue("Error", typeof(SDADataProviderError));
DatabaseSpecificNumber = info.GetInt32("DatabaseSpecificNumber");
MustRetry = info.GetBoolean("MustRetry");
}
internal SDADataProviderException(Exception innerException, SDADataProviderError error, int number, bool mustRetry, string commandText)
: this(innerException == null ? DefaultMessage : innerException.Message, innerException)
{
Error = error;
DatabaseSpecificNumber = number;
MustRetry = mustRetry;
_commandText = commandText ?? DefaultCommand;
}
internal SDADataProviderException(Exception innerException, SDADataProviderError error, string commandText)
: this(innerException, error, DefaultDatabaseNumber, false, commandText) { }
internal SDADataProviderException(Exception innerException, SDADataProviderError error, int number, string commandText)
: this(innerException, error, number, false, commandText) { }
internal SDADataProviderException(Exception innerException, SDADataProviderError error, int number, bool mustRetry)
: this(innerException, error, number, mustRetry, DefaultCommand) { }
/// <summary>
/// A kivétel üzenete.
/// </summary>
public override string Message
{
get
{
if (!string.IsNullOrWhiteSpace(_commandText))
{
return string.Format(
CultureInfo.InvariantCulture,
@"{0}: {1}
{2}",
DatabaseSpecificNumber,
_commandText,
base.Message);
}
return string.Format(
CultureInfo.InvariantCulture,
@"{0}
{1}",
DatabaseSpecificNumber,
base.Message);
}
}
/// <summary>
/// Sorosítás.
/// </summary>
public override void GetObjectData(SerializationInfo info, StreamingContext context)
{
if (info == null)
{
throw new ArgumentNullException(nameof(info));
}
base.GetObjectData(info, context);
info.AddValue("Error", Error);
info.AddValue("DatabaseSpecificNumber", DatabaseSpecificNumber);
info.AddValue("MustRetry", MustRetry);
}
}
/// <summary>
/// Holtpont.
/// </summary>
[Serializable]
public sealed class DeadlockException : SDADataProviderException
{
/// <summary>
/// Szabványos konstruktor.
/// </summary>
public DeadlockException() { }
/// <summary>
/// Szabványos konstruktor.
/// </summary>
public DeadlockException(string message)
: base(message) { }
/// <summary>
/// Szabványos konstruktor.
/// </summary>
public DeadlockException(string message, Exception inner)
: base(message, inner) { }
/// <summary>
/// Szabványos konstruktor.
/// </summary>
DeadlockException(SerializationInfo info, StreamingContext context)
: base(info, context) { }
internal DeadlockException(Exception innerException, int number, string commandText)
: base(innerException, SDADataProviderError.DeadlockDetected, number, false, commandText) { }
}
/// <summary>
/// Adatbázis művelet időtúllépés.
/// </summary>
[Serializable]
public sealed class CommandTimeoutException : SDADataProviderException
{
/// <summary>
/// Szabványos konstruktor.
/// </summary>
public CommandTimeoutException() { }
/// <summary>
/// Szabványos konstruktor.
/// </summary>
public CommandTimeoutException(string message)
: base(message) { }
/// <summary>
/// Szabványos konstruktor.
/// </summary>
public CommandTimeoutException(string message, Exception inner)
: base(message, inner) { }
/// <summary>
/// Szabványos konstruktor.
/// </summary>
CommandTimeoutException(SerializationInfo info, StreamingContext context)
: base(info, context) { }
internal CommandTimeoutException(Exception innerException, int number, string commandText)
: base(innerException, SDADataProviderError.CommandTimeout, number, false, commandText) { }
}
/// <summary>
/// Táblatér hiba.
/// </summary>
[Serializable]
public sealed class TableSpaceErrorException : SDADataProviderException
{
/// <summary>
/// Szabványos konstruktor.
/// </summary>
public TableSpaceErrorException() { }
/// <summary>
/// Szabványos konstruktor.
/// </summary>
public TableSpaceErrorException(string message)
: base(message) { }
/// <summary>
/// Szabványos konstruktor.
/// </summary>
public TableSpaceErrorException(string message, Exception inner)
: base(message, inner) { }
/// <summary>
/// Szabványos konstruktor.
/// </summary>
TableSpaceErrorException(SerializationInfo info, StreamingContext context)
: base(info, context) { }
internal TableSpaceErrorException(Exception innerException, int number, string commandText)
: base(innerException, SDADataProviderError.TableSpaceError, number, false, commandText) { }
}
/// <summary>
/// Egyediség megsértése.
/// </summary>
[Serializable]
public sealed class UniqueKeyViolationException : SDADataProviderException
{
/// <summary>
/// Szabványos konstruktor.
/// </summary>
public UniqueKeyViolationException() { }
/// <summary>
/// Szabványos konstruktor.
/// </summary>
public UniqueKeyViolationException(string message)
: base(message) { }
/// <summary>
/// Szabványos konstruktor.
/// </summary>
public UniqueKeyViolationException(string message, Exception inner)
: base(message, inner) { }
/// <summary>
/// Szabványos konstruktor.
/// </summary>
UniqueKeyViolationException(SerializationInfo info, StreamingContext context)
: base(info, context) { }
internal UniqueKeyViolationException(Exception innerException, int number, string commandText)
: base(innerException, SDADataProviderError.UniqueKeyViolation, number, false, commandText) { }
}
/// <summary>
/// Idegen kulcs megsértése.
/// </summary>
[Serializable]
public sealed class ForeignKeyViolationException : SDADataProviderException
{
/// <summary>
/// Szabványos konstruktor.
/// </summary>
public ForeignKeyViolationException() { }
/// <summary>
/// Szabványos konstruktor.
/// </summary>
public ForeignKeyViolationException(string message)
: base(message) { }
/// <summary>
/// Szabványos konstruktor.
/// </summary>
public ForeignKeyViolationException(string message, Exception inner)
: base(message, inner) { }
/// <summary>
/// Szabványos konstruktor.
/// </summary>
ForeignKeyViolationException(SerializationInfo info, StreamingContext context)
: base(info, context) { }
internal ForeignKeyViolationException(Exception innerException, int number, string commandText)
: base(innerException, SDADataProviderError.ForeignKeyViolation, number, false, commandText) { }
}
/// <summary>
/// Tábla vagy nézet nem létezik.
/// </summary>
[Serializable]
public sealed class TableOrViewNotExistsException : SDADataProviderException
{
/// <summary>
/// Szabványos konstruktor.
/// </summary>
public TableOrViewNotExistsException() { }
/// <summary>
/// Szabványos konstruktor.
/// </summary>
public TableOrViewNotExistsException(string message)
: base(message) { }
/// <summary>
/// Szabványos konstruktor.
/// </summary>
public TableOrViewNotExistsException(string message, Exception inner)
: base(message, inner) { }
/// <summary>
/// Szabványos konstruktor.
/// </summary>
TableOrViewNotExistsException(SerializationInfo info, StreamingContext context)
: base(info, context) { }
internal TableOrViewNotExistsException(Exception innerException, int number, string commandText)
: base(innerException, SDADataProviderError.TableOrViewNotExists, number, false, commandText) { }
}
/// <summary>
/// Oszlop nem létezik.
/// </summary>
[Serializable]
public sealed class InvalidColumnNameException : SDADataProviderException
{
/// <summary>
/// Szabványos konstruktor.
/// </summary>
public InvalidColumnNameException() { }
/// <summary>
/// Szabványos konstruktor.
/// </summary>
public InvalidColumnNameException(string message)
: base(message) { }
/// <summary>
/// Szabványos konstruktor.
/// </summary>
public InvalidColumnNameException(string message, Exception inner)
: base(message, inner) { }
/// <summary>
/// Szabványos konstruktor.
/// </summary>
InvalidColumnNameException(SerializationInfo info, StreamingContext context)
: base(info, context) { }
internal InvalidColumnNameException(Exception innerException, int number, string commandText)
: base(innerException, SDADataProviderError.InvalidColumnName, number, false, commandText) { }
}
/// <summary>
/// Kommunikációs hiba.
/// </summary>
[Serializable]
public sealed class CommunicationErrorException : SDADataProviderException
{
/// <summary>
/// Szabványos konstruktor.
/// </summary>
public CommunicationErrorException() { }
/// <summary>
/// Szabványos konstruktor.
/// </summary>
public CommunicationErrorException(string message)
: base(message) { }
/// <summary>
/// Szabványos konstruktor.
/// </summary>
public CommunicationErrorException(string message, Exception inner)
: base(message, inner) { }
/// <summary>
/// Szabványos konstruktor.
/// </summary>
CommunicationErrorException(SerializationInfo info, StreamingContext context)
: base(info, context) { }
internal CommunicationErrorException(Exception innerException, int number)
: base(innerException, SDADataProviderError.CommunicationError, number, false) { }
internal CommunicationErrorException(Exception innerException, int number, bool mustRetry)
: base(innerException, SDADataProviderError.CommunicationError, number, mustRetry) { }
}
}

23
Sda.DataProvider/ExecutionType.cs Normal file
View file

@ -0,0 +1,23 @@
namespace SDA.DataProvider
{
/// <summary>
/// <see cref="SDACommand"/> végrehajtás típus.
/// </summary>
public enum ExecutionType
{
/// <summary>
/// Scalar
/// </summary>
Scalar,
/// <summary>
/// Reader
/// </summary>
Reader,
/// <summary>
/// NonQuery
/// </summary>
NonQuery
}
}

40
Sda.DataProvider/Factories/MSSQLFactory.cs Normal file
View file

@ -0,0 +1,40 @@
using SDA.DataProvider.Core;
namespace SDA.DataProvider.Factories
{
/// <summary>
/// Az MSSQL databázis-kiszolgálóval való működéshez szükséges osztálygyár.
/// </summary>
class MSSQLFactory : SDAFactory
{
public MSSQLFactory(int? commandTimeout) : base(commandTimeout)
{
}
internal override SDACommandWrapper CreateCommand()
{
return new MSSQLWrappers.MSSQLCommandWrapper();
}
internal override SDAConnectionWrapper CreateConnection()
{
return new MSSQLWrappers.MSSQLConnectionWrapper();
}
internal override SDADataAdapterWrapper CreateDataAdapter()
{
return new MSSQLWrappers.MSSQLDataAdapterWrapper();
}
internal override SDACommandBuilderWrapper CreateCommandBuilder()
{
return new MSSQLWrappers.MSSQLCommandBuilderWrapper();
}
internal override SDACommandBuilderWrapper CreateCommandBuilder(SDADataAdapterWrapper dataAdapter)
{
return new MSSQLWrappers.MSSQLCommandBuilderWrapper(dataAdapter);
}
}
}

36
Sda.DataProvider/Initializer.cs Normal file
View file

@ -0,0 +1,36 @@
using System;
namespace SDA.DataProvider
{
/// <summary>
/// A modul inicializáló osztálya.
/// </summary>
public static class Initializer
{
/// <summary>
/// Inicializálja a modult a megfelelő adatszolgáltató használatára.
/// </summary>
/// <param name="databaseType">Az adatbázis típusa</param>
public static void Initialize(DatabaseType databaseType)
{
Initialize(databaseType, null);
}
/// <summary>
/// Inicializálja a modult a megfelelő adatszolgáltató használatára.
/// </summary>
/// <param name="databaseType">Az adatbázis típusa</param>
/// <param name="commandTimeout">Az összes command alapértelmezett timeout paramétere</param>
public static void Initialize(DatabaseType databaseType, int? commandTimeout)
{
switch (databaseType)
{
case DatabaseType.NativeMSSQL:
SDAFactory.Instance = new Factories.MSSQLFactory(commandTimeout);
break;
default:
throw new InvalidOperationException("Invalid database type.");
}
}
}
}

1
Sda.DataProvider/Properties/AssemblyInfo.cs Normal file
View file

@ -0,0 +1 @@


21
Sda.DataProvider/SDABulkAdapter.cs Normal file
View file

@ -0,0 +1,21 @@
using System.Data;
namespace SDA.DataProvider
{
/// <summary>
/// Nagy sebességű adatbeszúrásra (bulk insert)
/// </summary>
public abstract class SDABulkAdapter
{
/// <summary>
/// Bulk insert művelettel beszúrja a megadott source DataTable sorait
/// az adatbázisba.
/// </summary>
/// <param name="source">DataTable, ami a beszúrandó adatokat
/// tartalmazza. A DataTable oszlopainak azonosnak kell lenni a
/// céltábla oszlopaival adattípusra és névre is. A DataTable TableName
/// property-je tartalmazza a céltábla nevét.
/// </param>
public abstract void BulkInsert(DataTable source);
}
}

273
Sda.DataProvider/SDACommand.cs Normal file
View file

@ -0,0 +1,273 @@
using System;
using System.Data;
using System.Diagnostics;
using System.Diagnostics.CodeAnalysis;
using JetBrains.Annotations;
using SDA.DataProvider.Core;
namespace SDA.DataProvider
{
/// <summary>
/// Adatbázis-parancs.
/// </summary>
public class SDACommand : IDisposable
{
[NotNull]
internal SDACommandWrapper Command;
[CanBeNull]
internal SDAConnection InnerConnection;
[NotNull]
internal SDACommandParameterCollection InnerParameters;
/// <summary>
/// Létrehoz egy új adatbázis-parancs objektum példányt.
/// </summary>
public SDACommand()
{
if (SDAFactory.Instance == null)
{
throw new InvalidOperationException("SDAFactory.Instance");
}
Command = SDAFactory.Instance.CreateCommand();
InnerParameters = new SDACommandParameterCollection(Command);
// Csak hogy mindig legyen explicit beállítva...
Command.CommandType = CommandType.Text;
// Ha van beállított Command Timeout, akkor átadjuk
if (SDAFactory.Instance.CommandTimeout.HasValue)
{
Command.CommandTimeout = SDAFactory.Instance.CommandTimeout.Value;
}
}
/// <summary>
/// Létrehoz egy új adatbázis-parancs objektum példányt.
/// </summary>
/// <param name="commandText">SQL parancs</param>
/// <param name="connection">Adatbázis kacsolat</param>
public SDACommand(string commandText, SDAConnection connection)
{
if (connection == null)
{
throw new ArgumentNullException(nameof(connection));
}
if (SDAFactory.Instance == null)
{
throw new InvalidOperationException("SDAFactory.Instance");
}
Command = SDAFactory.Instance.CreateCommand();
InnerParameters = new SDACommandParameterCollection(Command);
InnerConnection = connection;
CommandText = commandText;
Command.Connection = connection.Connection;
// Ha van beállított Command Timeout, akkor átadjuk
if (SDAFactory.Instance.CommandTimeout.HasValue)
{
Command.CommandTimeout = SDAFactory.Instance.CommandTimeout.Value;
}
}
internal SDACommand(SDACommandWrapper command)
{
Command = command;
InnerParameters = new SDACommandParameterCollection(Command);
// Ha van beállított Command Timeout, akkor átadjuk
if (SDAFactory.Instance.CommandTimeout.HasValue)
{
Command.CommandTimeout = SDAFactory.Instance.CommandTimeout.Value;
}
}
bool _disposed;
/// <summary>
/// Explicit destruktor.
/// </summary>
/// <param name="disposing">Programozott felszabadítás?</param>
protected virtual void Dispose(bool disposing)
{
if (_disposed)
{
return;
}
if (disposing)
{
Command.Dispose();
}
_disposed = true;
}
/// <summary>
/// Eldobja az objektumot.
/// </summary>
public void Dispose()
{
Dispose(true);
GC.SuppressFinalize(this);
}
/// <summary>
/// A parancs SQL szövege.
/// </summary>
[SuppressMessage("Microsoft.Security", "CA2100:Review SQL queries for security vulnerabilities")]
[CanBeNull]
public virtual string CommandText
{
get
{
return Command.CommandText;
}
set
{
Command.CommandText = value;
}
}
/// <summary>
/// A parancs maximális futási ideje másodpercben.
/// </summary>
public int CommandTimeout
{
get
{
return Command.CommandTimeout;
}
set
{
Command.CommandTimeout = value;
}
}
/// <summary>
/// A parancs adatbázis-kapcsolata.
/// </summary>
[CanBeNull]
public virtual SDAConnection Connection
{
get
{
return InnerConnection;
}
set
{
InnerConnection = value;
Command.Connection = value?.Connection;
}
}
/// <summary>
/// Végrehajtja a parancsot, és visszatér az eredmény első sorának első oszlopának értékével.
/// </summary>
/// <returns>Az eredmény első sorának első oszlopának értéke</returns>
[CanBeNull]
public virtual object ExecuteScalar()
{
return !SDAConnectionDiagnostics.DiagnosticEnable
? Command.ExecuteScalar()
: ExecuteWithDiagnostic(Command.ExecuteScalar, ExecutionType.Scalar);
}
/// <summary>
/// Végrehajtja a parancsot és egy SDADataReader objektumot épít a válasz feldolgozására.
/// </summary>
/// <returns>Egy SDADataReader objektum</returns>
[NotNull]
public SDADataReader ExecuteReader()
{
return !SDAConnectionDiagnostics.DiagnosticEnable
? new SDADataReader(Command.ExecuteReader())
: new SDADataReader(ExecuteWithDiagnostic(Command.ExecuteReader, ExecutionType.Scalar));
}
/// <summary>
/// Végrehajtja a parancsot és egy SDADataReader objektumot épít a válasz feldolgozására.
/// </summary>
/// <param name="commandBehavior">A parancs végrehajtásának tulajdonságai</param>
/// <returns>Egy SDADataReader objektum</returns>
[NotNull]
public SDADataReader ExecuteReader(CommandBehavior commandBehavior)
{
return !SDAConnectionDiagnostics.DiagnosticEnable
? new SDADataReader(Command.ExecuteReader(commandBehavior))
: new SDADataReader(ExecuteWithDiagnostic(() => Command.ExecuteReader(commandBehavior), ExecutionType.Scalar));
}
/// <summary>
/// Végrehajtja a parancsot, és visszatér a művelet által érintett sorok számával.
/// </summary>
/// <returns>A művelet által érintett sorok száma</returns>
public int ExecuteNonQuery()
{
return Command.ExecuteNonQuery();
}
/// <summary>
/// A parancsból egy előkészített változatot hoz létre az adatbázis-kiszolgálón.
/// </summary>
public void Prepare()
{
Command.Prepare();
}
/// <summary>
/// Leállítja a parancs végrehajtását.
/// </summary>
public void Cancel()
{
Command.Cancel();
}
/// <summary>
/// A parancs paramétereinek listája.
/// </summary>
[NotNull]
public virtual SDACommandParameterCollection Parameters => InnerParameters;
/// <summary>
/// A parancshoz tartozó adatbázis-ügylet.
/// </summary>
[CanBeNull]
public virtual SDATransaction Transaction
{
get
{
return null;
}
set
{
Command.Transaction = value?.Transaction;
}
}
/// <summary>
/// A parancs típusa.
/// </summary>
public CommandType CommandType
{
get
{
return Command.CommandType;
}
set
{
Command.CommandType = value;
}
}
private TResult ExecuteWithDiagnostic<TResult>(Func<TResult> f, ExecutionType executionType)
{
var watch = new Stopwatch();
watch.Start();
var result = f();
watch.Stop();
SDAConnectionDiagnostics.RaiseCommandExecutedEvent(this, new CommandExecutedEventArgs(watch.Elapsed, executionType));
return result;
}
}
}

94
Sda.DataProvider/SDACommandBuilder.cs Normal file
View file

@ -0,0 +1,94 @@
using System;
using System.Diagnostics.CodeAnalysis;
using SDA.DataProvider.Core;
namespace SDA.DataProvider
{
/// <summary>
/// Egy konkrét táblára vonatkozó <c>DML</c> utasításokat generál.
/// </summary>
public class SDACommandBuilder : IDisposable
{
internal SDACommandBuilderWrapper CommandBuilder;
/// <summary>
/// Az osztály alapértelmezett konstruktora.
/// </summary>
public SDACommandBuilder()
{
CommandBuilder = SDAFactory.Instance.CreateCommandBuilder();
}
/// <summary>
/// Az osztály konstruktora.
/// </summary>
/// <param name="dataAdapter"></param>
public SDACommandBuilder(SDADataAdapter dataAdapter)
{
if (dataAdapter == null)
{
throw new ArgumentNullException(nameof(dataAdapter));
}
CommandBuilder = SDAFactory.Instance.CreateCommandBuilder(dataAdapter.DataAdapter);
}
/// <summary>
/// Paraméterek kötése.
/// </summary>
public void DeriveParameters(SDACommand command)
{
if (command == null)
{
throw new ArgumentNullException(nameof(command));
}
CommandBuilder.DeriveParameters(command.Command);
}
/// <summary>
/// Visszaadja a törlő parancs objektumot.
/// </summary>
/// <returns></returns>
[SuppressMessage("Microsoft.Design", "CA1024:UsePropertiesWhereAppropriate")]
public SDACommand GetDeleteCommand()
{
return new SDACommand(CommandBuilder.GetDeleteCommand());
}
/// <summary>
/// Beszúrás parancs.
/// </summary>
[SuppressMessage("Microsoft.Design", "CA1024:UsePropertiesWhereAppropriate")]
public SDACommand GetInsertCommand()
{
return new SDACommand(CommandBuilder.GetInsertCommand());
}
/// <summary>
/// Módosítás parancs.
/// </summary>
[SuppressMessage("Microsoft.Design", "CA1024:UsePropertiesWhereAppropriate")]
public SDACommand GetUpdateCommand()
{
return new SDACommand(CommandBuilder.GetUpdateCommand());
}
/// <summary>
/// Séma frissítése.
/// </summary>
public void RefreshSchema()
{
CommandBuilder.RefreshSchema();
}
/// <summary>
/// Eldobja az objektumot.
/// </summary>
public void Dispose()
{
CommandBuilder.Dispose();
CommandBuilder = null;
}
}
}

81
Sda.DataProvider/SDACommandParameter.cs Normal file
View file

@ -0,0 +1,81 @@
using System.Data;
using SDA.DataProvider.Core;
namespace SDA.DataProvider
{
/// <summary>
/// Adatbázis-parancs paramétere.
/// </summary>
public class SDACommandParameter
{
internal SDACommandParameterWrapper Parameter;
protected SDACommandParameter()
{ }
internal SDACommandParameter(SDACommandParameterWrapper parameter)
{
Parameter = parameter;
}
/// <summary>
/// A paraméter típusa.
/// </summary>
public SDADBType DBType
{
get
{
return Parameter.DBType;
}
set
{
Parameter.DBType = value;
}
}
/// <summary>
/// A paraméter értéke
/// </summary>
public virtual object Value
{
get
{
return Parameter.Value;
}
set
{
Parameter.Value = value;
}
}
/// <summary>
/// A paraméter neve.
/// </summary>
public string ParameterName
{
get
{
return Parameter.ParameterName;
}
set
{
Parameter.ParameterName = value;
}
}
/// <summary>
/// A paraméter iránya.
/// </summary>
public ParameterDirection Direction
{
get
{
return Parameter.Direction;
}
set
{
Parameter.Direction = value;
}
}
}
}

153
Sda.DataProvider/SDACommandParameterCollection.cs Normal file
View file

@ -0,0 +1,153 @@
using System;
using System.Diagnostics.CodeAnalysis;
using JetBrains.Annotations;
using SDA.DataProvider.Core;
namespace SDA.DataProvider
{
/// <summary>
/// Adatbázis-parancs paramétereinek listája.
/// </summary>
[SuppressMessage("Microsoft.Naming", "CA1711:IdentifiersShouldNotHaveIncorrectSuffix")]
public class SDACommandParameterCollection
{
internal SDACommandWrapper Command;
protected SDACommandParameterCollection()
{
}
internal SDACommandParameterCollection(SDACommandWrapper command)
{
Command = command;
}
internal virtual SDACommandParameterCollectionWrapper Parameters
{
get
{
return Command.Parameters;
}
}
/// <summary>
/// Visszaadja a megadott nevű paraméter objektumot.
/// </summary>
[CanBeNull]
public virtual SDACommandParameter this[string index]
{
get
{
SDACommandParameterWrapper parameter = Parameters[index];
return parameter != null ? new SDACommandParameter(parameter) : null;
}
}
/// <summary>
/// Visszaadja a megadott sorszámú paraméter objektumot.
/// </summary>
[NotNull]
public SDACommandParameter this[int index]
{
get
{
return new SDACommandParameter(Parameters[index]);
}
set
{
if (value == null)
{
throw new ArgumentNullException(nameof(value));
}
Parameters[index] = value.Parameter;
}
}
/// <summary>
/// Új paramétert vesz fel a listába.
/// </summary>
/// <param name="parameter">A listába felveendő paraméter objektum</param>
/// <returns>A listába felvett paraméter objektum</returns>
[NotNull]
public virtual SDACommandParameter Add(SDACommandParameter parameter)
{
if (parameter == null)
{
throw new ArgumentNullException(nameof(parameter));
}
Command.Parameters.Add(parameter.Parameter);
return parameter;
}
/// <summary>
/// Új paramétert vesz fel a listába.
/// </summary>
/// <param name="name">A paraméter neve</param>
/// <param name="type">A paraméter típusa</param>
/// <returns>A listába felvett paraméter objektum</returns>
[NotNull]
public virtual SDACommandParameter Add(string name, SDADBType type)
{
return new SDACommandParameter(Command.Parameters.Add(name, type));
}
/// <summary>
/// Új paramétert vesz fel a listába.
/// </summary>
/// <param name="name">A paraméter neve</param>
/// <param name="type">A paraméter típusa</param>
/// <param name="size">A paraméterhez tartozó oszlop mérete</param>
/// <returns>A listába felvett paraméter objektum</returns>
[NotNull]
public virtual SDACommandParameter Add(string name, SDADBType type, int size)
{
return new SDACommandParameter(Command.Parameters.Add(name, type, size));
}
/// <summary>
/// Új paramétert vesz fel a listába.
/// </summary>
/// <param name="name">A paraméter neve</param>
/// <param name="value">A paraméter értéke</param>
/// <returns>A listába felvett paraméter objektum</returns>
[NotNull]
public virtual SDACommandParameter Add(string name, object value)
{
return new SDACommandParameter(Command.Parameters.Add(name, value));
}
/// <summary>
/// Eltávolítja a megadott paramétert a listából.
/// </summary>
/// <param name="parameter">Az eltávolítandó paraméter</param>
public virtual void Remove(SDACommandParameter parameter)
{
if (parameter == null)
{
throw new ArgumentNullException(nameof(parameter));
}
Command.Parameters.Remove(parameter.Parameter);
}
/// <summary>
/// Kiüríti a paraméterlistát.
/// </summary>
public virtual void Clear()
{
Command.Parameters.Clear();
}
/// <summary>
/// Command paraméterek száma
/// </summary>
/// <returns></returns>
public virtual int Count()
{
return Parameters.Count;
}
}
}

281
Sda.DataProvider/SDAConnection.cs Normal file
View file

@ -0,0 +1,281 @@
using System;
using System.Data;
using System.Diagnostics;
using System.Diagnostics.CodeAnalysis;
using JetBrains.Annotations;
using SDA.DataProvider.Core;
namespace SDA.DataProvider
{
/// <summary>
/// Adatbázis-kapcsolat
/// </summary>
public class SDAConnection : IDisposable /*, IDbConnection */
{
[NotNull]
internal SDAConnectionWrapper Connection;
/// <summary>
/// Előállít egy új adatbázis-kapcsolat példányt.
/// </summary>
public SDAConnection()
{
if (SDAFactory.Instance == null)
{
throw new InvalidOperationException("SDAFactory.Instance");
}
Connection = SDAFactory.Instance.CreateConnection();
}
/// <summary>
/// Előállít egy új adatbázis-kapcsolat példányt.
/// </summary>
/// <param name="connectionString">Az adatbázis-kapcsolat paramétereit leíró karakterlánc</param>
public SDAConnection([CanBeNull] string connectionString)
{
if (SDAFactory.Instance == null)
{
throw new InvalidOperationException("SDAFactory.Instance");
}
Connection = SDAFactory.Instance.CreateConnection();
Connection.ConnectionString = connectionString;
}
/// <summary>
/// Előállít egy új adatbázis-kapcsolat példányt.
/// </summary>
/// <param name="databaseType">Az adatbázis típusa.</param>
/// <param name="connectionString">Az adatbázis-kapcsolat paramétereit leíró karakterlánc.</param>
public SDAConnection(DatabaseType databaseType, [CanBeNull] string connectionString) : this(databaseType, connectionString, null)
{
}
/// <summary>
/// Előállít egy új adatbázis-kapcsolat példányt.
/// </summary>
/// <param name="databaseType">Az adatbázis típusa.</param>
/// <param name="connectionString">Az adatbázis-kapcsolat paramétereit leíró karakterlánc.</param>
/// <param name="commandTimeout">Command timeout-ja.</param>
public SDAConnection(DatabaseType databaseType, [CanBeNull] string connectionString, int? commandTimeout)
{
var factory = SDAFactory.GetByDatabaseType(databaseType, commandTimeout);
Debug.Assert(factory != null, "factory != null");
Connection = factory.CreateConnection();
Debug.Assert(Connection != null, "Connection != null");
Connection.ConnectionString = connectionString;
}
/// <summary>
/// Megnyitja az adatbázis-kapcsolatot.
/// </summary>
public void Open()
{
OpenWithRetry(0);
}
/// <summary>
/// Lezárja az adatbáziskapcsolatot.
/// </summary>
public void Close()
{
Connection.Close();
}
/// <summary>
/// Létrehoz egy - az adatbázis-kapcsolathoz tartozó - adatbázis-parancs objektumot
/// </summary>
/// <returns>Egy adatbázis-parancs objektum</returns>
[NotNull]
public SDACommand CreateCommand()
{
return new SDACommand(Connection.CreateCommand());
}
/// <summary>
/// Létrehoz egy - az adatbázis-kapcsolathoz tartozó - adatbázis-parancs objektumot
/// </summary>
/// <param name="commandText">A parancs objektum szövege</param>
/// <returns>Egy adatbázis-parancs objektum</returns>
[NotNull]
[SuppressMessage("ReSharper", "UseObjectOrCollectionInitializer")]
public SDACommand CreateCommand([CanBeNull] string commandText)
{
SDACommandWrapper command = null;
SDACommand result = null;
try
{
command = Connection.CreateCommand();
result = new SDACommand(command);
result.CommandText = commandText;
return result;
}
catch
{
command?.Dispose();
result?.Dispose();
throw;
}
}
/// <summary>
/// Adatbázis ügyletet kezdeményez.
/// </summary>
/// <returns>Egy adatbázis-ügylet objektum</returns>
[NotNull]
public SDATransaction BeginTransaction()
{
return new SDATransaction(Connection.BeginTransaction());
}
/// <summary>
/// Adatbázis ügyletet kezdeményez.
/// </summary>
/// <param name="isolationLevel">Elválasztás szintje</param>
/// <returns>Egy adatbázis-ügylet objektum</returns>
[NotNull]
public SDATransaction BeginTransaction(IsolationLevel isolationLevel)
{
return new SDATransaction(Connection.BeginTransaction(isolationLevel));
}
/// <summary>
/// Létrehoz egy <see cref="SDABulkAdapter"/>-t nagyon gyors
/// adatbeszúrásokhoz.
/// </summary>
/// <param name="transaction">
/// Opcionális <see cref="SDATransaction"/> objektum, ha nincs megadva,
/// akkor a bulk művelet _nem_ fut tranzakcióban, azaz ha megáll egy
/// hiba miatt, akkor a már beszúrt sorok nem görgetődnek vissza!
/// Viszont ha a kapcsolaton már van aktív tranzakció, akkor azt
/// kötelező megadni a bulk insertnek is.
/// </param>
/// <returns>
/// Egy új <see cref="SDABulkAdapter"/>.
/// </returns>
[NotNull]
public SDABulkAdapter CreateBulkAdapter(SDATransaction transaction = null)
{
return Connection.CreateBulkAdapter(transaction);
}
/// <summary>
/// Üresre törli az adatbázis-szerver connection pool-ját.
/// </summary>
/// <param name="all">
/// True érték esetén az összes pool-t alaphelyzetbe hozza,
/// False érték esetén csak az adott kapcsolathoz tartozót.
/// </param>
public void ResetConnectionPool(bool all = false)
{
Connection.ResetConnectionPool(all);
}
/// <summary>
/// Az adatbázis-kapcsolat paramétereit leíró karakterlánc.
/// </summary>
[CanBeNull]
public string ConnectionString
{
get
{
return Connection.ConnectionString;
}
set
{
Connection.ConnectionString = value;
}
}
/// <summary>
/// Az adatbázis-kapcsolat állapota.
/// </summary>
public ConnectionState State => Connection.State;
bool _disposed;
/// <summary>
/// Explicit destruktor.
/// </summary>
/// <param name="disposing">Programozott felszabadítás?</param>
protected virtual void Dispose(bool disposing)
{
if (_disposed)
{
return;
}
if (disposing)
{
Connection.Dispose();
SDAConnectionDiagnostics.DecrementActiveConnections();
}
_disposed = true;
}
/// <summary>
/// Eldobja az objektumot.
/// </summary>
public void Dispose()
{
Dispose(true);
GC.SuppressFinalize(this);
}
//#region IDbConnection Members
//public void ChangeDatabase(string databaseName)
//{
//}
//IDbTransaction IDbConnection.BeginTransaction(System.Data.IsolationLevel il)
//{
// return BeginTransaction(il);
//}
//IDbTransaction IDbConnection.BeginTransaction()
//{
// return BeginTransaction();
//}
//IDbCommand IDbConnection.CreateCommand()
//{
// throw new NotImplementedException();
// return CreateCommand();
//}
//public string Database
//{
// get { return m_Connection.Database; }
//}
//public int ConnectionTimeout
//{
// get { return m_Connection.ConnectionTimeout; }
//}
//#endregion
#region Újrapróbálkozás
void OpenWithRetry(int tries)
{
try
{
Connection.Open();
SDAConnectionDiagnostics.IncrementActiveConnections();
}
catch (SDADataProviderException exception)
{
if ((exception.MustRetry) && (tries < Configuration.MaxTries))
{
OpenWithRetry(tries + 1);
}
else
{
throw;
}
}
}
#endregion
}
}

42
Sda.DataProvider/SDAConnectionDiagnostics.cs Normal file
View file

@ -0,0 +1,42 @@
using System;
namespace SDA.DataProvider
{
/// <summary>
/// Diagnosztikai célokat szolgál.
/// </summary>
public static class SDAConnectionDiagnostics
{
/// <summary>
///
/// </summary>
public static bool DiagnosticEnable { get; set; } = false;
/// <summary>
/// <see cref="SDACommand"/> végrehajtása után kiváltodó esemény />
/// </summary>
public static event EventHandler<CommandExecutedEventArgs> CommandExecuted;
internal static void RaiseCommandExecutedEvent(object sender, CommandExecutedEventArgs transactionEventArgs)
{
CommandExecuted?.Invoke(sender, transactionEventArgs);
}
static volatile int _activeConnections;
internal static void IncrementActiveConnections()
{
_activeConnections++;
}
internal static void DecrementActiveConnections()
{
_activeConnections--;
}
/// <summary>
/// A jelenleg megnyitott, de még nem eldobott adatbázis-kapcsolatok számát adja meg.
/// </summary>
public static int ActiveConnections => _activeConnections;
}
}

67
Sda.DataProvider/SDADBType.cs Normal file
View file

@ -0,0 +1,67 @@
using System.Diagnostics.CodeAnalysis;
namespace SDA.DataProvider
{
/// <summary>
/// Adatbázis-paraméterek típusai.
/// </summary>
[SuppressMessage("Microsoft.Naming", "CA1709:IdentifiersShouldBeCasedCorrectly", MessageId = "SDADB")]
public enum SDADBType
{
/// <summary>
/// Bináris adat
/// </summary>
Binary,
/// <summary>
/// Karakter
/// </summary>
Char,
/// <summary>
/// Dátum, idő
/// </summary>
DateTime,
/// <summary>
/// Lebegőpontos
/// </summary>
Double,
/// <summary>
/// Egész típus
/// </summary>
Int,
/// <summary>
/// Karakterlánc
/// </summary>
String,
/// <summary>
/// Logikai érték (SDAConvert T - F)
/// </summary>
Boolean,
/// <summary>
/// Hosszú karakterlánc (> 4000 karakter)
/// </summary>
LongString,
/// <summary>
/// Nagy egész típus
/// </summary>
LongInt,
/// <summary>
/// Nem unicode karakterlánc
/// </summary>
NonUnicodeString,
/// <summary>
/// GUID
/// </summary>
Guid
}
}

207
Sda.DataProvider/SDADataAdapter.cs Normal file
View file

@ -0,0 +1,207 @@
using System;
using System.Data;
using System.Globalization;
using SDA.DataProvider.Core;
namespace SDA.DataProvider
{
/// <summary>
/// Adapter
/// </summary>
public class SDADataAdapter : IDisposable
{
internal SDADataAdapterWrapper DataAdapter;
internal SDACommand InnerDeleteCommand;
internal SDACommand InnerInsertCommand;
internal SDACommand InnerSelectCommand;
internal SDACommand InnerUpdateCommand;
/// <summary>
/// Előállít egy új adatbázis-kapcsolat példányt.
/// </summary>
public SDADataAdapter()
{
if (SDAFactory.Instance == null)
{
throw new InvalidOperationException("SDAFactory.Instance");
}
DataAdapter = SDAFactory.Instance.CreateDataAdapter();
}
/// <summary>
/// Előállít egy új adatbázis-kapcsolat példányt.
/// </summary>
/// <param name="type">Az adatbázis-kezelő típusa.</param>
public SDADataAdapter(DatabaseType type) : this(type, null)
{
}
/// <summary>
/// Előállít egy új adatbázis-kapcsolat példányt.
/// </summary>
/// <param name="type">Az adatbázis-kezelő típusa.</param>
public SDADataAdapter(DatabaseType type, int? commandTimeout)
{
DataAdapter = SDAFactory.GetByDatabaseType(type, commandTimeout).CreateDataAdapter();
}
/// <summary>
/// Törléshez használt parancsobjektum.
/// </summary>
public SDACommand DeleteCommand
{
get
{
return InnerDeleteCommand;
}
set
{
DataAdapter.DeleteCommand = value?.Command;
InnerDeleteCommand = value;
}
}
/// <summary>
/// Beszúráshoz használt parancsobjektum.
/// </summary>
public SDACommand InsertCommand
{
get
{
return InnerInsertCommand;
}
set
{
DataAdapter.InsertCommand = value?.Command;
InnerInsertCommand = value;
}
}
/// <summary>
/// Lekérdezéshez használt parancsobjektum.
/// </summary>
public SDACommand SelectCommand
{
get
{
return InnerSelectCommand;
}
set
{
DataAdapter.SelectCommand = value?.Command;
InnerSelectCommand = value;
}
}
/// <summary>
/// Módosításhoz használt parancsobjektum.
/// </summary>
public SDACommand UpdateCommand
{
get
{
return InnerUpdateCommand;
}
set
{
DataAdapter.UpdateCommand = value?.Command;
InnerUpdateCommand = value;
}
}
/// <summary>
/// Feltölti adattal a táblát.
/// </summary>
/// <param name="table">A feltöltendő tábla</param>
public void Fill(DataTable table)
{
DataAdapter.Fill(table);
}
/// <summary>
/// Feltölti adattal a táblát
/// </summary>
/// <param name="table">A feltöltendő tábla</param>
/// <param name="startRecord">Az első rekord indexe</param>
/// <param name="endRecord">Az utolsó rekord indexe</param>
/// <remarks>Nem szabványos metódus!</remarks>
public void Fill(DataTable table, int startRecord, int endRecord)
{
if (table == null)
{
throw new ArgumentNullException(nameof(table));
}
table.TableName = "table";
using (DataSet dts = new DataSet())
{
dts.Locale = CultureInfo.CurrentCulture;
dts.Tables.Add(table);
DataAdapter.Fill(dts, startRecord, endRecord, "table");
}
}
/// <summary>
/// Feltölti adattal a táblát
/// </summary>
/// <param name="dataSet">A feltöltendő adathalmaz</param>
public void Fill(DataSet dataSet)
{
DataAdapter.Fill(dataSet);
}
/// <summary>
/// Frissíti az adatbázist.
/// </summary>
/// <param name="dataSet">A forrás adathalmaz</param>
public void Update(DataSet dataSet)
{
DataAdapter.Update(dataSet);
}
/// <summary>
/// Frissíti az adatbázist.
/// </summary>
/// <param name="dataTable">A forrás tábla</param>
public void Update(DataTable dataTable)
{
DataAdapter.Update(dataTable);
}
bool _disposed;
/// <summary>
/// Explicit destruktor.
/// </summary>
/// <param name="disposing">Programozott felszabadítás?</param>
protected virtual void Dispose(bool disposing)
{
if (_disposed)
{
return;
}
if (disposing)
{
InnerDeleteCommand = null;
InnerInsertCommand = null;
InnerSelectCommand = null;
InnerUpdateCommand = null;
if (DataAdapter != null)
{
DataAdapter.Dispose();
DataAdapter = null;
}
}
_disposed = true;
}
/// <summary>
/// Eldobja az objektumot.
/// </summary>
public void Dispose()
{
Dispose(true);
GC.SuppressFinalize(this);
}
}
}

415
Sda.DataProvider/SDADataReader.cs Normal file
View file

@ -0,0 +1,415 @@
using System;
using System.Data;
using System.Diagnostics.CodeAnalysis;
using SDA.DataProvider.Core;
namespace SDA.DataProvider
{
/// <summary>
/// Adatbázis lekérdezések eredményhalmazának felolvasását végző osztály.
/// </summary>
public class SDADataReader : IDisposable
{
internal SDADataReaderWrapper Reader;
internal SDADataReader()
{
}
internal SDADataReader(SDADataReaderWrapper reader)
{
Reader = reader;
}
bool _disposed;
/// <summary>
/// Explicit destruktor.
/// </summary>
/// <param name="disposing">Programozott felszabadítás?</param>
protected virtual void Dispose(bool disposing)
{
if (_disposed)
{
return;
}
if (disposing)
{
if (Reader != null)
{
Reader.Dispose();
Reader = null;
}
}
_disposed = true;
}
/// <summary>
/// Eldobja az objektumot.
/// </summary>
public void Dispose()
{
Dispose(true);
GC.SuppressFinalize(this);
}
/// <summary>
/// Lezárja az objektumot.
/// </summary>
public void Close()
{
Reader.Close();
}
/// <summary>
/// A következő rekordra áll.
/// </summary>
/// <returns></returns>
public bool Read()
{
return Reader.Read();
}
/// <summary>
/// A következő eredményre áll.
/// </summary>
/// <returns>True, ha van még eredmény; egyébként False.</returns>
public bool NextResult()
{
return Reader.NextResult();
}
/// <summary>
/// Megvizsgálja, hogy a jelenlegi rekord adott oszlopának van-e értéke.
/// </summary>
/// <param name="index">Az oszlop sorszáma</param>
/// <returns>True, ha nincs értéke; egyébként False</returns>
public bool IsDBNull(int index)
{
return Reader.IsDBNull(index);
}
/// <summary>
/// A megadott oszlop értékét logikai típusként adja vissza.
/// </summary>
/// <param name="index">Az oszlop sorszáma</param>
/// <returns>Az oszlop értéke</returns>
public bool GetBoolean(int index)
{
return Reader.GetBoolean(index);
}
/// <summary>
/// A megadott oszlop értékét bájtként adja vissza.
/// </summary>
/// <param name="index">Az oszlop sorszáma</param>
/// <returns>Az oszlop értéke</returns>
public byte GetByte(int index)
{
return Reader.GetByte(index);
}
/// <summary>
/// A megadott oszlop értékét karakterként adja vissza.
/// </summary>
/// <param name="index">Az oszlop sorszáma</param>
/// <returns>Az oszlop értéke</returns>
public char GetChar(int index)
{
return Reader.GetChar(index);
}
/// <summary>
/// A megadott oszlop értékét dátum-időként adja vissza.
/// </summary>
/// <param name="index">Az oszlop sorszáma</param>
/// <returns>Az oszlop értéke</returns>
public DateTime GetDateTime(int index)
{
return Reader.GetDateTime(index);
}
/// <summary>
/// A megadott oszlop értékét számként (decimal) adja vissza.
/// </summary>
/// <param name="index">Az oszlop sorszáma</param>
/// <returns>Az oszlop értéke</returns>
public decimal GetDecimal(int index)
{
return Reader.GetDecimal(index);
}
/// <summary>
/// A megadott oszlop értékét lebegőpontos típusként adja vissza.
/// </summary>
/// <param name="index">Az oszlop sorszáma</param>
/// <returns>Az oszlop értéke</returns>
public double GetDouble(int index)
{
return Reader.GetDouble(index);
}
/// <summary>
/// A megadott oszlop értékét 16 bites előjeles egész típusként adja vissza.
/// </summary>
/// <param name="index">Az oszlop sorszáma</param>
/// <returns>Az oszlop értéke</returns>
public short GetInt16(int index)
{
return Reader.GetInt16(index);
}
/// <summary>
/// A megadott oszlop értékét 32 bites egész típusként adja vissza.
/// </summary>
/// <param name="index">Az oszlop sorszáma</param>
/// <returns>Az oszlop értéke</returns>
public int GetInt32(int index)
{
return Reader.GetInt32(index);
}
/// <summary>
/// A megadott oszlop értékét 64 bites egész típusként adja vissza.
/// </summary>
/// <param name="index">Az oszlop sorszáma</param>
/// <returns>Az oszlop értéke</returns>
public long GetInt64(int index)
{
return Reader.GetInt64(index);
}
/// <summary>
/// A megadott oszlop értékét karakterláncként adja vissza.
/// </summary>
/// <param name="index">Az oszlop sorszáma</param>
/// <returns>Az oszlop értéke</returns>
public string GetString(int index)
{
return Reader.GetString(index);
}
/// <summary>
/// A megadott oszlop értékét karakterláncként adja vissza.
/// </summary>
/// <param name="index">Az oszlop sorszáma</param>
/// <returns>Az oszlop értéke</returns>
public string GetLongString(int index)
{
return Reader.GetLongString(index);
}
/// <summary>
/// A megadott oszlop értékét objektumként adja vissza.
/// </summary>
/// <param name="index">Az oszlop sorszáma</param>
/// <returns>Az oszlop értéke</returns>
public object GetValue(int index)
{
return Reader.GetValue(index);
}
/// <summary>
/// A megadott oszlop Guid értékét adja vissza.
/// </summary>
/// <param name="index">Az oszlop sorszáma</param>
/// <returns>Az oszlop Guid értéke</returns>
public Guid GetGuid(int index)
{
return Reader.GetGuid(index);
}
/// <summary>
/// Visszaadja a jelenlegi rekord összes oszlopának értékét.
/// </summary>
/// <param name="values">Objektumtömb, amibe az értékeket kell másolni</param>
/// <returns>Tömbbe másolt objektumok száma</returns>
public int GetValues(object[] values)
{
return Reader.GetValues(values);
}
/// <summary>
/// Visszaadja az objektum metaadatait.
/// </summary>
/// <returns>Egy DataTable objektum, ami az oszlopok leírását tartalmazza</returns>
[SuppressMessage("Microsoft.Design", "CA1024:UsePropertiesWhereAppropriate")]
public DataTable GetSchemaTable()
{
return Reader.GetSchemaTable();
}
/// <summary>
/// Visszaadja a megadott nevű oszlop értékét.
/// </summary>
public object this[string name] => Reader[name];
/// <summary>
/// Visszaadja a megadott indexű oszlop értékét.
/// </summary>
public object this[int index]
{
get
{
return Reader[index];
}
}
/// <summary>
/// Lezárult-e az olvasás?
/// </summary>
public bool IsClosed
{
get
{
return Reader.IsClosed;
}
}
/// <summary>
/// Az aktuális sor oszlopainak száma.
/// </summary>
public int FieldCount
{
get
{
return Reader.FieldCount;
}
}
/// <summary>
/// Megadja egy mező indexét.
/// </summary>
/// <param name="fieldName">A kért mező neve</param>
/// <returns>Az oszlop indexe</returns>
public int GetOrdinal(string fieldName)
{
return Reader.GetOrdinal(fieldName);
}
#region Nem szabványos kényelmi funkciók
/// <summary>
/// A megadott oszlop értékét logikai típusként adja vissza.
/// </summary>
/// <param name="index">Az oszlop sorszáma</param>
/// <param name="defaultValue">Null esetén mivel térjen vissza.</param>
/// <returns>Az oszlop értéke</returns>
public bool? GetBoolean(int index, bool? defaultValue)
{
return IsDBNull(index) ? defaultValue : Reader.GetBoolean(index);
}
/// <summary>
/// A megadott oszlop értékét bájtként adja vissza.
/// </summary>
/// <param name="index">Az oszlop sorszáma</param>
/// <param name="defaultValue">Null esetén mivel térjen vissza.</param>
/// <returns>Az oszlop értéke</returns>
public byte? GetByte(int index, byte? defaultValue)
{
return IsDBNull(index) ? defaultValue : Reader.GetByte(index);
}
/// <summary>
/// A megadott oszlop értékét karakterként adja vissza.
/// </summary>
/// <param name="index">Az oszlop sorszáma</param>
/// <param name="defaultValue">Null esetén mivel térjen vissza.</param>
/// <returns>Az oszlop értéke</returns>
public char? GetChar(int index, char? defaultValue)
{
return IsDBNull(index) ? defaultValue : Reader.GetChar(index);
}
/// <summary>
/// A megadott oszlop értékét dátum-időként adja vissza.
/// </summary>
/// <param name="index">Az oszlop sorszáma</param>
/// <param name="defaultValue">Null esetén mivel térjen vissza.</param>
/// <returns>Az oszlop értéke</returns>
public DateTime? GetDateTime(int index, DateTime? defaultValue)
{
return IsDBNull(index) ? defaultValue : Reader.GetDateTime(index);
}
/// <summary>
/// A megadott oszlop értékét számként (decimal) adja vissza.
/// </summary>
/// <param name="index">Az oszlop sorszáma</param>
/// <param name="defaultValue">Null esetén mivel térjen vissza.</param>
/// <returns>Az oszlop értéke</returns>
public decimal? GetDecimal(int index, decimal? defaultValue)
{
return IsDBNull(index) ? defaultValue : Reader.GetDecimal(index);
}
/// <summary>
/// A megadott oszlop értékét lebegőpontos típusként adja vissza.
/// </summary>
/// <param name="index">Az oszlop sorszáma</param>
/// <param name="defaultValue">Null esetén mivel térjen vissza.</param>
/// <returns>Az oszlop értéke</returns>
public double? GetDouble(int index, double? defaultValue)
{
return IsDBNull(index) ? defaultValue : Reader.GetDouble(index);
}
/// <summary>
/// A megadott oszlop értékét 16 bites előjeles egész típusként adja vissza.
/// </summary>
/// <param name="index">Az oszlop sorszáma</param>
/// <param name="defaultValue">Null esetén mivel térjen vissza.</param>
/// <returns>Az oszlop értéke</returns>
public short? GetInt16(int index, short? defaultValue)
{
return IsDBNull(index) ? defaultValue : Reader.GetInt16(index);
}
/// <summary>
/// A megadott oszlop értékét 32 bites egész típusként adja vissza.
/// </summary>
/// <param name="index">Az oszlop sorszáma</param>
/// <param name="defaultValue">Null esetén mivel térjen vissza.</param>
/// <returns>Az oszlop értéke</returns>
public int? GetInt32(int index, int? defaultValue)
{
return IsDBNull(index) ? defaultValue : Reader.GetInt32(index);
}
/// <summary>
/// A megadott oszlop értékét 64 bites egész típusként adja vissza.
/// </summary>
/// <param name="index">Az oszlop sorszáma</param>
/// <param name="defaultValue">Null esetén mivel térjen vissza.</param>
/// <returns>Az oszlop értéke</returns>
public long? GetInt64(int index, long? defaultValue)
{
return IsDBNull(index) ? defaultValue : Reader.GetInt64(index);
}
/// <summary>
/// A megadott oszlop értékét karakterláncként adja vissza.
/// </summary>
/// <param name="index">Az oszlop sorszáma</param>
/// <param name="defaultValue">Null esetén mivel térjen vissza.</param>
/// <returns>Az oszlop értéke</returns>
public string GetString(int index, string defaultValue)
{
return IsDBNull(index) ? defaultValue : Reader.GetString(index);
}
/// <summary>
/// A megadott oszlop értékét objektumként adja vissza.
/// </summary>
/// <param name="index">Az oszlop sorszáma</param>
/// <param name="defaultValue">Null esetén mivel térjen vissza.</param>
/// <returns>Az oszlop értéke</returns>
public object GetValue(int index, object defaultValue)
{
return IsDBNull(index) ? defaultValue : Reader.GetValue(index);
}
#endregion
}
}

93
Sda.DataProvider/SDATransaction.cs Normal file
View file

@ -0,0 +1,93 @@
using System;
using System.Data;
using SDA.DataProvider.Core;
namespace SDA.DataProvider
{
/// <summary>
/// Adatbázis-ügylet
/// </summary>
public class SDATransaction : IDbTransaction
{
internal SDATransactionWrapper Transaction;
internal SDATransaction(SDATransactionWrapper transaction)
{
Transaction = transaction;
}
bool _disposed;
/// <summary>
/// Explicit destruktor.
/// </summary>
/// <param name="disposing">Programozott felszabadítás?</param>
protected virtual void Dispose(bool disposing)
{
if (_disposed)
{
return;
}
if (disposing)
{
if (Transaction != null)
{
Transaction.Dispose();
Transaction = null;
}
}
_disposed = true;
}
/// <summary>
/// Eldobja az ügyletet.
/// </summary>
public void Dispose()
{
Dispose(true);
GC.SuppressFinalize(this);
}
#region IDbTransaction Members
/// <summary>
/// Az ügylethez tartozó adatbázis-kapcsolat.
/// </summary>
public IDbConnection Connection
{
get
{
return Transaction.Connection;
}
}
/// <summary>
/// Az elválasztás szintje.
/// </summary>
public IsolationLevel IsolationLevel
{
get
{
return Transaction.IsolationLevel;
}
}
/// <summary>
/// Elköveti az ügyletet.
/// </summary>
public void Commit()
{
Transaction.Commit();
}
/// <summary>
/// Visszagörgeti az ügyletet.
/// </summary>
public void Rollback()
{
Transaction.Rollback();
}
#endregion
}
}

228
Sda.DataProvider/Sda.DataProvider.csproj Normal file
View file

@ -0,0 +1,228 @@
<?xml version="1.0" encoding="utf-8"?>
<Project DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003" ToolsVersion="12.0">
<PropertyGroup>
<ProjectType>Local</ProjectType>
<ProductVersion>9.0.30729</ProductVersion>
<ProjectGuid>{9AC4FD13-81F5-48AC-AA21-BA774C4DC771}</ProjectGuid>
<SccProjectName>SAK</SccProjectName>
<SccLocalPath>SAK</SccLocalPath>
<SccAuxPath>SAK</SccAuxPath>
<SccProvider>SAK</SccProvider>
<Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
<Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
<ApplicationIcon>
</ApplicationIcon>
<AssemblyKeyContainerName>
</AssemblyKeyContainerName>
<AssemblyName>Sda.DataProvider</AssemblyName>
<AssemblyOriginatorKeyFile>
</AssemblyOriginatorKeyFile>
<DefaultClientScript>JScript</DefaultClientScript>
<DefaultHTMLPageLayout>Grid</DefaultHTMLPageLayout>
<DefaultTargetSchema>IE50</DefaultTargetSchema>
<DelaySign>false</DelaySign>
<OutputType>Library</OutputType>
<RootNamespace>SDA.DataProvider</RootNamespace>
<RunPostBuildEvent>OnBuildSuccess</RunPostBuildEvent>
<StartupObject>
</StartupObject>
<FileUpgradeFlags>
</FileUpgradeFlags>
<UpgradeBackupLocation>
</UpgradeBackupLocation>
<TargetFrameworkVersion>v4.8</TargetFrameworkVersion>
<PublishUrl>publish\</PublishUrl>
<Install>true</Install>
<InstallFrom>Disk</InstallFrom>
<UpdateEnabled>false</UpdateEnabled>
<UpdateMode>Foreground</UpdateMode>
<UpdateInterval>7</UpdateInterval>
<UpdateIntervalUnits>Days</UpdateIntervalUnits>
<UpdatePeriodically>false</UpdatePeriodically>
<UpdateRequired>false</UpdateRequired>
<MapFileExtensions>true</MapFileExtensions>
<ApplicationRevision>0</ApplicationRevision>
<ApplicationVersion>1.0.0.%2a</ApplicationVersion>
<IsWebBootstrapper>false</IsWebBootstrapper>
<UseApplicationTrust>false</UseApplicationTrust>
<BootstrapperEnabled>true</BootstrapperEnabled>
<TargetFrameworkProfile />
<CodeContractsAssemblyMode>0</CodeContractsAssemblyMode>
<ResolveAssemblyWarnOrErrorOnTargetArchitectureMismatch>None</ResolveAssemblyWarnOrErrorOnTargetArchitectureMismatch>
</PropertyGroup>
<PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
<OutputPath>bin\Debug\</OutputPath>
<AllowUnsafeBlocks>false</AllowUnsafeBlocks>
<BaseAddress>285212672</BaseAddress>
<CheckForOverflowUnderflow>false</CheckForOverflowUnderflow>
<ConfigurationOverrideFile>
</ConfigurationOverrideFile>
<DefineConstants>TRACE;DEBUG;CODE_ANALYSIS;JETBRAINS_ANNOTATIONS</DefineConstants>
<DocumentationFile>
</DocumentationFile>
<DebugSymbols>true</DebugSymbols>
<FileAlignment>4096</FileAlignment>
<NoStdLib>false</NoStdLib>
<NoWarn>
</NoWarn>
<Optimize>false</Optimize>
<RegisterForComInterop>false</RegisterForComInterop>
<RemoveIntegerChecks>false</RemoveIntegerChecks>
<TreatWarningsAsErrors>false</TreatWarningsAsErrors>
<WarningLevel>4</WarningLevel>
<DebugType>full</DebugType>
<ErrorReport>prompt</ErrorReport>
<UseVSHostingProcess>true</UseVSHostingProcess>
<CodeContractsEnableRuntimeChecking>False</CodeContractsEnableRuntimeChecking>
<CodeContractsRuntimeOnlyPublicSurface>False</CodeContractsRuntimeOnlyPublicSurface>
<CodeContractsRuntimeThrowOnFailure>True</CodeContractsRuntimeThrowOnFailure>
<CodeContractsRuntimeCallSiteRequires>False</CodeContractsRuntimeCallSiteRequires>
<CodeContractsRuntimeSkipQuantifiers>False</CodeContractsRuntimeSkipQuantifiers>
<CodeContractsNonNullObligations>False</CodeContractsNonNullObligations>
<CodeContractsBoundsObligations>False</CodeContractsBoundsObligations>
<CodeContractsArithmeticObligations>False</CodeContractsArithmeticObligations>
<CodeContractsEnumObligations>False</CodeContractsEnumObligations>
<CodeContractsRedundantAssumptions>False</CodeContractsRedundantAssumptions>
<CodeContractsInferRequires>False</CodeContractsInferRequires>
<CodeContractsInferEnsures>False</CodeContractsInferEnsures>
<CodeContractsInferObjectInvariants>False</CodeContractsInferObjectInvariants>
<CodeContractsSuggestAssumptions>False</CodeContractsSuggestAssumptions>
<CodeContractsSuggestRequires>True</CodeContractsSuggestRequires>
<CodeContractsSuggestEnsures>False</CodeContractsSuggestEnsures>
<CodeContractsSuggestObjectInvariants>False</CodeContractsSuggestObjectInvariants>
<CodeContractsRunInBackground>True</CodeContractsRunInBackground>
<CodeContractsShowSquigglies>True</CodeContractsShowSquigglies>
<CodeContractsUseBaseLine>False</CodeContractsUseBaseLine>
<CodeContractsEmitXMLDocs>False</CodeContractsEmitXMLDocs>
<CodeContractsCustomRewriterAssembly />
<CodeContractsCustomRewriterClass />
<CodeContractsLibPaths />
<CodeContractsExtraRewriteOptions />
<CodeContractsExtraAnalysisOptions />
<CodeContractsBaseLineFile />
<CodeContractsCacheAnalysisResults>True</CodeContractsCacheAnalysisResults>
<CodeContractsRuntimeCheckingLevel>Full</CodeContractsRuntimeCheckingLevel>
<CodeContractsReferenceAssembly>DoNotBuild</CodeContractsReferenceAssembly>
<CodeContractsAnalysisWarningLevel>0</CodeContractsAnalysisWarningLevel>
<Prefer32Bit>false</Prefer32Bit>
</PropertyGroup>
<PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
<OutputPath>bin\Release\</OutputPath>
<AllowUnsafeBlocks>false</AllowUnsafeBlocks>
<BaseAddress>285212672</BaseAddress>
<CheckForOverflowUnderflow>false</CheckForOverflowUnderflow>
<ConfigurationOverrideFile>
</ConfigurationOverrideFile>
<DefineConstants>TRACE;CODE_ANALYSIS;JETBRAINS_ANNOTATIONS</DefineConstants>
<DocumentationFile>bin\Release\Sda.DataProvider.XML</DocumentationFile>
<DebugSymbols>true</DebugSymbols>
<FileAlignment>4096</FileAlignment>
<NoStdLib>false</NoStdLib>
<NoWarn>
</NoWarn>
<Optimize>true</Optimize>
<RegisterForComInterop>false</RegisterForComInterop>
<RemoveIntegerChecks>false</RemoveIntegerChecks>
<TreatWarningsAsErrors>false</TreatWarningsAsErrors>
<WarningLevel>4</WarningLevel>
<DebugType>pdbonly</DebugType>
<ErrorReport>prompt</ErrorReport>
<UseVSHostingProcess>true</UseVSHostingProcess>
<CodeContractsEnableRuntimeChecking>False</CodeContractsEnableRuntimeChecking>
<CodeContractsRuntimeOnlyPublicSurface>False</CodeContractsRuntimeOnlyPublicSurface>
<CodeContractsRuntimeThrowOnFailure>True</CodeContractsRuntimeThrowOnFailure>
<CodeContractsRuntimeCallSiteRequires>False</CodeContractsRuntimeCallSiteRequires>
<CodeContractsRuntimeSkipQuantifiers>False</CodeContractsRuntimeSkipQuantifiers>
<CodeContractsNonNullObligations>False</CodeContractsNonNullObligations>
<CodeContractsBoundsObligations>False</CodeContractsBoundsObligations>
<CodeContractsArithmeticObligations>False</CodeContractsArithmeticObligations>
<CodeContractsEnumObligations>False</CodeContractsEnumObligations>
<CodeContractsRedundantAssumptions>False</CodeContractsRedundantAssumptions>
<CodeContractsInferRequires>False</CodeContractsInferRequires>
<CodeContractsInferEnsures>False</CodeContractsInferEnsures>
<CodeContractsInferObjectInvariants>False</CodeContractsInferObjectInvariants>
<CodeContractsSuggestAssumptions>False</CodeContractsSuggestAssumptions>
<CodeContractsSuggestRequires>True</CodeContractsSuggestRequires>
<CodeContractsSuggestEnsures>False</CodeContractsSuggestEnsures>
<CodeContractsSuggestObjectInvariants>False</CodeContractsSuggestObjectInvariants>
<CodeContractsRunInBackground>True</CodeContractsRunInBackground>
<CodeContractsShowSquigglies>True</CodeContractsShowSquigglies>
<CodeContractsUseBaseLine>False</CodeContractsUseBaseLine>
<CodeContractsEmitXMLDocs>False</CodeContractsEmitXMLDocs>
<CodeContractsCustomRewriterAssembly />
<CodeContractsCustomRewriterClass />
<CodeContractsLibPaths />
<CodeContractsExtraRewriteOptions />
<CodeContractsExtraAnalysisOptions />
<CodeContractsBaseLineFile />
<CodeContractsCacheAnalysisResults>True</CodeContractsCacheAnalysisResults>
<CodeContractsRuntimeCheckingLevel>Full</CodeContractsRuntimeCheckingLevel>
<CodeContractsReferenceAssembly>DoNotBuild</CodeContractsReferenceAssembly>
<CodeContractsAnalysisWarningLevel>0</CodeContractsAnalysisWarningLevel>
<Prefer32Bit>false</Prefer32Bit>
</PropertyGroup>
<PropertyGroup>
<SignAssembly>false</SignAssembly>
</PropertyGroup>
<ItemGroup>
<Reference Include="JetBrains.Annotations, Version=10.4.0.0, Culture=neutral, PublicKeyToken=1010a0d8d6380325, processorArchitecture=MSIL">
<HintPath>..\packages\JetBrains.Annotations.10.4.0\lib\net\JetBrains.Annotations.dll</HintPath>
</Reference>
<Reference Include="Microsoft.CSharp" />
<Reference Include="System" />
<Reference Include="System.ComponentModel.Composition" />
<Reference Include="System.Core" />
<Reference Include="System.Data" />
<Reference Include="System.Data.DataSetExtensions" />
<Reference Include="System.Runtime.Serialization" />
<Reference Include="System.Xml" />
</ItemGroup>
<ItemGroup>
<Compile Include="..\Tools\SharedAssemblyInfo.cs">
<Link>Properties\SharedAssemblyInfo.cs</Link>
</Compile>
<Compile Include="CommandExecutedEventArgs.cs" />
<Compile Include="ExecutionType.cs" />
<Compile Include="Wrappers\MSSQL\MSSQLBulkAdapter.cs" />
<Compile Include="Properties\AssemblyInfo.cs" />
<Compile Include="Configuration.cs" />
<Compile Include="Core\SDACommandBuilderWrapper.cs" />
<Compile Include="Core\SDACommandParameterCollectionWrapper.cs" />
<Compile Include="Core\SDACommandParameterWrapper.cs" />
<Compile Include="Core\SDACommandWrapper.cs" />
<Compile Include="Core\SDAConnectionWrapper.cs" />
<Compile Include="Core\SDADataAdapterWrapper.cs" />
<Compile Include="Core\SDAFactory.cs" />
<Compile Include="Core\SDADataReaderWrapper.cs" />
<Compile Include="Core\SDATransactionWrapper.cs" />
<Compile Include="DatabaseType.cs" />
<Compile Include="SDAConnectionDiagnostics.cs" />
<Compile Include="Exceptions.cs" />
<Compile Include="Factories\MSSQLFactory.cs" />
<Compile Include="Initializer.cs" />
<Compile Include="SDABulkAdapter.cs" />
<Compile Include="SDACommand.cs" />
<Compile Include="SDACommandBuilder.cs" />
<Compile Include="SDACommandParameter.cs" />
<Compile Include="SDACommandParameterCollection.cs" />
<Compile Include="SDAConnection.cs" />
<Compile Include="SDADataAdapter.cs" />
<Compile Include="SDADataReader.cs" />
<Compile Include="SDADBType.cs" />
<Compile Include="SDATransaction.cs" />
<Compile Include="Wrappers\MSSQL\MSSQLCommandBuilderWrapper.cs" />
<Compile Include="Wrappers\MSSQL\MSSQLCommandParameterCollectionWrapper.cs" />
<Compile Include="Wrappers\MSSQL\MSSQLCommandParameterWrapper.cs" />
<Compile Include="Wrappers\MSSQL\MSSQLCommandWrapper.cs" />
<Compile Include="Wrappers\MSSQL\MSSQLConnectionStringBuilderWrapper.cs" />
<Compile Include="Wrappers\MSSQL\MSSQLConnectionWrapper.cs" />
<Compile Include="Wrappers\MSSQL\MSSQLDataAdapterWrapper.cs" />
<Compile Include="Wrappers\MSSQL\MSSQLDataReaderWrapper.cs" />
<Compile Include="Wrappers\MSSQL\MSSQLExceptionHelper.cs" />
<Compile Include="Wrappers\MSSQL\MSSQLTransactionWrapper.cs" />
</ItemGroup>
<ItemGroup>
<None Include="packages.config" />
</ItemGroup>
<Import Project="$(MSBuildBinPath)\Microsoft.CSharp.targets" />
</Project>

59
Sda.DataProvider/Wrappers/MSSQL/MSSQLBulkAdapter.cs Normal file
View file

@ -0,0 +1,59 @@
using System;
using System.Data;
using System.Data.SqlClient;
using JetBrains.Annotations;
namespace SDA.DataProvider.MSSQLWrappers
{
/// <summary>
/// Microsoft SQL Server alapú bulk insert implementáció.
/// </summary>
public class MSSQLBulkAdapter : SDABulkAdapter
{
private readonly SqlBulkCopy bulkCopy;
/// <summary>
/// Létrehoz egy Microsoft SQL Server specifikus bulk adapter példányt.
/// </summary>
/// <param name="bulkCopy">Egy SQL Server SqlBulkCopy példány, a
/// tényleges bulk implementáció.</param>
/// <exception cref="ArgumentNullException">Ha a kapott paraméter null.
/// </exception>
internal MSSQLBulkAdapter([NotNull] SqlBulkCopy bulkCopy)
{
if (bulkCopy == null)
{
throw new ArgumentNullException(nameof(bulkCopy));
}
this.bulkCopy = bulkCopy;
}
/// <inheritdoc />
public override void BulkInsert(DataTable source)
{
if (string.IsNullOrWhiteSpace(source.TableName))
{
throw new ArgumentException("TableName property must be set to the target table name", nameof(source));
}
if (source.Columns.Count == 0)
{
throw new ArgumentException("should contain at least 1 column to bulk insert", nameof(source));
}
if (source.Rows.Count == 0)
{
return;
}
bulkCopy.DestinationTableName = source.TableName;
bulkCopy.WriteToServer(source);
//bulkCopy.NotifyAfter = 1000;
//bulkCopy.SqlRowsCopied += (sender, args) =>
//{
//};
}
}
}

69
Sda.DataProvider/Wrappers/MSSQL/MSSQLCommandBuilderWrapper.cs Normal file
View file

@ -0,0 +1,69 @@
using System.Data.SqlClient;
using System.Diagnostics.CodeAnalysis;
using SDA.DataProvider.Core;
namespace SDA.DataProvider.MSSQLWrappers
{
class MSSQLCommandBuilderWrapper : SDACommandBuilderWrapper
{
internal SqlCommandBuilder CommandBuilder;
internal MSSQLDataAdapterWrapper InnerDataAdapter;
internal MSSQLCommandBuilderWrapper()
{
CommandBuilder = new SqlCommandBuilder();
}
[SuppressMessage("Microsoft.Usage", "CA2214:DoNotCallOverridableMethodsInConstructors")]
internal MSSQLCommandBuilderWrapper(SDADataAdapterWrapper dataAdapter)
: this()
{
// ReSharper disable once DoNotCallOverridableMethodsInConstructor
DataAdapter = dataAdapter;
}
protected override SDADataAdapterWrapper DataAdapter
{
get
{
return InnerDataAdapter;
}
set
{
InnerDataAdapter = (MSSQLDataAdapterWrapper)value;
CommandBuilder.DataAdapter = InnerDataAdapter.DataAdapter;
}
}
public override void DeriveParameters(SDACommandWrapper command)
{
SqlCommandBuilder.DeriveParameters(((MSSQLCommandWrapper)command).Command);
}
public override SDACommandWrapper GetDeleteCommand()
{
return new MSSQLCommandWrapper(CommandBuilder.GetDeleteCommand());
}
public override SDACommandWrapper GetInsertCommand()
{
return new MSSQLCommandWrapper(CommandBuilder.GetInsertCommand());
}
public override SDACommandWrapper GetUpdateCommand()
{
return new MSSQLCommandWrapper(CommandBuilder.GetUpdateCommand());
}
public override void RefreshSchema()
{
CommandBuilder.RefreshSchema();
}
public override void Dispose()
{
CommandBuilder.Dispose();
}
}
}

108
Sda.DataProvider/Wrappers/MSSQL/MSSQLCommandParameterCollectionWrapper.cs Normal file
View file

@ -0,0 +1,108 @@
using System.Data;
using System.Data.SqlClient;
using SDA.DataProvider.Core;
namespace SDA.DataProvider.MSSQLWrappers
{
class MSSQLCommandParameterCollectionWrapper : SDACommandParameterCollectionWrapper
{
internal SqlParameterCollection Parameters
{
get
{
return Command.Parameters;
}
}
public override bool Contains(SDACommandParameterWrapper parameter)
{
return Parameters.Contains("@" + parameter.ParameterName);
}
public override int IndexOf(SDACommandParameterWrapper parameter)
{
return Parameters.IndexOf("@" + parameter.ParameterName);
}
internal SqlCommand Command;
internal MSSQLCommandParameterCollectionWrapper(SqlCommand command)
{
Command = command;
}
public override SDACommandParameterWrapper this[string parameterName]
{
get
{
if (!Parameters.Contains("@" + parameterName))
{
return null;
}
SqlParameter parameter = Parameters["@" + parameterName];
return new MSSQLCommandParameterWrapper(parameter);
}
set
{
Parameters["@" + parameterName] = ((MSSQLCommandParameterWrapper)value).Parameter;
}
}
public override SDACommandParameterWrapper this[int index]
{
get
{
return new MSSQLCommandParameterWrapper(Parameters[index]);
}
set
{
Parameters[index] = ((MSSQLCommandParameterWrapper)value).Parameter;
}
}
public override SDACommandParameterWrapper Add(SDACommandParameterWrapper parameter)
{
Parameters.Add(((MSSQLCommandParameterWrapper)parameter).Parameter);
return parameter;
}
public override SDACommandParameterWrapper Add(string name, SDADBType type)
{
SqlDbType dbtype = MSSQLParameterTypeConverter.ConvertSDADBTypeToSqlDbType(type);
MSSQLCommandParameterWrapper result = new MSSQLCommandParameterWrapper(Command.Parameters.Add("@" + name, dbtype));
return result;
}
public override SDACommandParameterWrapper Add(string name, SDADBType type, int size)
{
SqlDbType dbtype = MSSQLParameterTypeConverter.ConvertSDADBTypeToSqlDbType(type);
MSSQLCommandParameterWrapper result = new MSSQLCommandParameterWrapper(Command.Parameters.Add("@" + name, dbtype, size));
return result;
}
public override SDACommandParameterWrapper Add(string name, object value)
{
MSSQLCommandParameterWrapper result = new MSSQLCommandParameterWrapper(Command.Parameters.AddWithValue("@" + name, value));
return result;
}
public override void Remove(SDACommandParameterWrapper parameter)
{
Command.Parameters.Remove(((MSSQLCommandParameterWrapper)parameter).Parameter);
}
public override void Clear()
{
Command.Parameters.Clear();
}
public override int Count
{
get
{
return Parameters.Count;
}
}
}
}

148
Sda.DataProvider/Wrappers/MSSQL/MSSQLCommandParameterWrapper.cs Normal file
View file

@ -0,0 +1,148 @@
using System;
using System.Data;
using System.Data.SqlClient;
using System.Globalization;
using SDA.DataProvider.Core;
namespace SDA.DataProvider.MSSQLWrappers
{
class MSSQLCommandParameterWrapper : SDACommandParameterWrapper
{
internal SqlParameter Parameter;
internal MSSQLCommandParameterWrapper(SqlParameter parameter)
{
Parameter = parameter;
}
protected override IDbDataParameter WrappedParameter
{
get
{
return Parameter;
}
}
public override object Value
{
get
{
return Parameter.Value;
}
set
{
if (value is bool boolean)
{
Parameter.Value = boolean ? 'T' : 'F';
}
else
{
Parameter.Value = value;
}
}
}
public override SDADBType DBType
{
get
{
return MSSQLParameterTypeConverter.ConvertSqlDbTypeToSDADBType(Parameter.SqlDbType);
}
set
{
Parameter.SqlDbType = MSSQLParameterTypeConverter.ConvertSDADBTypeToSqlDbType(value);
}
}
}
class MSSQLParameterTypeConverter
{
public static SqlDbType ConvertSDADBTypeToSqlDbType(SDADBType type)
{
switch (type)
{
case SDADBType.Int:
return SqlDbType.Int;
case SDADBType.String:
return SqlDbType.NVarChar;
case SDADBType.Binary:
return SqlDbType.Image;
case SDADBType.Char:
return SqlDbType.NChar;
case SDADBType.DateTime:
return SqlDbType.DateTime;
case SDADBType.Double:
return SqlDbType.Float;
case SDADBType.Boolean:
return SqlDbType.Char;
case SDADBType.LongString:
return SqlDbType.NText;
case SDADBType.LongInt:
return SqlDbType.BigInt;
case SDADBType.NonUnicodeString:
return SqlDbType.VarChar;
case SDADBType.Guid:
return SqlDbType.UniqueIdentifier;
default:
throw new NotImplementedException(type.ToString());
}
}
public static SDADBType ConvertSqlDbTypeToSDADBType(SqlDbType type)
{
switch (type)
{
case SqlDbType.BigInt:
return SDADBType.LongInt;
case SqlDbType.Binary:
return SDADBType.Binary;
case SqlDbType.Bit:
return SDADBType.Boolean;
case SqlDbType.Char:
return SDADBType.Char;
case SqlDbType.DateTime:
return SDADBType.DateTime;
case SqlDbType.Decimal:
throw new NotSupportedException(string.Format(CultureInfo.InvariantCulture, "Conversion from '{0}' is not supported.", type));
case SqlDbType.Float:
return SDADBType.Double;
case SqlDbType.Image:
return SDADBType.Binary;
case SqlDbType.Int:
return SDADBType.Int;
case SqlDbType.Money:
throw new NotSupportedException(string.Format(CultureInfo.InvariantCulture, "Conversion from '{0}' is not supported.", type));
case SqlDbType.NChar:
return SDADBType.Char;
case SqlDbType.NText:
return SDADBType.LongString;
case SqlDbType.NVarChar:
return SDADBType.String;
case SqlDbType.Real:
return SDADBType.Double;
case SqlDbType.SmallDateTime:
return SDADBType.DateTime;
case SqlDbType.SmallInt:
return SDADBType.Int;
case SqlDbType.SmallMoney:
throw new NotSupportedException(string.Format(CultureInfo.InvariantCulture, "Conversion from '{0}' is not supported.", type));
case SqlDbType.Text:
return SDADBType.LongString;
case SqlDbType.Timestamp:
throw new NotSupportedException(string.Format(CultureInfo.InvariantCulture, "Conversion from '{0}' is not supported.", type));
case SqlDbType.TinyInt:
throw new NotSupportedException(string.Format(CultureInfo.InvariantCulture, "Conversion from '{0}' is not supported.", type));
case SqlDbType.UniqueIdentifier:
return SDADBType.Guid;
case SqlDbType.VarBinary:
throw new NotSupportedException(string.Format(CultureInfo.InvariantCulture, "Conversion from '{0}' is not supported.", type));
case SqlDbType.VarChar:
return SDADBType.NonUnicodeString;
case SqlDbType.Variant:
throw new NotSupportedException(string.Format(CultureInfo.InvariantCulture, "Conversion from '{0}' is not supported.", type));
default:
throw new NotImplementedException(type.ToString());
}
}
}
}

206
Sda.DataProvider/Wrappers/MSSQL/MSSQLCommandWrapper.cs Normal file
View file

@ -0,0 +1,206 @@
using System;
using System.Data;
using System.Data.SqlClient;
using System.Diagnostics.CodeAnalysis;
using SDA.DataProvider.Core;
namespace SDA.DataProvider.MSSQLWrappers
{
class MSSQLCommandWrapper : SDACommandWrapper
{
internal SqlCommand Command;
internal MSSQLConnectionWrapper ConnectionWrapper;
internal MSSQLCommandParameterCollectionWrapper InnerParameters;
internal MSSQLTransactionWrapper InnerTransaction;
internal MSSQLCommandWrapper()
{
try
{
// ReSharper disable once UseObjectOrCollectionInitializer
Command = new SqlCommand();
Command.CommandTimeout = 300;
InnerParameters = new MSSQLCommandParameterCollectionWrapper(Command);
}
catch
{
if (Command != null)
{
Command.Dispose();
}
throw;
}
}
internal MSSQLCommandWrapper(SqlCommand command)
{
Command = command;
Command.CommandTimeout = 300;
InnerParameters = new MSSQLCommandParameterCollectionWrapper(Command);
}
protected override IDbCommand WrappedCommand
{
get
{
return Command;
}
}
string SafeGetParametersText()
{
string result = "";
for (int i = 0; i < Command.Parameters.Count; i++)
{
result += Command.Parameters[i].ParameterName + "=";
if (Command.Parameters[i].Value == null)
{
result += @"csharpnull, ";
}
else if (Command.Parameters[i].Value == DBNull.Value)
{
result += @"DBNULL, ";
}
else
{
result += "[" + Command.Parameters[i].Value + "], ";
}
}
return result;
}
string SafeGetCommandText()
{
if (Command != null)
{
return Command.CommandText + "\n" + SafeGetParametersText();
}
return "";
}
public override SDAConnectionWrapper Connection
{
get
{
return ConnectionWrapper;
}
set
{
MSSQLConnectionWrapper connection = value as MSSQLConnectionWrapper;
ConnectionWrapper = connection;
Command.Connection = connection?.Connection;
}
}
[SuppressMessage("Microsoft.Security", "CA2100:Review SQL queries for security vulnerabilities")]
public override string CommandText
{
get
{
string temp = Command.CommandText.Replace("@p", ":p");
return temp;
}
set
{
if (value == null)
{
Command.CommandText = "";
return;
}
string temp = value.Replace(":p", "@p");
Command.CommandText = temp;
}
}
public override int ExecuteNonQuery()
{
try
{
return Command.ExecuteNonQuery();
}
catch (SqlException exception)
{
throw MSSQLExceptionHelper.TranslateSqlException(exception, SafeGetCommandText());
}
}
public override SDADataReaderWrapper ExecuteReader()
{
try
{
return new MSSQLDataReaderWrapper(Command.ExecuteReader());
}
catch (SqlException exception)
{
throw MSSQLExceptionHelper.TranslateSqlException(exception, SafeGetCommandText());
}
}
public override SDADataReaderWrapper ExecuteReader(CommandBehavior commandBehavior)
{
try
{
return new MSSQLDataReaderWrapper(Command.ExecuteReader(commandBehavior));
}
catch (SqlException exception)
{
throw MSSQLExceptionHelper.TranslateSqlException(exception, SafeGetCommandText());
}
}
public override object ExecuteScalar()
{
try
{
return Command.ExecuteScalar();
}
catch (SqlException exception)
{
throw MSSQLExceptionHelper.TranslateSqlException(exception, SafeGetCommandText());
}
}
public override SDATransactionWrapper Transaction
{
get
{
return InnerTransaction;
}
set
{
MSSQLTransactionWrapper transaction = value as MSSQLTransactionWrapper;
InnerTransaction = transaction;
Command.Transaction = transaction?.Transaction;
}
}
bool _disposed;
protected override void Dispose(bool disposing)
{
if (_disposed)
{
return;
}
base.Dispose(disposing);
if (disposing)
{
if (Command != null)
{
Command.Dispose();
Command = null;
}
}
_disposed = true;
}
public override SDACommandParameterCollectionWrapper Parameters
{
get
{
return InnerParameters;
}
}
}
}

61
Sda.DataProvider/Wrappers/MSSQL/MSSQLConnectionStringBuilderWrapper.cs Normal file
View file

@ -0,0 +1,61 @@
using System;
using System.Data.SqlClient;
namespace SDA.DataProvider.Wrappers.MSSQL
{
internal class MSSQLConnectionStringBuilderWrapper : IDisposable
{
SqlConnectionStringBuilder builder;
public MSSQLConnectionStringBuilderWrapper(string connectionstring)
{
builder = new SqlConnectionStringBuilder(connectionstring);
GenerateConnectionString();
}
public string ConnectionString
{
get
{
return builder.ConnectionString;
}
set
{
builder.ConnectionString = value;
GenerateConnectionString();
}
}
/// <summary>
/// ha megvan adva ConnectionTimeout a konfigban, akkor felülírja a connection stringet
/// </summary>
void GenerateConnectionString()
{
if (Configuration.ConnectionTimeout.HasValue
&& builder.ConnectionString.IndexOf("Connect Timeout", StringComparison.OrdinalIgnoreCase) == -1)
{
ConnectionTimeout = Configuration.ConnectionTimeout.Value;
}
}
public void Dispose()
{
builder = null;
}
public int ConnectionTimeout
{
get
{
return builder.ConnectTimeout;
}
set
{
builder.ConnectTimeout = value;
}
}
}
}

182
Sda.DataProvider/Wrappers/MSSQL/MSSQLConnectionWrapper.cs Normal file
View file

@ -0,0 +1,182 @@
using System.Data;
using System.Data.SqlClient;
using SDA.DataProvider.Core;
using SDA.DataProvider.Wrappers.MSSQL;
namespace SDA.DataProvider.MSSQLWrappers
{
class MSSQLConnectionWrapper : SDAConnectionWrapper
{
internal SqlConnection Connection;
internal MSSQLConnectionStringBuilderWrapper ConnectionStringBuilder;
protected override IDbConnection WrappedConnection
{
get
{
return Connection;
}
}
public MSSQLConnectionWrapper()
{
Connection = new SqlConnection();
}
public MSSQLConnectionWrapper(string connectionString)
{
try
{
ConnectionStringBuilder = new MSSQLConnectionStringBuilderWrapper(connectionString);
Connection = new SqlConnection(ConnectionStringBuilder.ConnectionString);
}
catch (SqlException exception)
{
throw MSSQLExceptionHelper.TranslateSqlException(exception);
}
}
public override void Dispose()
{
ConnectionStringBuilder.Dispose();
Connection.Dispose();
ConnectionStringBuilder = null;
Connection = null;
}
public override void Open()
{
try
{
Connection.Open();
}
catch (SqlException exception)
{
throw MSSQLExceptionHelper.TranslateSqlException(exception);
}
}
/// <inheritdoc />
public override SDABulkAdapter CreateBulkAdapter(SDATransaction transaction = null)
{
SqlBulkCopy sqlBulkCopy;
if (transaction == null)
{
sqlBulkCopy = new SqlBulkCopy(Connection);
}
else
{
sqlBulkCopy = new SqlBulkCopy(Connection, SqlBulkCopyOptions.Default, (SqlTransaction)transaction.Transaction.NativeTransaction);
}
return new MSSQLBulkAdapter(sqlBulkCopy);
}
/// <inheritdoc />
public override void ResetConnectionPool(bool all = false)
{
if (all)
{
SqlConnection.ClearAllPools();
}
else
{
SqlConnection.ClearPool(Connection);
}
}
public override SDATransactionWrapper BeginTransaction()
{
try
{
return new MSSQLTransactionWrapper(this, Connection.BeginTransaction());
}
catch (SqlException exception)
{
throw MSSQLExceptionHelper.TranslateSqlException(exception);
}
}
public override SDATransactionWrapper BeginTransaction(IsolationLevel isolationLevel)
{
try
{
return new MSSQLTransactionWrapper(this, Connection.BeginTransaction(isolationLevel));
}
catch (SqlException exception)
{
throw MSSQLExceptionHelper.TranslateSqlException(exception);
}
}
public override SDACommandWrapper CreateCommand()
{
MSSQLCommandWrapper result = null;
try
{
// ReSharper disable once UseObjectOrCollectionInitializer
result = new MSSQLCommandWrapper();
result.Connection = this;
return result;
}
catch
{
if (result != null)
{
result.Dispose();
}
throw;
}
}
public override string ConnectionString
{
get
{
return Connection.ConnectionString;
}
set
{
try
{
if (ConnectionStringBuilder == null)
{
ConnectionStringBuilder = new MSSQLConnectionStringBuilderWrapper(value);
}
else
{
ConnectionStringBuilder.ConnectionString = value;
}
Connection.ConnectionString = ConnectionStringBuilder.ConnectionString;
}
catch (SqlException exception)
{
throw MSSQLExceptionHelper.TranslateSqlException(exception);
}
}
}
public override int ConnectionTimeout
{
get
{
return Connection.ConnectionTimeout;
}
}
public override void ChangeDatabase(string databaseName)
{
try
{
Connection.ChangeDatabase(databaseName);
}
catch (SqlException exception)
{
throw MSSQLExceptionHelper.TranslateSqlException(exception);
}
}
}
}

262
Sda.DataProvider/Wrappers/MSSQL/MSSQLDataAdapterWrapper.cs Normal file
View file

@ -0,0 +1,262 @@
using System;
using System.Data;
using System.Data.Common;
using System.Data.SqlClient;
using SDA.DataProvider.Core;
namespace SDA.DataProvider.MSSQLWrappers
{
internal class MSSQLDataAdapterWrapper : SDADataAdapterWrapper
{
internal SqlDataAdapter DataAdapter;
internal MSSQLCommandWrapper InnerDeleteCommand;
internal MSSQLCommandWrapper InnerInsertCommand;
internal MSSQLCommandWrapper InnerSelectCommand;
internal MSSQLCommandWrapper InnerUpdateCommand;
static string SafeGetParametersText(SDACommandWrapper command)
{
string result = "";
for (int i = 0; i < command.Parameters.Count; i++)
{
result += command.Parameters[i].ParameterName + "=";
if (command.Parameters[i].Value == null)
{
result += @"csharpnull, ";
}
else if (command.Parameters[i].Value == DBNull.Value)
{
result += @"DBNULL, ";
}
else
{
result += "[" + command.Parameters[i].Value + "], ";
}
}
return result;
}
static string SafeGetCommandText(SDACommandWrapper command)
{
if (command != null)
{
return command.CommandText + "\n" + SafeGetParametersText(command);
}
return "";
}
public MSSQLDataAdapterWrapper()
{
DataAdapter = new SqlDataAdapter();
}
public override void Dispose()
{
DataAdapter.Dispose();
DataAdapter = null;
InnerDeleteCommand = null;
InnerInsertCommand = null;
InnerSelectCommand = null;
InnerUpdateCommand = null;
}
public override SDACommandWrapper DeleteCommand
{
get
{
return InnerDeleteCommand;
}
set
{
MSSQLCommandWrapper command = value as MSSQLCommandWrapper;
DataAdapter.DeleteCommand = command != null ? command.Command : null;
InnerDeleteCommand = command;
}
}
public override SDACommandWrapper InsertCommand
{
get
{
return InnerInsertCommand;
}
set
{
MSSQLCommandWrapper command = value as MSSQLCommandWrapper;
DataAdapter.InsertCommand = command?.Command;
InnerInsertCommand = command;
}
}
public override SDACommandWrapper SelectCommand
{
get
{
return InnerSelectCommand;
}
set
{
MSSQLCommandWrapper command = value as MSSQLCommandWrapper;
DataAdapter.SelectCommand = command?.Command;
InnerSelectCommand = command;
}
}
public override SDACommandWrapper UpdateCommand
{
get
{
return InnerUpdateCommand;
}
set
{
MSSQLCommandWrapper command = value as MSSQLCommandWrapper;
DataAdapter.UpdateCommand = command?.Command;
InnerUpdateCommand = command;
}
}
public override bool AcceptChangesDuringFill
{
get
{
return DataAdapter.AcceptChangesDuringFill;
}
set
{
DataAdapter.AcceptChangesDuringFill = value;
}
}
public override bool ContinueUpdateOnError
{
get
{
return DataAdapter.ContinueUpdateOnError;
}
set
{
DataAdapter.ContinueUpdateOnError = value;
}
}
public override MissingMappingAction MissingMappingAction
{
get
{
return DataAdapter.MissingMappingAction;
}
set
{
DataAdapter.MissingMappingAction = value;
}
}
public override MissingSchemaAction MissingSchemaAction
{
get
{
return DataAdapter.MissingSchemaAction;
}
set
{
DataAdapter.MissingSchemaAction = value;
}
}
public override DataTableMappingCollection TableMappings
{
get
{
return DataAdapter.TableMappings;
}
}
public override int Fill(DataSet dataSet)
{
try
{
return DataAdapter.Fill(dataSet);
}
catch (SqlException exception)
{
throw MSSQLExceptionHelper.TranslateSqlException(exception, SafeGetCommandText(InnerSelectCommand));
}
}
public override int Fill(DataSet dts, int startRecord, int endRecord, string srcTable)
{
try
{
return DataAdapter.Fill(dts, startRecord, (endRecord - startRecord) + 1, srcTable);
}
catch (SqlException exception)
{
throw MSSQLExceptionHelper.TranslateSqlException(exception, SafeGetCommandText(InnerSelectCommand));
}
}
public override int Fill(DataTable dataTable)
{
try
{
return DataAdapter.Fill(dataTable);
}
catch (SqlException exception)
{
throw MSSQLExceptionHelper.TranslateSqlException(exception, SafeGetCommandText(InnerSelectCommand));
}
}
public override DataTable[] FillSchema(DataSet dataSet, SchemaType schemaType)
{
try
{
return DataAdapter.FillSchema(dataSet, schemaType);
}
catch (SqlException exception)
{
throw MSSQLExceptionHelper.TranslateSqlException(exception, SafeGetCommandText(InnerSelectCommand));
}
}
public override DataTable FillSchema(DataTable dataTable, SchemaType schemaType)
{
try
{
return DataAdapter.FillSchema(dataTable, schemaType);
}
catch (SqlException exception)
{
throw MSSQLExceptionHelper.TranslateSqlException(exception, SafeGetCommandText(InnerSelectCommand));
}
}
public override DataTable[] FillSchema(DataSet dataSet, SchemaType schemaType, string srcTable)
{
try
{
return DataAdapter.FillSchema(dataSet, schemaType, srcTable);
}
catch (SqlException exception)
{
throw MSSQLExceptionHelper.TranslateSqlException(exception, SafeGetCommandText(InnerSelectCommand));
}
}
public override int Update(DataRow[] dataRows)
{
return DataAdapter.Update(dataRows);
}
public override int Update(DataSet dataSet)
{
return DataAdapter.Update(dataSet);
}
public override int Update(DataTable dataTable)
{
return DataAdapter.Update(dataTable);
}
}
}

191
Sda.DataProvider/Wrappers/MSSQL/MSSQLDataReaderWrapper.cs Normal file
View file

@ -0,0 +1,191 @@
using System;
using System.Data;
using System.Data.SqlClient;
using System.Globalization;
using SDA.DataProvider.Core;
namespace SDA.DataProvider.MSSQLWrappers
{
class MSSQLDataReaderWrapper : SDADataReaderWrapper
{
internal SqlDataReader Reader;
internal MSSQLDataReaderWrapper(SqlDataReader reader)
{
Reader = reader;
}
protected override IDataReader WrappedDataReader
{
get
{
return Reader;
}
}
bool _disposed;
protected override void Dispose(bool disposing)
{
if (_disposed)
{
return;
}
if (disposing)
{
if (Reader != null)
{
Reader.Dispose();
Reader = null;
}
}
_disposed = true;
}
public override void Close()
{
Reader.Close();
}
public override bool Read()
{
try
{
return Reader.Read();
}
catch (SqlException ex)
{
throw MSSQLExceptionHelper.TranslateSqlException(ex);
}
}
public override bool NextResult()
{
return Reader.NextResult();
}
public override bool IsDBNull(int index)
{
return Reader.IsDBNull(index);
}
public override bool GetBoolean(int index)
{
object value = GetValue(index);
if (value is Boolean)
{
return (bool)value;
}
char temp = GetChar(index);
switch (temp)
{
case '0':
case 'f':
case 'F':
case 'n':
case 'N':
return false;
case '1':
case 't':
case 'T':
case 'y':
case 'Y':
return true;
default:
throw new SDADataProviderException(new InvalidCastException());
}
}
public override byte GetByte(int index)
{
return Reader.GetByte(index);
}
public override char GetChar(int index)
{
string temp = Reader.GetString(index);
if (temp.Length == 1)
{
return temp[0];
}
throw new InvalidCastException();
}
public override DateTime GetDateTime(int index)
{
return Reader.GetDateTime(index);
}
public override decimal GetDecimal(int index)
{
return Convert.ToDecimal(Reader.GetValue(index), CultureInfo.InvariantCulture);
}
public override double GetDouble(int index)
{
return Convert.ToDouble(Reader.GetValue(index), CultureInfo.InvariantCulture);
}
public override short GetInt16(int index)
{
return Convert.ToInt16(Reader.GetValue(index), CultureInfo.InvariantCulture);
}
public override int GetInt32(int index)
{
return Convert.ToInt32(Reader.GetValue(index), CultureInfo.InvariantCulture);
}
public override long GetInt64(int index)
{
return Convert.ToInt64(Reader.GetValue(index), CultureInfo.InvariantCulture);
}
public override string GetString(int index)
{
return Reader.GetString(index);
}
public override string GetLongString(int index)
{
return Reader.GetString(index);
}
public override object GetValue(int index)
{
return Reader.GetValue(index);
}
public override int GetValues(object[] values)
{
return Reader.GetValues(values);
}
public override DataTable GetSchemaTable()
{
return Reader.GetSchemaTable();
}
public override Guid GetGuid(int i)
{
return Reader.GetGuid(i);
}
public override object this[string name] => Reader[name];
public override object this[int index]
{
get
{
return Reader[index];
}
}
public override int FieldCount => Reader.FieldCount;
public override int GetOrdinal(string fieldname)
{
return Reader.GetOrdinal(fieldname);
}
}
}

50
Sda.DataProvider/Wrappers/MSSQL/MSSQLExceptionHelper.cs Normal file
View file

@ -0,0 +1,50 @@
using System.Data.SqlClient;
namespace SDA.DataProvider.MSSQLWrappers
{
class MSSQLExceptionHelper
{
public static SDADataProviderException TranslateSqlException(SqlException exception)
{
return TranslateSqlException(exception, "");
}
public static SDADataProviderException TranslateSqlException(SqlException exception, string commandText)
{
switch ((MSSQLErrors)exception.Number)
{
case MSSQLErrors.ForeignKeyViolation:
return new ForeignKeyViolationException(exception, exception.Number, commandText);
case MSSQLErrors.UniqueKeyViolation:
case MSSQLErrors.CannotInsertDuplicateKeyRow:
return new UniqueKeyViolationException(exception, exception.Number, commandText);
case MSSQLErrors.DeadlockDetected:
return new DeadlockException(exception, exception.Number, commandText);
case MSSQLErrors.CommandTimeout:
return new CommandTimeoutException(exception, exception.Number, commandText);
case MSSQLErrors.TableOrViewDoesNotExist:
return new TableOrViewNotExistsException(exception, exception.Number, commandText);
case MSSQLErrors.UntitledCommunicationError:
case MSSQLErrors.PreLoginHandshake:
case MSSQLErrors.ConnectionError:
return new CommunicationErrorException(exception, exception.Number, false);
default:
return new SDADataProviderException(exception, SDADataProviderError.Unknown, exception.Number, commandText);
}
}
}
enum MSSQLErrors
{
CommandTimeout = -2,
ForeignKeyViolation = 547,
UniqueKeyViolation = 2627,
CannotInsertDuplicateKeyRow = 2601,
CannotInsertNull = 515,
TableOrViewDoesNotExist = 208,
ConnectionError = 1231,
PreLoginHandshake = 10054,
UntitledCommunicationError = 2,
DeadlockDetected = 1205,
}
}

68
Sda.DataProvider/Wrappers/MSSQL/MSSQLTransactionWrapper.cs Normal file
View file

@ -0,0 +1,68 @@
using System.Data;
using System.Data.SqlClient;
using SDA.DataProvider.Core;
namespace SDA.DataProvider.MSSQLWrappers
{
class MSSQLTransactionWrapper : SDATransactionWrapper
{
private MSSQLConnectionWrapper connection;
public SqlTransaction Transaction;
internal MSSQLTransactionWrapper(MSSQLConnectionWrapper connection, SqlTransaction transaction)
{
this.connection = connection;
Transaction = transaction;
}
public override void Commit()
{
try
{
Transaction.Commit();
}
catch (SqlException exception)
{
throw MSSQLExceptionHelper.TranslateSqlException(exception);
}
}
public override void Rollback()
{
try
{
Transaction.Rollback();
}
catch (SqlException exception)
{
throw MSSQLExceptionHelper.TranslateSqlException(exception);
}
}
internal override IDbTransaction NativeTransaction => Transaction;
public override void Dispose()
{
Transaction.Dispose();
Transaction = null;
}
public override SDAConnectionWrapper Connection
{
get
{
return connection;
}
}
public override IsolationLevel IsolationLevel
{
get
{
return Transaction.IsolationLevel;
}
}
}
}

5
Sda.DataProvider/packages.config Normal file
View file

@ -0,0 +1,5 @@
<?xml version="1.0" encoding="utf-8"?>
<packages>
<package id="JetBrains.Annotations" version="10.4.0" targetFramework="net48" />
<package id="Meziantou.Analyzer" version="1.0.688" targetFramework="net48" developmentDependency="true" />
</packages>