public EventQueryMapping(StoreOptions storeOptions) : base(typeof(IEvent), storeOptions)
{
DatabaseSchemaName = storeOptions.Events.DatabaseSchemaName;
TenancyStyle = storeOptions.Events.TenancyStyle;
TableName = new DbObjectName(DatabaseSchemaName, "mt_events");
duplicateField(x => x.Sequence, "seq_id");
if (storeOptions.Events.StreamIdentity == StreamIdentity.AsGuid)
{
duplicateField(x => x.StreamId, "stream_id");
}
else
{
duplicateField(x => x.StreamKey, "stream_id");
}
duplicateField(x => x.Version, "version");
duplicateField(x => x.Timestamp, "timestamp");
duplicateField(x => x.IsArchived, "is_archived");
if (storeOptions.EventGraph.Metadata.CorrelationId.Enabled)
{
duplicateField(x => x.CorrelationId, storeOptions.EventGraph.Metadata.CorrelationId.Name);
}
if (storeOptions.EventGraph.Metadata.CausationId.Enabled)
{
duplicateField(x => x.CausationId, storeOptions.EventGraph.Metadata.CausationId.Name);
}
}
public void parse_qualified_name_without_schema()
{
var name = DbObjectName.Parse(theProvider, "foo");
name.Schema.ShouldBe(theProvider.DefaultDatabaseSchemaName);
name.Name.ShouldBe("foo");
}
public static void MarkOwnership(this IDocumentSession session, DbObjectName table, int ownerId,
IEnumerable <Envelope> envelopes)
{
var operation = new MarkOwnership(table, ownerId, envelopes);
session.QueueOperation(operation);
}
public static Function ForRemoval(DbObjectName identifier)
{
return(new Function(identifier, null)
{
IsRemoved = true
});
}
public void parse_qualified_name_with_schema()
{
var name = DbObjectName.Parse(theProvider, "other.foo");
name.Schema.ShouldBe("other");
name.Name.ShouldBe("foo");
}
public ColumnExpression ForeignKeyTo(string referencedTableName, string referencedColumnName,
string fkName = null, CascadeAction onDelete = CascadeAction.NoAction,
CascadeAction onUpdate = CascadeAction.NoAction)
{
return(ForeignKeyTo(DbObjectName.Parse(SqlServerProvider.Instance, referencedTableName), referencedColumnName, fkName, onDelete,
onUpdate));
}
public UniqueIndex(DocumentMapping mapping, MemberInfo[][] members)
{
_members = members;
_locator = members
.Select(m =>
{
var sql = mapping.FieldFor(m).SqlLocator.Replace("d.", "");
switch (Casing)
{
case Casings.Upper:
return($" upper({sql})");
case Casings.Lower:
return($" lower({sql})");
default:
return($" ({sql})");
}
})
.Join(",");
_locator = $" ({_locator})";
_table = mapping.Table;
}
public static DbObjectName ParseIdentifier(string functionSql)
{
var signature = ParseSignature(functionSql);
var open = signature.IndexOf('(');
return(DbObjectName.Parse(signature.Substring(0, open)));
}
public static void DeleteEnvelopes(this IDocumentSession session, DbObjectName table,
IEnumerable <Envelope> envelopes)
{
var operation = new DeleteEnvelopes(table, envelopes);
session.QueueOperation(operation);
}
public void to_temp_copy_table_appends__temp()
{
var name = new DbObjectName("foo");
var tempCopy = name.ToTempCopyTable();
tempCopy.QualifiedName.ShouldBe("public.foo_temp");
}
public static void DeleteEnvelope(this IDocumentSession session, DbObjectName table,
Envelope envelope)
{
var operation = new DeleteEnvelope(table, envelope);
session.QueueOperation(operation);
}
public void ShouldCompareEqualityByValue()
{
DbObjectName name1 = "Customer";
DbObjectName name2 = "Customer";
Assert.AreEqual(name1, name2);
}
public void parse_qualified_name_without_schema()
{
var name = DbObjectName.Parse("foo");
name.Schema.ShouldBe("public");
name.Name.ShouldBe("foo");
}
public UpsertFunction(DocumentMapping mapping, DbObjectName identifier = null, bool disableConcurrency = false) : base(identifier ?? mapping.UpsertFunction)
{
_disableConcurrency = disableConcurrency;
if (mapping == null)
{
throw new ArgumentNullException(nameof(mapping));
}
_tableName = mapping.Table;
var table = new DocumentTable(mapping);
if (table.PrimaryKeys.Count > 1)
{
_primaryKeyConstraintName = mapping.Table.Name + "_pkey";
}
else
{
_primaryKeyConstraintName = "pk_" + mapping.Table.Name;
}
var idType = mapping.IdMember.GetMemberType();
var pgIdType = TypeMappings.GetPgType(idType);
Arguments.Add(new UpsertArgument
{
Arg = "docId",
PostgresType = pgIdType,
Column = "id",
Members = new[] { mapping.IdMember }
});
Arguments.Add(new DocJsonBodyArgument());
Arguments.AddRange(mapping.DuplicatedFields.Select(x => x.UpsertArgument));
Arguments.Add(new VersionArgument());
Arguments.Add(new DotNetTypeArgument());
if (mapping.IsHierarchy())
{
Arguments.Add(new DocTypeArgument());
}
if (mapping.UseOptimisticConcurrency)
{
Arguments.Add(new CurrentVersionArgument());
}
if (mapping.TenancyStyle == TenancyStyle.Conjoined)
{
Arguments.Add(new TenantIdArgument());
_tenantWhereClause = $"{_tableName.QualifiedName}.{TenantIdColumn.Name} = {TenantIdArgument.ArgName}";
_andTenantWhereClause = $" and {_tenantWhereClause}";
}
}
///<inheritdoc/>
public virtual TableDefinition GetTableDefinition()
{
this.LoadDbAdapter();
TableDefinition definition = DbSchema.Tables
.Where(c => DbObjectName.Equals(c.Name, StringComparison.OrdinalIgnoreCase))
.Select(c => new TableDefinition
{
Name = c.Name,
ConnectorId = Connector.Id,
ConnectorName = Connector.Name,
SchemaName = c.Schema,
DbName = Connector.InitialCatalog,
Columns = c.Columns.Select(d => new ColumnDefinition
{
Name = d.ColumnName,
Type = d.ColumnType,
Length = d.ColumnLength,
IsComputed = d.IsComputed,
IsNullable = d.ColumnIsNullable,
IsPrimaryKey = d.IsPK,
IsForigenKey = d.IsFK,
ReferencedTable = d.ReferencedTable,
ReferencedColumn = d.ReferencedColumn,
ReferencedSchema = d.ReferencedSchema,
ReferencedDatabase = d.ReferencedDatabase,
IsPrimaryKeyIdentity = d.PKIsIdentity
})
})
.FirstOrDefault();
definition.NavigationProperties = ListNavigationProperties();
return(definition);
}
public override string ToString()
{
if (DbObjectName != null)
{
return(DbObjectName.ToString());
}
return(base.ToString());
}
public void CallsSproc_extension_method()
{
var command = new SqlCommand();
command.CallsSproc(DbObjectName.Parse(SqlServerProvider.Instance, "foo.func")).ShouldBeSameAs(command);
command.CommandType.ShouldBe(CommandType.StoredProcedure);
command.CommandText.ShouldBe("foo.func");
}
public void can_parse_without_schema()
{
var table = DbObjectName.Parse("mt_doc_user");
table.Name.ShouldBe("mt_doc_user");
table.Schema.ShouldBe("public");
table.QualifiedName.ShouldBe("public.mt_doc_user");
}
public SprocCall Sproc(DbObjectName function, ICallback callback = null)
{
if (function == null)
{
throw new ArgumentNullException(nameof(function));
}
return(Current().Sproc(function, callback));
}
public void ShouldReturnOnlyObjectName()
{
string strName = "Customer";
DbObjectName name = strName;
Assert.AreEqual("", name.Schema);
Assert.AreEqual("Customer", name.ShortName);
Assert.AreEqual("Customer", name.ToString());
}
public EnvelopeTables(MessagingSettings settings, StoreOptions storeConfiguration)
{
Incoming = new DbObjectName(storeConfiguration.DatabaseSchemaName,
PostgresqlEnvelopeStorage.IncomingTableName);
Outgoing = new DbObjectName(storeConfiguration.DatabaseSchemaName,
PostgresqlEnvelopeStorage.OutgoingTableName);
CurrentNodeId = settings.UniqueNodeId;
}
public void ShouldReturnSchemaAndObjectNameEvenForFullyQualifiedNames()
{
string strName = "localhost.Northwind.dbo.Customer";
DbObjectName name = strName;
Assert.AreEqual("dbo", name.Schema);
Assert.AreEqual("Customer", name.ShortName);
Assert.AreEqual("localhost.Northwind.dbo.Customer", name.ToString());
}
public SystemFunction(string schema, string functionName, string args, bool isRemoved = false)
: base(new DbObjectName(schema, functionName), isRemoved)
{
_args = args;
_function = new DbObjectName(schema, functionName);
_dropSql = $"drop function if exists {schema}.{functionName}({args}) cascade;";
Name = functionName;
}
public void should_stick_the_patch_doc_function_in_the_right_schema()
{
StoreOptions(_ => _.DatabaseSchemaName = "other");
theStore.Schema.ApplyAllConfiguredChangesToDatabase();
var expected = new DbObjectName("other", "mt_transform_patch_doc");
theStore.Tenancy.Default.DbObjects.Functions().Contains(expected).ShouldBeTrue();
}
public static void ShouldContain(this DbObjectName[] names, string qualifiedName)
{
if (names == null)
{
throw new ArgumentNullException(nameof(names));
}
var function = DbObjectName.Parse(qualifiedName);
names.ShouldContain(function);
}
public virtual void Execute(IDatabase db, IScriptFile xmlFile)
{
Throw.If(db, "db").IsNull();
Throw.If(xmlFile, "xmlFile").IsNull();
Throw.If(!xmlFile.IsXml, "xmlFile");
DbObjectName tableName = GetTableNameFromXmlElement(xmlFile);
ITable table = MyMetaUtil.GetTableOrThrow(db, tableName);
LoadTable(table, xmlFile.Path);
}
public void Parse(string definition)
{
var open1 = definition.IndexOf('(');
var closed1 = definition.IndexOf(')');
ColumnNames = definition.Substring(open1 + 1, closed1 - open1 - 1).ToDelimitedArray(',');
var open2 = definition.IndexOf('(', closed1);
var closed2 = definition.IndexOf(')', open2);
LinkedNames = definition.Substring(open2 + 1, closed2 - open2 - 1).ToDelimitedArray(',');
var references = "REFERENCES";
var tableStart = definition.IndexOf(references) + references.Length;
var tableName = definition.Substring(tableStart, open2 - tableStart).Trim();
LinkedTable = DbObjectName.Parse(PostgresqlProvider.Instance, tableName);
if (definition.ContainsIgnoreCase("ON DELETE CASCADE"))
{
OnDelete = CascadeAction.Cascade;
}
else if (definition.ContainsIgnoreCase("ON DELETE RESTRICT"))
{
OnDelete = CascadeAction.Restrict;
}
else if (definition.ContainsIgnoreCase("ON DELETE SET NULL"))
{
OnDelete = CascadeAction.SetNull;
}
else if (definition.ContainsIgnoreCase("ON DELETE SET DEFAULT"))
{
OnDelete = CascadeAction.SetDefault;
}
if (definition.ContainsIgnoreCase("ON UPDATE CASCADE"))
{
OnUpdate = CascadeAction.Cascade;
}
else if (definition.ContainsIgnoreCase("ON UPDATE RESTRICT"))
{
OnUpdate = CascadeAction.Restrict;
}
else if (definition.ContainsIgnoreCase("ON UPDATE SET NULL"))
{
OnUpdate = CascadeAction.SetNull;
}
else if (definition.ContainsIgnoreCase("ON UPDATE SET DEFAULT"))
{
OnUpdate = CascadeAction.SetDefault;
}
}
public static async Task <bool> FunctionExists(this SqlConnection conn, DbObjectName functionIdentifier)
{
var sql =
"SELECT specific_schema, routine_name FROM information_schema.routines WHERE type_udt_name != 'trigger' and routine_name like :name and specific_schema = :schema;";
using var reader = await conn.CreateCommand(sql)
.With("name", functionIdentifier.Name)
.With("schema", functionIdentifier.Schema)
.ExecuteReaderAsync();
return(await reader.ReadAsync());
}
public EventQueryMapping(StoreOptions storeOptions) : base(typeof(IEvent), storeOptions)
{
Selector = new EventSelector(storeOptions.Events, storeOptions.Serializer());
DatabaseSchemaName = storeOptions.Events.DatabaseSchemaName;
Table = new DbObjectName(DatabaseSchemaName, "mt_events");
duplicateField(x => x.Sequence, "seq_id");
duplicateField(x => x.StreamId, "stream_id");
duplicateField(x => x.Version, "version");
duplicateField(x => x.Timestamp, "timestamp");
}
public SprocCall Sproc(DbObjectName function, ICallback callback = null)
{
if (function == null)
{
throw new ArgumentNullException(nameof(function));
}
var call = new SprocCall(this, function);
AddCall(call, callback);
return(call);
}
