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

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
}
}