public TypeMappingSource(
TypeMappingSourceDependencies dependencies,
RelationalTypeMappingSourceDependencies relationalDependencies,
INpgsqlOptions npgsqlOptions = null) :
base(dependencies, relationalDependencies, npgsqlOptions)
{
}
public MagicTagQuerySqlGeneratorFactory(
QuerySqlGeneratorDependencies dependencies,
INpgsqlOptions npgsqlOptions)
{
_dependencies = dependencies;
_npgsqlOptions = npgsqlOptions;
}
public NpgsqlQuerySqlGeneratorFactory(
QuerySqlGeneratorDependencies dependencies,
[NotNull] INpgsqlOptions npgsqlOptions)
{
_dependencies = dependencies;
_npgsqlOptions = npgsqlOptions;
}
public ZackQuerySqlGeneratorFactory_Npgsql(QuerySqlGeneratorDependencies dependencies,
ISqlGenerationHelper sqlGenerationHelper, INpgsqlOptions npgsqlOptions)
{
this.dependencies = dependencies;
this._sqlGenerationHelper = sqlGenerationHelper;
this._npgsqlOptions = npgsqlOptions;
}
public SqlMigrationsScriptGenerator(
MigrationsSqlGeneratorDependencies dependencies,
IMigrationsAnnotationProvider migrationsAnnotations,
INpgsqlOptions npgsqlOptions)
: base(dependencies, migrationsAnnotations, npgsqlOptions)
{
}
public MyPostgresMigrationsSqlGenerator(
MigrationsSqlGeneratorDependencies dependencies,
INpgsqlOptions npgsqlOptions
)
: base(dependencies, npgsqlOptions)
{
}
public NpgsqlMethodCallTranslatorProvider(
[NotNull] RelationalMethodCallTranslatorProviderDependencies dependencies,
[NotNull] IRelationalTypeMappingSource typeMappingSource,
[NotNull] INpgsqlOptions npgsqlOptions)
: base(dependencies)
{
var npgsqlSqlExpressionFactory = (NpgsqlSqlExpressionFactory)dependencies.SqlExpressionFactory;
var npgsqlTypeMappingSource = (NpgsqlTypeMappingSource)typeMappingSource;
var jsonTranslator = new NpgsqlJsonPocoTranslator(typeMappingSource, npgsqlSqlExpressionFactory);
LTreeTranslator = new NpgsqlLTreeTranslator(typeMappingSource, npgsqlSqlExpressionFactory);
AddTranslators(new IMethodCallTranslator[]
{
new NpgsqlArrayTranslator(typeMappingSource, npgsqlSqlExpressionFactory, jsonTranslator),
new NpgsqlByteArrayMethodTranslator(npgsqlSqlExpressionFactory),
new NpgsqlConvertTranslator(npgsqlSqlExpressionFactory),
new NpgsqlDateTimeMethodTranslator(typeMappingSource, npgsqlSqlExpressionFactory),
new NpgsqlFullTextSearchMethodTranslator(typeMappingSource, npgsqlSqlExpressionFactory),
new NpgsqlFuzzyStringMatchMethodTranslator(npgsqlSqlExpressionFactory),
new NpgsqlJsonDomTranslator(typeMappingSource, npgsqlSqlExpressionFactory),
new NpgsqlJsonDbFunctionsTranslator(typeMappingSource, npgsqlSqlExpressionFactory),
new NpgsqlLikeTranslator(npgsqlSqlExpressionFactory),
LTreeTranslator,
new NpgsqlMathTranslator(typeMappingSource, npgsqlSqlExpressionFactory),
new NpgsqlNetworkTranslator(typeMappingSource, npgsqlSqlExpressionFactory),
new NpgsqlNewGuidTranslator(npgsqlSqlExpressionFactory, npgsqlOptions.PostgresVersion),
new NpgsqlObjectToStringTranslator(npgsqlSqlExpressionFactory),
new NpgsqlRandomTranslator(npgsqlSqlExpressionFactory),
new NpgsqlRangeTranslator(typeMappingSource, npgsqlSqlExpressionFactory),
new NpgsqlRegexIsMatchTranslator(npgsqlSqlExpressionFactory),
new NpgsqlStringMethodTranslator(npgsqlTypeMappingSource, npgsqlSqlExpressionFactory),
new NpgsqlTrigramsMethodTranslator(npgsqlTypeMappingSource, npgsqlSqlExpressionFactory),
});
}
public NpgsqlQuerySqlGeneratorFactory(
[NotNull] QuerySqlGeneratorDependencies dependencies,
[NotNull] INpgsqlOptions npgsqlOptions)
: base(dependencies)
{
_npgsqlOptions = npgsqlOptions;
}
/// <inheritdoc />
public NpgsqlCompositeMemberTranslator(
[NotNull] RelationalCompositeMemberTranslatorDependencies dependencies,
[NotNull] INpgsqlOptions npgsqlOptions)
: base(dependencies)
{
// ReSharper disable once VirtualMemberCallInConstructor
AddTranslators(MemberTranslators);
}
public NpgsqlCompositeMethodCallTranslatorEx(
RelationalCompositeMethodCallTranslatorDependencies dependencies,
INpgsqlOptions npgsqlOptions)
: base(dependencies, npgsqlOptions)
{
// ReSharper disable once DoNotCallOverridableMethodsInConstructor
AddTranslators(MethodCallTranslators);
}
public NpgsqlMigrationsSqlGenerator(
[NotNull] MigrationsSqlGeneratorDependencies dependencies,
[NotNull] INpgsqlOptions npgsqlOptions)
: base(dependencies)
{
_sqlGenerationHelper = (NpgsqlSqlGenerationHelper)dependencies.SqlGenerationHelper;
_typeMappingSource = (NpgsqlTypeMappingSource)dependencies.TypeMappingSource;
_postgresVersion = npgsqlOptions.PostgresVersion;
}
public NpgsqlConventionSetBuilder(
ProviderConventionSetBuilderDependencies dependencies,
RelationalConventionSetBuilderDependencies relationalDependencies,
IRelationalTypeMappingSource typeMappingSource,
INpgsqlOptions npgsqlOptions)
: base(dependencies, relationalDependencies)
{
_typeMappingSource = typeMappingSource;
_postgresVersion = npgsqlOptions.PostgresVersion;
}
public NpgsqlCompositeMethodCallTranslator(
[NotNull] RelationalCompositeMethodCallTranslatorDependencies dependencies,
[NotNull] INpgsqlOptions npgsqlOptions)
: base(dependencies)
{
// ReSharper disable once DoNotCallOverridableMethodsInConstructor
AddTranslators(_methodCallTranslators);
foreach (var plugin in npgsqlOptions.Plugins)
{
plugin.AddMethodCallTranslators(this);
}
}
public NpgsqlCompositeMemberTranslator(
[NotNull] RelationalCompositeMemberTranslatorDependencies dependencies,
[NotNull] INpgsqlOptions npgsqlOptions)
: base(dependencies)
{
AddTranslators(new List <IMemberTranslator>
{
new NpgsqlStringLengthTranslator(),
new NpgsqlDateTimeMemberTranslator()
});
foreach (var plugin in npgsqlOptions.Plugins)
{
plugin.AddMemberTranslators(this);
}
}
/// <inheritdoc />
public NpgsqlCompositeMethodCallTranslator(
[NotNull] RelationalCompositeMethodCallTranslatorDependencies dependencies,
[NotNull] INpgsqlOptions npgsqlOptions)
: base(dependencies)
{
var versionDependentTranslators = new IMethodCallTranslator[]
{
new NpgsqlDateAddTranslator(npgsqlOptions.PostgresVersion),
new NpgsqlMathTranslator(npgsqlOptions.PostgresVersion)
};
// ReSharper disable once DoNotCallOverridableMethodsInConstructor
AddTranslators(MethodCallTranslators);
// ReSharper disable once DoNotCallOverridableMethodsInConstructor
AddTranslators(versionDependentTranslators);
}
public NpgsqlCompositeMethodCallTranslator(
[NotNull] RelationalCompositeMethodCallTranslatorDependencies dependencies,
[NotNull] INpgsqlOptions npgsqlOptions)
: base(dependencies)
{
var instanceTranslators =
new IMethodCallTranslator[]
{
new NpgsqlDateAddTranslator(npgsqlOptions.PostgresVersion)
};
// ReSharper disable once DoNotCallOverridableMethodsInConstructor
AddTranslators(_methodCallTranslators);
// ReSharper disable once DoNotCallOverridableMethodsInConstructor
AddTranslators(instanceTranslators);
foreach (var plugin in npgsqlOptions.Plugins)
{
plugin.AddMethodCallTranslators(this);
}
}
public NpgsqlMemberTranslatorProvider(
RelationalMemberTranslatorProviderDependencies dependencies,
IRelationalTypeMappingSource typeMappingSource,
INpgsqlOptions npgsqlOptions)
: base(dependencies)
{
var sqlExpressionFactory = (NpgsqlSqlExpressionFactory)dependencies.SqlExpressionFactory;
JsonPocoTranslator = new NpgsqlJsonPocoTranslator(typeMappingSource, sqlExpressionFactory);
AddTranslators(
new IMemberTranslator[] {
new NpgsqlArrayTranslator(sqlExpressionFactory, JsonPocoTranslator, npgsqlOptions.UseRedshift),
new NpgsqlDateTimeMemberTranslator(sqlExpressionFactory),
new NpgsqlJsonDomTranslator(typeMappingSource, sqlExpressionFactory),
new NpgsqlLTreeTranslator(typeMappingSource, sqlExpressionFactory),
JsonPocoTranslator,
new NpgsqlRangeTranslator(typeMappingSource, sqlExpressionFactory),
new NpgsqlStringMemberTranslator(sqlExpressionFactory),
new NpgsqlTimeSpanMemberTranslator(sqlExpressionFactory),
});
}
public CustomSqlMethodCallTranslator(RelationalCompositeMethodCallTranslatorDependencies dependencies, INpgsqlOptions sqlServerOptions) : base(dependencies, sqlServerOptions)
{
AddTranslators(new[] { new DateFormatTranslator() });
}
public NpgsqlModelCustomizer(ModelCustomizerDependencies dependencies, INpgsqlOptions npgsqlOptions) : base(dependencies)
{
_postgresVersion = npgsqlOptions.PostgresVersion;
}
public CustomNpgsqlQuerySqlGeneratorFactory(QuerySqlGeneratorDependencies dependencies, INpgsqlOptions npgsqlOptions)
: base(dependencies, npgsqlOptions) => this.npgsqlOptions = npgsqlOptions;
/// <inheritdoc />
public NpgsqlModelValidator(
ModelValidatorDependencies dependencies,
RelationalModelValidatorDependencies relationalDependencies,
INpgsqlOptions npgsqlOptions)
: base(dependencies, relationalDependencies)
=> _postgresVersion = Check.NotNull(npgsqlOptions, nameof(npgsqlOptions)).PostgresVersion;
public CustomNpgsqlMigrationsSqlGenerator(IDbProperties dbProperties, MigrationsSqlGeneratorDependencies dependencies, IMigrationsAnnotationProvider migrationsAnnotations, INpgsqlOptions npgsqlOptions)
: base(dependencies, migrationsAnnotations, npgsqlOptions)
{
if (dbProperties == null)
{
throw new ArgumentNullException(nameof(dbProperties));
}
_dbEncoding = dbProperties.CharacterEncoding ?? NpgsqlProperties.DefaultCharacterEncodingName;
_dbCollation = dbProperties.CaseSensitiveCollation;
}
public NpgsqlTypeMappingSource([NotNull] TypeMappingSourceDependencies dependencies,
[NotNull] RelationalTypeMappingSourceDependencies relationalDependencies,
[NotNull] ISqlGenerationHelper sqlGenerationHelper,
[CanBeNull] INpgsqlOptions npgsqlOptions = null)
: base(dependencies, relationalDependencies)
{
_sqlGenerationHelper = Check.NotNull(sqlGenerationHelper, nameof(sqlGenerationHelper));
// Initialize some mappings which depend on other mappings
_int4range = new NpgsqlRangeTypeMapping("int4range", typeof(NpgsqlRange <int>), _int4, sqlGenerationHelper);
_int8range = new NpgsqlRangeTypeMapping("int8range", typeof(NpgsqlRange <long>), _int8, sqlGenerationHelper);
_numrange = new NpgsqlRangeTypeMapping("numrange", typeof(NpgsqlRange <decimal>), _numeric, sqlGenerationHelper);
_tsrange = new NpgsqlRangeTypeMapping("tsrange", typeof(NpgsqlRange <DateTime>), _timestamp, sqlGenerationHelper);
_tstzrange = new NpgsqlRangeTypeMapping("tstzrange", typeof(NpgsqlRange <DateTime>), _timestamptz, sqlGenerationHelper);
_daterange = new NpgsqlRangeTypeMapping("daterange", typeof(NpgsqlRange <DateTime>), _timestamptz, sqlGenerationHelper);
// Note that PostgreSQL has aliases to some built-in type name aliases (e.g. int4 for integer),
// these are mapped as well.
// https://www.postgresql.org/docs/current/static/datatype.html#DATATYPE-TABLE
var storeTypeMappings = new Dictionary <string, RelationalTypeMapping[]>(StringComparer.OrdinalIgnoreCase)
{
{ "boolean", new[] { _bool } },
{ "bool", new[] { _bool } },
{ "bytea", new[] { _bytea } },
{ "real", new[] { _float4 } },
{ "float4", new[] { _float4 } },
{ "double precision", new[] { _float8 } },
{ "float8", new[] { _float8 } },
{ "numeric", new[] { _numeric } },
{ "decimal", new[] { _numeric } },
{ "money", new[] { _money } },
{ "uuid", new[] { _uuid } },
{ "smallint", new RelationalTypeMapping[] { _int2, _int2Byte } },
{ "int2", new RelationalTypeMapping[] { _int2, _int2Byte } },
{ "integer", new[] { _int4 } },
{ "int", new[] { _int4 } },
{ "int4", new[] { _int4 } },
{ "bigint", new[] { _int8 } },
{ "int8", new[] { _int8 } },
{ "text", new[] { _text } },
{ "jsonb", new RelationalTypeMapping[] { _jsonbString, _jsonbDocument, _jsonbElement } },
{ "json", new RelationalTypeMapping[] { _jsonString, _jsonDocument, _jsonElement } },
{ "xml", new[] { _xml } },
{ "citext", new[] { _citext } },
{ "character varying", new[] { _varchar } },
{ "varchar", new[] { _varchar } },
{ "character", new[] { _char } },
{ "char", new[] { _char } },
{ "char(1)", new RelationalTypeMapping[] { _singleChar, _stringAsSingleChar } },
{ "character(1)", new RelationalTypeMapping[] { _singleChar, _stringAsSingleChar } },
{ "date", new[] { _date } },
{ "timestamp without time zone", new[] { _timestamp } },
{ "timestamp", new[] { _timestamp } },
{ "timestamp with time zone", new[] { _timestamptz, _timestamptzDto } },
{ "timestamptz", new[] { _timestamptz, _timestamptzDto } },
{ "interval", new[] { _interval } },
{ "time without time zone", new[] { _time } },
{ "time", new[] { _time } },
{ "time with time zone", new[] { _timetz } },
{ "timetz", new[] { _timetz } },
{ "macaddr", new[] { _macaddr } },
{ "macaddr8", new[] { _macaddr8 } },
{ "inet", new[] { _inet } },
{ "cidr", new[] { _cidr } },
{ "bit", new[] { _bit } },
{ "bit varying", new[] { _varbit } },
{ "varbit", new[] { _varbit } },
{ "hstore", new[] { _hstore } },
{ "point", new[] { _point } },
{ "box", new[] { _box } },
{ "line", new[] { _line } },
{ "lseg", new[] { _lseg } },
{ "path", new[] { _path } },
{ "polygon", new[] { _polygon } },
{ "circle", new[] { _circle } },
{ "xid", new[] { _xid } },
{ "oid", new[] { _oid } },
{ "cid", new[] { _cid } },
{ "regtype", new[] { _regtype } },
{ "lo", new[] { _lo } },
{ "tid", new[] { _tid } },
{ "int4range", new[] { _int4range } },
{ "int8range", new[] { _int8range } },
{ "numrange", new[] { _numrange } },
{ "tsrange", new[] { _tsrange } },
{ "tstzrange", new[] { _tstzrange } },
{ "daterange", new[] { _daterange } },
{ "tsquery", new[] { _tsquery } },
{ "tsvector", new[] { _tsvector } },
{ "regconfig", new[] { _regconfig } }
};
var clrTypeMappings = new Dictionary <Type, RelationalTypeMapping>
{
{ typeof(bool), _bool },
public NpgsqlMigrationsSqlGenerator2(MigrationsSqlGeneratorDependencies dependencies, INpgsqlOptions npgsqlOptions) : base(dependencies, npgsqlOptions)
{
}
public CustomSqlMethodCallTranslator(RelationalCompositeMethodCallTranslatorDependencies dependencies,
INpgsqlOptions npgsqlOptions) : base(dependencies, npgsqlOptions)
{
// ReSharper disable once VirtualMemberCallInConstructor
AddTranslators(new[] { new JsonbFindTranslator() });
}
public ShardingPostgreSqlMigrationsSqlGenerator(MigrationsSqlGeneratorDependencies dependencies, INpgsqlOptions npgsqlOptions) : base(dependencies, npgsqlOptions)
{
}
public ShardingPostgreSqlMigrationsSqlGenerator(MigrationsSqlGeneratorDependencies dependencies, IMigrationsAnnotationProvider migrationsAnnotations, INpgsqlOptions npgsqlOptions) : base(dependencies, migrationsAnnotations, npgsqlOptions)
{
}
/// <inheritdoc />
public CaseInsensitiveSqlGeneratorFactory(QuerySqlGeneratorDependencies dependencies,
INpgsqlOptions npgsqlOptions)
: base(dependencies)
{
_npgsqlOptions = npgsqlOptions;
}
public NpgsqlConventionSetBuilder(
ProviderConventionSetBuilderDependencies dependencies,
RelationalConventionSetBuilderDependencies relationalDependencies,
INpgsqlOptions npgsqlOptions)
: base(dependencies, relationalDependencies)
=> _postgresVersion = npgsqlOptions.PostgresVersion;
/// <inheritdoc />
public NpgsqlQuerySqlGeneratorFactory(
[NotNull] QuerySqlGeneratorDependencies dependencies,
[NotNull] INpgsqlOptions npgsqlOptions)
: base(dependencies)
=> _npgsqlOptions = Check.NotNull(npgsqlOptions, nameof(npgsqlOptions));
