public static Expression Build(SqlDataTypeProvider sqlDataTypeProvider, SqlDialect sqlDialect, DataAccessModel model, string tableNamePrefix, SqlDataDefinitionBuilderFlags flags)
{
var builder = new SqlDataDefinitionExpressionBuilder(sqlDialect, sqlDataTypeProvider, model, tableNamePrefix, flags);
var retval = builder.Build();
return retval;
}
public Sql92QueryFormatter(SqlQueryFormatterOptions options = SqlQueryFormatterOptions.Default, SqlDialect sqlDialect = null, SqlDataTypeProvider sqlDataTypeProvider = null, TypeDescriptorProvider typeDescriptorProvider = null)
: base(sqlDialect, new StringWriter(new StringBuilder()))
{
this.options = options;
this.typeDescriptorProvider = typeDescriptorProvider;
this.sqlDataTypeProvider = sqlDataTypeProvider ?? new DefaultSqlDataTypeProvider(new ConstraintDefaultsConfiguration());
this.stringQuote = this.sqlDialect.GetSyntaxSymbolString(SqlSyntaxSymbol.StringQuote);
this.identifierQuoteString = this.sqlDialect.GetSyntaxSymbolString(SqlSyntaxSymbol.IdentifierQuote);
}
private SqlDataDefinitionExpressionBuilder(SqlDialect sqlDialect, SqlDataTypeProvider sqlDataTypeProvider, DataAccessModel model, string tableNamePrefix, SqlDataDefinitionBuilderFlags flags)
{
this.model = model;
this.sqlDialect = sqlDialect;
this.tableNamePrefix = tableNamePrefix;
this.flags = flags;
this.sqlDataTypeProvider = sqlDataTypeProvider;
this.currentTableConstraints = new List<Expression>();
}
public Sql92QueryFormatter(SqlQueryFormatterOptions options = SqlQueryFormatterOptions.Default, SqlDialect sqlDialect = null, SqlDataTypeProvider sqlDataTypeProvider = null)
: base(sqlDialect, new StringWriter(new StringBuilder()))
{
this.options = options;
if (sqlDataTypeProvider == null)
{
this.sqlDataTypeProvider = new DefaultSqlDataTypeProvider(ConstraintDefaults.Default);
}
else
{
this.sqlDataTypeProvider = sqlDataTypeProvider;
}
this.stringQuote = this.sqlDialect.GetSyntaxSymbolString(SqlSyntaxSymbol.StringQuote);
this.identifierQuoteString = this.sqlDialect.GetSyntaxSymbolString(SqlSyntaxSymbol.IdentifierQuote);
}
public void Can_build_sql(string sql, SqlDialect dialect)
{
PagingQuery query = null;
Timed(() =>
{
query = SqlBuilder.Page(sql, 0, 10);
});
Assert.IsNotNull(query);
Assert.IsNotNullOrEmpty(query.CountQuery, "Count query must exist");
Assert.IsNotNullOrEmpty(query.PageQuery, "Page query must exist");
Assert.IsNotEmpty(query.Parameters);
Console.WriteLine(query.CountQuery);
Console.WriteLine(query.PageQuery);
foreach(var parameter in query.Parameters)
{
Console.WriteLine("{0} = {1}", parameter.Key, parameter.Value);
}
}
public IFormattable TableAndColumn <TEntity>(SqlDialect sqlDialect, string propertyName,
EntityMapping entityMappingOverride = null) where TEntity : class
{
_sqlDialectHelper.SetDialogueIfNeeded <TEntity>(sqlDialect);
return(Sql.TableAndColumn <TEntity>(propertyName, entityMappingOverride));
}
protected override Expression VisitMethodCall(MethodCallExpression methodExp)
{
switch (methodExp.Method.Name)
{
case "Contains":
if (methodExp.Method.DeclaringType == typeof(string))
{
this.Visit(methodExp.Object);
SqlBuilder.AppendFormat(SqlDialect.Contains(), TranslateClause(methodExp.Arguments[0]));
return(methodExp);
}
else
{
Expression mex;
if (methodExp.Object != null)
{
this.Visit(methodExp.Arguments[0]);
SqlBuilder.Append(" IN (");
mex = methodExp.Object;
}
else
{
this.Visit(methodExp.Arguments[1]);
SqlBuilder.Append(" IN (");
mex = methodExp.Arguments[0];
}
if (mex.NodeType == ExpressionType.Call && mex is MethodCallExpression && ((MethodCallExpression)mex).Method.DeclaringType == typeof(SubQuery))
{
this.Visit(mex);
}
else
{
IEnumerable result = Expression.Lambda(mex).Compile().DynamicInvoke() as IEnumerable;
int length = 0;
foreach (var v in result)
{
length++;
this.Visit(Expression.Constant(v));
SqlBuilder.Append(",");
}
if (length == 0)
{
SqlBuilder.Append("NULL,");
}
SqlBuilder.Remove(SqlBuilder.Length - 1, 1);
}
SqlBuilder.Append(")");
return(methodExp);
}
case "ToUpper":
SqlBuilder.Append(" UPPER(");
this.Visit(methodExp.Object);
SqlBuilder.Append(")");
return(methodExp);
case "ToLower":
SqlBuilder.Append(" LOWER(");
this.Visit(methodExp.Object);
SqlBuilder.Append(")");
return(methodExp);
case "CompareTo":
IsPreTreatBinary = true;
this.Visit(methodExp.Object);
SqlBuilder.Append("{0}");
this.Visit(methodExp.Arguments[0]);
return(methodExp);
case "Equals":
this.Visit(methodExp.Object);
SqlBuilder.Append("=");
this.Visit(methodExp.Arguments[0]);
return(methodExp);
case "IndexOf":
SqlBuilder.AppendFormat(SqlDialect.IndexOf(), TranslateClause(methodExp.Arguments[0]), TranslateClause(methodExp.Object));
return(methodExp);
case "IsNullOrEmpty":
string template = " ({0} IS NULL OR {0}='') ";
string[] sections = template.Split(new string[] { "{0}" }, StringSplitOptions.None);
for (int i = 0; i < sections.Length - 1; i++)
{
if (i == 0)
{
SqlBuilder.Append(sections[i]);
}
this.Visit(methodExp.Arguments[0]);
SqlBuilder.Append(sections[i + 1]);
}
return(methodExp);
case "ToString":
//Convert.ToString()
if (methodExp.Method.DeclaringType == typeof(System.Convert))
{
MemberTypeVisitor mtVisitor = new MemberTypeVisitor();
MemberType = mtVisitor.Translate(methodExp.Arguments[0]);
if (MemberType != null)
{
SqlBuilder.AppendFormat(SqlDialect.ToChar(), TranslateClause(methodExp.Arguments[0]));
return(methodExp);
}
}
else if (methodExp.Method.DeclaringType == typeof(System.Object))
{
MemberTypeVisitor mtVisitor = new MemberTypeVisitor();
MemberType = mtVisitor.Translate(methodExp.Object);
if (MemberType != null)
{
SqlBuilder.AppendFormat(SqlDialect.ToChar(), TranslateClause(methodExp.Object));
return(methodExp);
}
}
else if (methodExp.Method.DeclaringType == typeof(Nullable <DateTime>) || methodExp.Method.DeclaringType == typeof(DateTime))
{
if (methodExp.Arguments[0] is ConstantExpression)
{
MemberTypeVisitor mtVisitor = new MemberTypeVisitor();
MemberType = mtVisitor.Translate(methodExp.Object);
if (MemberType != null)
{
string timeFormat = ((ConstantExpression)methodExp.Arguments[0]).Value as string;
string clause = TranslateClause(methodExp.Object);
//非列就转向了
if (string.IsNullOrEmpty(clause))
{
goto default;
}
SqlBuilder.AppendFormat("(" + SqlDialect.ParseTimeFormat(timeFormat) + ")", clause);
return(methodExp);
}
}
}
goto default;
case "ToInt32":
//Convert.ToInt32()
if (methodExp.Method.DeclaringType == typeof(System.Convert))
{
MemberTypeVisitor mtVisitor = new MemberTypeVisitor();
MemberType = mtVisitor.Translate(methodExp.Arguments[0]);
if (MemberType != null)
{
SqlBuilder.AppendFormat(SqlDialect.ToNumber(), TranslateClause(methodExp.Arguments[0]));
return(methodExp);
}
}
goto default;
case "ToDateTime":
if (methodExp.Method.DeclaringType == typeof(System.Convert))
{
MemberTypeVisitor mtVisitor = new MemberTypeVisitor();
MemberType = mtVisitor.Translate(methodExp.Arguments[0]);
if (MemberType == typeof(Nullable <DateTime>) || MemberType == typeof(DateTime))
{
this.Visit(methodExp.Arguments[0]);
return(methodExp);
}
else if (MemberType == typeof(string))
{
SqlBuilder.AppendFormat(SqlDialect.ToDateTime(), TranslateClause(methodExp.Arguments[0]));
return(methodExp);
}
}
goto default;
case "StartsWith":
this.Visit(methodExp.Object);
SqlBuilder.AppendFormat(SqlDialect.StartsWith(), TranslateClause(methodExp.Arguments[0]));
return(methodExp);
case "EndsWith":
this.Visit(methodExp.Object);
SqlBuilder.AppendFormat(SqlDialect.EndsWith(), TranslateClause(methodExp.Arguments[0]));
return(methodExp);
case "TrimStart":
SqlBuilder.Append(" LTRIM(");
this.Visit(methodExp.Object);
SqlBuilder.Append(")");
return(methodExp);
case "TrimEnd":
SqlBuilder.Append(" RTRIM(");
this.Visit(methodExp.Object);
SqlBuilder.Append(")");
return(methodExp);
case "Trim":
SqlBuilder.Append(" RTRIM(LTRIM(");
this.Visit(methodExp.Object);
SqlBuilder.Append("))");
return(methodExp);
case "Count":
if (methodExp.Method.DeclaringType == typeof(SqlFunctions))
{
SqlBuilder.AppendFormat("COUNT({0})", TranslateClause(methodExp.Arguments[0]));
return(methodExp);
}
goto default;
case "CountDistinct":
if (methodExp.Method.DeclaringType == typeof(SqlFunctions))
{
SqlBuilder.AppendFormat("COUNT(DISTINCT {0})", TranslateClause(methodExp.Arguments[0]));
return(methodExp);
}
goto default;
case "Max":
case "Min":
case "Avg":
if (methodExp.Method.DeclaringType == typeof(SqlFunctions))
{
SqlBuilder.AppendFormat("{0}({1})", methodExp.Method.Name, TranslateClause(methodExp.Arguments[0]));
return(methodExp);
}
goto default;
case "GetSingle":
if (methodExp.Method.DeclaringType == typeof(SubQuery))
{
Expression opd1 = methodExp.Arguments[0];
Expression opd2 = methodExp.Arguments[1];
if (methodExp.Arguments[0].NodeType == ExpressionType.Quote)
{
opd1 = ((UnaryExpression)(methodExp.Arguments[0])).Operand;
}
if (methodExp.Arguments[1].NodeType == ExpressionType.Quote)
{
opd2 = ((UnaryExpression)(methodExp.Arguments[1])).Operand;
}
if (WithAlias)
{
SqlBuilder.AppendFormat("(SELECT {0} FROM {1} AS {3} WHERE {2})", TranslateClause(((LambdaExpression)opd2).Body), GetTableName(((LambdaExpression)opd1).Parameters[0].Type), TranslateClause(((LambdaExpression)opd1).Body), ((LambdaExpression)opd1).Parameters[0].Name);
}
else
{
SqlBuilder.AppendFormat("(SELECT {0} FROM {1} WHERE {2})", TranslateClause(((LambdaExpression)opd2).Body), GetTableName(((LambdaExpression)opd1).Parameters[0].Type), TranslateClause(((LambdaExpression)opd1).Body));
}
return(methodExp);
}
goto default;
case "GetList":
if (methodExp.Method.DeclaringType == typeof(SubQuery))
{
Expression opd1 = methodExp.Arguments[0];
Expression opd2 = methodExp.Arguments[1];
if (methodExp.Arguments[0].NodeType == ExpressionType.Quote)
{
opd1 = ((UnaryExpression)(methodExp.Arguments[0])).Operand;
}
if (methodExp.Arguments[1].NodeType == ExpressionType.Quote)
{
opd2 = ((UnaryExpression)(methodExp.Arguments[1])).Operand;
}
if (WithAlias)
{
SqlBuilder.AppendFormat("SELECT {0} FROM {1} AS {3} WHERE {2}", TranslateClause(((LambdaExpression)opd2).Body), GetTableName(((LambdaExpression)opd1).Parameters[0].Type), TranslateClause(((LambdaExpression)opd1).Body), ((LambdaExpression)opd1).Parameters[0].Name);
}
else
{
SqlBuilder.AppendFormat("SELECT {0} FROM {1} WHERE {2}", TranslateClause(((LambdaExpression)opd2).Body), GetTableName(((LambdaExpression)opd1).Parameters[0].Type), TranslateClause(((LambdaExpression)opd1).Body));
}
return(methodExp);
}
goto default;
default:
try
{
object result = Expression.Lambda(methodExp).Compile().DynamicInvoke();
var r = Expression.Constant(result, methodExp.Method.ReturnType);
this.Visit(r);
return(r);
}
catch
{
if (methodExp.Object != null)
{
Expression obj = this.Visit(methodExp.Object);
return(obj);
}
else
{
Expression obj = this.Visit(methodExp.Arguments[0]);
return(obj);
}
}
throw new NotSupportedException(string.Format("lambda表达式不支持使用此'{0}'方法，请自行扩展", methodExp.Method.Name));
}
}
/// <summary> /// Adds to command params. /// </summary> /// <param name="command">The command.</param> /// <param name="dialect">The dialect.</param> /// <param name="index">The index.</param> public abstract void AddToCommandParams(DbCommand command, SqlDialect dialect, int index);
/// <summary>
/// Initializes a new instance of the <see cref="DataTableCommandBuilder"/> class.
/// </summary>
/// <param name="ds">The <see cref="System.Data.DataSet"/> containing the specified <see cref="System.Data.DataTable"/>.</param>
/// <param name="tableName">Name of the DataTable.</param>
/// <param name="connection">The database connection.</param>
/// <param name="dialect">The type of SQL dialect.</param>
public DataTableCommandBuilder(DataSet ds, string tableName, DbConnection connection, SqlDialect dialect)
{
if (ds == null)
{
throw new ArgumentNullException("ds");
}
if (String.IsNullOrEmpty(tableName))
{
throw new ArgumentNullException("tableName");
}
if (connection == null)
{
throw new ArgumentNullException("connection");
}
_connection = connection;
SqlDialect = dialect ?? SqlDialect.Create(connection);
dataTable = ds.Tables[tableName];
}
public CatalogDao(SqlDialect sqlDialect, string schemaConnectionString) : base(new CatalogSqlBuilder(sqlDialect), new CatalogResultHandler(), schemaConnectionString)
{
}
public ReplicaItemDaoImpl(ISessionCreator sessionCreator, SqlDialect dialect) : base(sessionCreator, dialect)
{
}
/// <summary>
/// Sets the dialect (SQL server type / version) for query.
/// </summary>
/// <remarks>TODO: SqlDialect system should be improved.</remarks>
public SqlQuery Dialect(SqlDialect dialect)
{
this.dialect = dialect;
return this;
}
private void SetupOrmConfiguration(SqlDialect dialect)
{
OrmConfiguration.DefaultDialect = dialect;
OrmConfiguration.RegisterEntity<Building>()
.SetTableName("Buildings")
.SetProperty(nameof(Building.BuildingId), PropertyMappingOptions.KeyProperty)
.SetProperty(nameof(Building.Name));
}
/// <summary>
/// Returns various database specific options to be used by the sql builder for the specified dialect.
/// </summary>
public virtual SqlDatabaseOptions GetDatabaseOptions(SqlDialect dialect)
{
switch (dialect)
{
case SqlDialect.MsSql:
return _defaultMsSqlDatabaseOptions;
case SqlDialect.PostgreSql:
return _defaultPostgreSqlDatabaseOptions;
case SqlDialect.MySql:
return _defaultMySqlDatabaseOptions;
default:
return _defaultGenericSqlDatabaseOptions;
}
}
static void Write(string testDirectory, SqlDialect dialect, string suffix, string script)
{
Write(testDirectory, suffix, script, dialect.ToString());
}
public PessimisticConcurrencyControlStrategy(SqlDialect sqlDialect, OutboxCommands outboxCommands)
{
this.sqlDialect = sqlDialect;
this.outboxCommands = outboxCommands;
}
public SagaCommandTests(SqlDialect sqlDialect)
{
this.sqlDialect = sqlDialect;
}
public SqliteSqlQueryFormatter(SqlQueryFormatterOptions options, SqlDialect sqlDialect, SqlDataTypeProvider sqlDataTypeProvider)
: base(options, sqlDialect, sqlDataTypeProvider)
{
}
public PostgresSqlDataDefinitionExpressionBuilder(SqlDatabaseContext sqlDatabaseContext, SqlDataTypeProvider sqlDataTypeProvider, SqlDialect sqlDialect)
{
this.SqlDatabaseContext = sqlDatabaseContext;
this.SqlDataTypeProvider = sqlDataTypeProvider;
this.SqlDialect = sqlDialect;
}
public CatalogDao(SqlDialect sqlDialect) : base(new CatalogSqlBuilder(sqlDialect), new CatalogResultHandler())
{
}
public static Expression Build(SqlDataTypeProvider sqlDataTypeProvider, SqlDialect sqlDialect)
{
return(null);
}
public DatabaseItemRepo(ThreadExecuter threadExecuter, ISessionCreator sessionCreator, SqlDialect dialect)
: base(threadExecuter, sessionCreator)
{
this._repo = new DatabaseItemDaoImpl(sessionCreator, dialect);
this.BaseRepo = _repo;
}
public SubscriptionPersister(Func <DbConnection> connectionBuilder, string tablePrefix, SqlDialect sqlDialect, TimeSpan?cacheFor)
{
this.connectionBuilder = connectionBuilder;
this.sqlDialect = sqlDialect;
this.cacheFor = cacheFor;
subscriptionCommands = SubscriptionCommandBuilder.Build(sqlDialect, tablePrefix);
if (cacheFor != null)
{
Cache = new ConcurrentDictionary <string, CacheItem>();
}
}
public PostgresSqlQueryFormatter(SqlQueryFormatterOptions options, SqlDialect sqlDialect, SqlDataTypeProvider sqlDataTypeProvider, TypeDescriptorProvider typeDescriptorProvider, string schemaName, bool convertEnumsToText)
: base(options, sqlDialect, sqlDataTypeProvider, typeDescriptorProvider)
{
this.schemaName = schemaName;
this.ConvertEnumsToText = convertEnumsToText;
}
public OutboxCommandTests(SqlDialect sqlDialect)
{
this.sqlDialect = sqlDialect;
}
public override void AddToCommandParams(DbCommand command, SqlDialect dialect, int index)
{
return;
}
public ProductSqlBuilder(SqlDialect sqlDialect) : base(sqlDialect, "Product")
{
this.SqlInsert = "INSERT INTO Product (CatalogDescription,OwnerDescription,OwnerName,Ownerid,Catalogid,CatalogName," + this.SqlBaseFieldInsertFront + ") VALUES (@CatalogDescription,@OwnerDescription,@OwnerName,@Ownerid,@Catalogid,@CatalogName," + this.SqlBaseFieldInsertBack + ")";
this.SqlUpdate = "UPDATE Product SET CatalogDescription=@CatalogDescription,OwnerDescription=@OwnerDescription,OwnerName=@OwnerName,Ownerid=@Ownerid,Catalogid=@Catalogid,CatalogName=@CatalogName," + this.SqlBaseFieldUpdate + " WHERE Id=@Id";
}
public IFormattable Table <TEntity>(SqlDialect sqlDialect, EntityMapping entityMappingOverride = null) where TEntity : class
{
_sqlDialectHelper.SetDialogueIfNeeded <TEntity>(sqlDialect);
return(Sql.Table <TEntity>(entityMappingOverride));
}
public ProductDao(SqlDialect sqlDialect) : base(new ProductSqlBuilder(sqlDialect), new ProductResultHandler())
{
}
public PostgresDotConnectSqlQueryFormatter(SqlQueryFormatterOptions options, SqlDialect sqlDialect, SqlDataTypeProvider sqlDataTypeProvider, TypeDescriptorProvider typeDescriptorProvider, string schemaName, bool convertEnumsToText)
: base(options, sqlDialect, sqlDataTypeProvider, typeDescriptorProvider, schemaName, convertEnumsToText)
{
}
public ProductDao(SqlDialect sqlDialect, string schemaConnectionString) : base(new ProductSqlBuilder(sqlDialect), new ProductResultHandler(), schemaConnectionString)
{
}
public void Write()
{
var directory = Path.Combine(TestContext.CurrentContext.TestDirectory, "../../");
foreach (var variant in Enum.GetValues(typeof(BuildSqlDialect)).Cast <BuildSqlDialect>())
{
Write(directory, variant, "TimeoutCreate", TimeoutScriptBuilder.BuildCreateScript(variant));
Write(directory, variant, "TimeoutDrop", TimeoutScriptBuilder.BuildDropScript(variant));
Write(directory, variant, "OutboxCreate", OutboxScriptBuilder.BuildCreateScript(variant));
Write(directory, variant, "OutboxDrop", OutboxScriptBuilder.BuildDropScript(variant));
Write(directory, variant, "SubscriptionCreate", SubscriptionScriptBuilder.BuildCreateScript(variant));
Write(directory, variant, "SubscriptionDrop", SubscriptionScriptBuilder.BuildDropScript(variant));
var sagaDefinition = new SagaDefinition(
tableSuffix: "OrderSaga",
name: "OrderSaga",
correlationProperty: new CorrelationProperty(
name: "OrderNumber",
type: CorrelationPropertyType.Int),
transitionalCorrelationProperty: new CorrelationProperty(
name: "OrderId",
type: CorrelationPropertyType.Guid));
Write(directory, variant, "SagaCreate", SagaScriptBuilder.BuildCreateScript(sagaDefinition, variant));
Write(directory, variant, "SagaDrop", SagaScriptBuilder.BuildDropScript(sagaDefinition, variant));
}
var dialects = new SqlDialect[]
{
new SqlDialect.MsSqlServer(),
new SqlDialect.MySql(),
new SqlDialect.Oracle()
};
foreach (var dialect in dialects)
{
var timeoutCommands = TimeoutCommandBuilder.Build(
sqlDialect: dialect,
tablePrefix: "EndpointName");
Write(directory, dialect, "TimeoutAdd", timeoutCommands.Add);
Write(directory, dialect, "TimeoutNext", timeoutCommands.Next);
Write(directory, dialect, "TimeoutRange", timeoutCommands.Range);
Write(directory, dialect, "TimeoutRemoveById", timeoutCommands.RemoveById);
Write(directory, dialect, "TimeoutRemoveBySagaId", timeoutCommands.RemoveBySagaId);
Write(directory, dialect, "TimeoutPeek", timeoutCommands.Peek);
var outboxCommands = OutboxCommandBuilder.Build(
tablePrefix: "EndpointName",
sqlDialect: dialect);
Write(directory, dialect, "OutboxCleanup", outboxCommands.Cleanup);
Write(directory, dialect, "OutboxGet", outboxCommands.Get);
Write(directory, dialect, "OutboxSetAsDispatched", outboxCommands.SetAsDispatched);
Write(directory, dialect, "OutboxStore", outboxCommands.Store);
var subscriptionCommands = SubscriptionCommandBuilder.Build(
sqlDialect: dialect,
tablePrefix: "EndpointName");
Write(directory, dialect, "SubscriptionSubscribe", subscriptionCommands.Subscribe);
Write(directory, dialect, "SubscriptionUnsubscribe", subscriptionCommands.Unsubscribe);
Write(directory, dialect, "SubscriptionGetSubscribers", subscriptionCommands.GetSubscribers(new List <MessageType>
{
new MessageType("MessageTypeName", new Version())
}));
var sagaCommandBuilder = new SagaCommandBuilder(dialect);
Write(directory, dialect, "SagaComplete", sagaCommandBuilder.BuildCompleteCommand("EndpointName_SagaName"));
Write(directory, dialect, "SagadGetByProperty", sagaCommandBuilder.BuildGetByPropertyCommand("PropertyName", "EndpointName_SagaName"));
Write(directory, dialect, "SagaGetBySagaId", sagaCommandBuilder.BuildGetBySagaIdCommand("EndpointName_SagaName"));
Write(directory, dialect, "SagaSave", sagaCommandBuilder.BuildSaveCommand("CorrelationProperty", "TransitionalCorrelationProperty", "EndpointName_SagaName"));
Write(directory, dialect, "SagaUpdate", sagaCommandBuilder.BuildUpdateCommand("TransitionalCorrelationProperty", "EndpointName_SagaName"));
// since we don't have doco on oracle saga finders
if (!(dialect is SqlDialect.Oracle))
{
Write(directory, dialect, "SagaSelect", sagaCommandBuilder.BuildSelectFromCommand("EndpointName_SagaName"));
}
}
}
protected GenericStatementSqlBuilder(
EntityDescriptor entityDescriptor,
EntityMapping entityMapping,
SqlDialect dialect)
{
var databaseOptions = OrmConfiguration.Conventions.GetDatabaseOptions(dialect);
this.UsesSchemaForTableNames = databaseOptions.IsUsingSchemas;
this.IdentifierStartDelimiter = databaseOptions.StartDelimiter;
this.IdentifierEndDelimiter = databaseOptions.EndDelimiter;
this.ParameterPrefix = databaseOptions.ParameterPrefix;
//_entityRelationships = new ConcurrentDictionary<IStatementSqlBuilder, EntityRelationship>();
_regularStatementFormatter = new SqlStatementFormatter(entityDescriptor, entityMapping, this, false);
_forcedTableResolutionStatementFormatter = new SqlStatementFormatter(entityDescriptor, entityMapping, this, true);
this.EntityDescriptor = entityDescriptor;
this.EntityMapping = entityMapping;
this.SelectProperties = this.EntityMapping.PropertyMappings
.Select(propMapping => propMapping.Value)
.ToArray();
this.KeyProperties = this.EntityMapping.PropertyMappings
.Where(propMapping => propMapping.Value.IsPrimaryKey)
.Select(propMapping => propMapping.Value)
.OrderBy(propMapping => propMapping.ColumnOrder)
.ToArray();
this.RefreshOnInsertProperties = this.SelectProperties
.Where(propInfo => propInfo.IsRefreshedOnInserts)
.ToArray();
this.RefreshOnUpdateProperties = this.SelectProperties
.Where(propInfo => propInfo.IsRefreshedOnUpdates)
.ToArray();
this.InsertKeyDatabaseGeneratedProperties = this.KeyProperties
.Intersect(this.RefreshOnInsertProperties)
.ToArray();
this.UpdateProperties = this.SelectProperties
.Where(propInfo => !propInfo.IsExcludedFromUpdates)
.ToArray();
this.InsertProperties = this.SelectProperties
.Where(propInfo => !propInfo.IsExcludedFromInserts)
.ToArray();
this.SequenceDependantProperties = this.SelectProperties
.Where(propInfo => !string.IsNullOrWhiteSpace(propInfo.SequenceName))
.ToArray();
_noAliasTableName = new Lazy <string>(() => this.GetTableNameInternal(), LazyThreadSafetyMode.PublicationOnly);
_noAliasKeysWhereClause = new Lazy <string>(() => this.ConstructKeysWhereClauseInternal(), LazyThreadSafetyMode.PublicationOnly);
_noAliasKeyColumnEnumeration = new Lazy <string>(() => this.ConstructKeyColumnEnumerationInternal(), LazyThreadSafetyMode.PublicationOnly);
_noAliasColumnEnumerationForSelect = new Lazy <string>(() => this.ConstructColumnEnumerationForSelectInternal(), LazyThreadSafetyMode.PublicationOnly);
_columnEnumerationForInsert = new Lazy <string>(() => this.ConstructColumnEnumerationForInsertInternal(), LazyThreadSafetyMode.PublicationOnly);
_paramEnumerationForInsert = new Lazy <string>(() => this.ConstructParamEnumerationForInsertInternal(), LazyThreadSafetyMode.PublicationOnly);
_noAliasUpdateClause = new Lazy <string>(() => this.ConstructUpdateClauseInternal(), LazyThreadSafetyMode.PublicationOnly);
_fullInsertStatement = new Lazy <string>(() => this.ConstructFullInsertStatementInternal(), LazyThreadSafetyMode.PublicationOnly);
_fullSingleUpdateStatement = new Lazy <string>(() => this.ConstructFullSingleUpdateStatementInternal(), LazyThreadSafetyMode.PublicationOnly);
_noConditionFullBatchUpdateStatement = new Lazy <string>(() => this.ConstructFullBatchUpdateStatementInternal(), LazyThreadSafetyMode.PublicationOnly);
_fullSingleDeleteStatement = new Lazy <string>(() => this.ConstructFullSingleDeleteStatementInternal(), LazyThreadSafetyMode.PublicationOnly);
_noConditionFullBatchDeleteStatement = new Lazy <string>(() => this.ConstructFullBatchDeleteStatementInternal(), LazyThreadSafetyMode.PublicationOnly);
_noConditionFullCountStatement = new Lazy <string>(() => this.ConstructFullCountStatementInternal(), LazyThreadSafetyMode.PublicationOnly);
_fullSingleSelectStatement = new Lazy <string>(() => this.ConstructFullSingleSelectStatementInternal(), LazyThreadSafetyMode.PublicationOnly);
}
public TimeoutPersister(IConnectionManager connectionManager, string tablePrefix, SqlDialect sqlDialect, TimeSpan timeoutsCleanupExecutionInterval, Func <DateTime> utcNow)
{
this.connectionManager = connectionManager;
this.sqlDialect = sqlDialect;
this.timeoutsCleanupExecutionInterval = timeoutsCleanupExecutionInterval;
this.utcNow = utcNow;
timeoutCommands = TimeoutCommandBuilder.Build(sqlDialect, tablePrefix);
oldestSupportedTimeout = sqlDialect.OldestSupportedTimeout;
}
public ItemCollectionDaoImpl(ISessionCreator sessionCreator, SqlDialect dialect) : base(sessionCreator, dialect)
{
}
protected ObjectDataProvider(Type runtimeType, IDataAccess dataAccess, ICache cache, SqlDialect sqlDialect)
{
RunTimeType = runtimeType;
var meta = new MetaData(runtimeType, sqlDialect);
Cache = cache;
ObjectType = meta.ExtractedEntityType;
RootType = meta.RootType;
AllTypesInMyHierarchy = meta.AllTypesInMyHierarchy;
FullHierarchyFields = meta.FullHierarchyFields;
ParticipatesInHierarchy = meta.ParticipatesInHierarchy;;
TopToBottomHierarchy = meta.TopToBottomHierarchy;
SubqueryAssociations = meta.GetSubqueryAssociations();
FieldsString = meta.GetFieldsString();
TableString = meta.GenerateFromTablesExpression();
DeleteCommand = meta.GetDeleteCommand();
InsertCommand = meta.GetInsertCommands();
UpdateCommand = meta.GetUpdateCommands();
NeedsTransactionForSave = meta.NeedsTransactionForSave();
ManyToManyAssociations = meta.ManyToManyAssociations;
PropertyToColumnMappings = meta.GetPropertyToColumnMappings();
SoftDeletePosition = ObjectType.GetSoftDeletePosition();
FullHierarchyFieldIdentifier = FullHierarchyFields.Select(c => c.GetCode(c.Identifier));
Db = dataAccess;
Sql = sqlDialect;
}
/// <summary>
/// Generates the key.
/// </summary>
/// <param name="sqlDialect">The SQL dialect.</param>
/// <param name="entityMap">The entity map.</param>
/// <param name="propertyName">Name of the property.</param>
/// <param name="priority">The priority.</param>
/// <returns></returns>
object IKeyGenerator.GenerateKey(SqlDialect sqlDialect, EntityMap entityMap, string propertyName, out SqlOperationPriority priority)
{
return(Generate(sqlDialect, entityMap, propertyName, out priority));
}
private void SetupOrmConfiguration(SqlDialect dialect)
{
OrmConfiguration.DefaultDialect = dialect;
OrmConfiguration.RegisterEntity<Building>()
.SetTableName("Buildings")
.SetProperty(building => building.BuildingId,propMapping => propMapping.SetPrimaryKey().SetDatabaseGenerated(DatabaseGeneratedOption.Identity).SetDatabaseColumnName("Id"))
.SetProperty(building => building.Name, propMapping=> propMapping.SetDatabaseColumnName("BuildingName"));
}
public CatalogSqlBuilder(SqlDialect sqlDialect) : base(sqlDialect, "Catalog")
{
this.SqlInsert = "INSERT INTO Catalog (Code,Parentid," + this.SqlBaseFieldInsertFront + ") VALUES (@Code,@Parentid," + this.SqlBaseFieldInsertBack + ")";
this.SqlUpdate = "UPDATE Catalog SET Code=@Code,Parentid=@Parentid," + this.SqlBaseFieldUpdate + " WHERE Id=@Id";
}
