public Table AddTable(string schema, string catalog, string name, string subselect, bool isAbstract, string schemaAction)
{
string key = subselect ?? dialect.Qualify(catalog, schema, name);
Table table;
if (!tables.TryGetValue(key, out table))
{
table = new Table();
table.IsAbstract = isAbstract;
table.Name = name;
table.Schema = schema;
table.Catalog = catalog;
table.Subselect = subselect;
table.SchemaActions = GetSchemaActions(schemaAction);
tables[key] = table;
}
else
{
if (!isAbstract)
{
table.IsAbstract = false;
}
}
return(table);
}
public void ValidateColumns(Dialect.Dialect dialect, IMapping mapping, ITableMetadata tableInfo)
{
IEnumerable <Column> iter = ColumnIterator;
foreach (Column column in iter)
{
IColumnMetadata columnInfo = tableInfo.GetColumnMetadata(column.Name);
if (columnInfo == null)
{
throw new HibernateException(string.Format("Missing column: {0} in {1}", column.Name,
dialect.Qualify(tableInfo.Catalog, tableInfo.Schema, tableInfo.Name)));
}
//TODO: Add new method to ColumnMetadata :getTypeCode
bool typesMatch = column.GetSqlType(dialect, mapping).StartsWith(columnInfo.TypeName, StringComparison.OrdinalIgnoreCase);
//|| columnInfo.get() == column.GetSqlTypeCode(mapping);
if (!typesMatch)
{
throw new HibernateException(string.Format("Wrong column type in {0} for column {1}. Found: {2}, Expected {3}",
dialect.Qualify(tableInfo.Catalog, tableInfo.Schema, tableInfo.Name),
column.Name, columnInfo.TypeName.ToLowerInvariant(),
column.GetSqlType(dialect, mapping)));
}
}
}
/// <summary>
/// Configures the SequenceGenerator by reading the value of <c>sequence</c> and
/// <c>schema</c> from the <c>parms</c> parameter.
/// </summary>
/// <param name="type">The <see cref="IType"/> the identifier should be.</param>
/// <param name="parms">An <see cref="IDictionary"/> of Param values that are keyed by parameter name.</param>
/// <param name="dialect">The <see cref="Dialect.Dialect"/> to help with Configuration.</param>
public virtual void Configure(IType type, IDictionary <string, string> parms, Dialect.Dialect dialect)
{
var nativeSequenceName = PropertiesHelper.GetString(Sequence, parms, "hibernate_sequence");
bool needQuote = StringHelper.IsBackticksEnclosed(nativeSequenceName);
bool isQuelified = nativeSequenceName.IndexOf('.') > 0;
if (isQuelified)
{
string qualifier = StringHelper.Qualifier(nativeSequenceName);
nativeSequenceName = StringHelper.Unqualify(nativeSequenceName);
nativeSequenceName = StringHelper.PurgeBackticksEnclosing(nativeSequenceName);
sequenceName = qualifier + '.' + (needQuote ? dialect.QuoteForTableName(nativeSequenceName) : nativeSequenceName);
}
else
{
nativeSequenceName = StringHelper.PurgeBackticksEnclosing(nativeSequenceName);
sequenceName = needQuote ? dialect.QuoteForTableName(nativeSequenceName) : nativeSequenceName;
}
string schemaName;
string catalogName;
parms.TryGetValue(Parameters, out parameters);
parms.TryGetValue(PersistentIdGeneratorParmsNames.Schema, out schemaName);
parms.TryGetValue(PersistentIdGeneratorParmsNames.Catalog, out catalogName);
if (!isQuelified)
{
sequenceName = dialect.Qualify(catalogName, schemaName, sequenceName);
}
identifierType = type;
sql = new SqlString(dialect.GetSequenceNextValString(sequenceName));
}
/// <summary>
/// Determine the table name to use for the generator values. Called during configuration.
/// </summary>
/// <param name="parms">The parameters supplied in the generator config (plus some standard useful extras).</param>
/// <param name="dialect">The dialect</param>
protected string DetermineGeneratorTableName(IDictionary <string, string> parms, Dialect.Dialect dialect)
{
string name = PropertiesHelper.GetString(TableParam, parms, DefaultTable);
bool isGivenNameUnqualified = name.IndexOf('.') < 0;
if (isGivenNameUnqualified)
{
// NHibernate doesn't seem to have anything resembling this ObjectNameNormalizer. Ignore that for now.
//ObjectNameNormalizer normalizer = ( ObjectNameNormalizer ) params.get( IDENTIFIER_NORMALIZER );
//name = normalizer.normalizeIdentifierQuoting( name );
//// if the given name is un-qualified we may neen to qualify it
//string schemaName = normalizer.normalizeIdentifierQuoting( params.getProperty( SCHEMA ) );
//string catalogName = normalizer.normalizeIdentifierQuoting( params.getProperty( CATALOG ) );
string schemaName;
string catalogName;
parms.TryGetValue(PersistentIdGeneratorParmsNames.Schema, out schemaName);
parms.TryGetValue(PersistentIdGeneratorParmsNames.Catalog, out catalogName);
name = dialect.Qualify(catalogName, schemaName, name);
}
else
{
// if already qualified there is not much we can do in a portable manner so we pass it
// through and assume the user has set up the name correctly.
}
return(name);
}
/// <summary>
/// Gets the schema qualified name of the Table using the specified qualifier
/// </summary>
/// <param name="dialect">The <see cref="Dialect"/> that knows how to Quote the Table name.</param>
/// <param name="defaultCatalog">The catalog name.</param>
/// <param name="defaultSchema">The schema name.</param>
/// <returns>A String representing the Qualified name.</returns>
/// <remarks>If this were used with MSSQL it would return a dbo.table_name.</remarks>
public virtual string GetQualifiedName(Dialect.Dialect dialect, string defaultCatalog, string defaultSchema)
{
if (!string.IsNullOrEmpty(subselect))
{
return("( " + subselect + " )");
}
string quotedName = GetQuotedName(dialect);
string usedSchema = schema == null ? defaultSchema : GetQuotedSchema(dialect);
string usedCatalog = catalog ?? defaultCatalog;
return(dialect.Qualify(usedCatalog, usedSchema, quotedName));
}
/// <summary>
/// Gets the schema qualified name of the Table using the specified qualifier
/// </summary>
/// <param name="dialect">The <see cref="Dialect"/> that knows how to Quote the Table name.</param>
/// <param name="defaultCatalog">The catalog name.</param>
/// <param name="defaultSchema">The schema name.</param>
/// <returns>A String representing the Qualified name.</returns>
/// <remarks>If this were used with MSSQL it would return a dbo.table_name.</remarks>
public virtual string GetQualifiedName(Dialect.Dialect dialect, string defaultCatalog, string defaultSchema)
{
if (!string.IsNullOrEmpty(subselect))
{
return("( " + subselect + " )");
}
var quotedName = GetQuotedName(dialect);
var usedSchema = GetQuotedSchema(dialect, defaultSchema);
var usedCatalog = GetQuotedCatalog(dialect, defaultCatalog);
return(dialect.Qualify(usedCatalog, usedSchema, quotedName));
}
/// <summary>
///
/// </summary>
/// <param name="type"></param>
/// <param name="parms"></param>
/// <param name="dialect"></param>
public void Configure(IType type, IDictionary <string, string> parms, Dialect.Dialect dialect)
{
string tableList;
string column;
string schema;
string catalog;
if (!parms.TryGetValue("tables", out tableList))
{
parms.TryGetValue(PersistentIdGeneratorParmsNames.Tables, out tableList);
}
string[] tables = tableList.Split(", ".ToCharArray(), StringSplitOptions.RemoveEmptyEntries);
if (!parms.TryGetValue("column", out column))
{
parms.TryGetValue(PersistentIdGeneratorParmsNames.PK, out column);
}
_returnClass = type.ReturnedClass;
parms.TryGetValue(PersistentIdGeneratorParmsNames.Schema, out schema);
parms.TryGetValue(PersistentIdGeneratorParmsNames.Catalog, out catalog);
StringBuilder buf = new StringBuilder();
for (int i = 0; i < tables.Length; i++)
{
if (tables.Length > 1)
{
buf.Append("select ").Append(column).Append(" from ");
}
buf.Append(dialect.Qualify(catalog, schema, tables[i]));
if (i < tables.Length - 1)
{
buf.Append(" union ");
}
}
if (tables.Length > 1)
{
buf.Insert(0, "( ").Append(" ) ids_");
column = "ids_." + column;
}
var sqlTxt = string.Format("select max({0}) from {1}", column, buf);
_sql = new SqlString(sqlTxt);
}
/// <summary>
///
/// </summary>
/// <param name="type"></param>
/// <param name="parms"></param>
/// <param name="dialect"></param>
public void Configure(IType type, IDictionary <string, string> parms, Dialect.Dialect dialect)
{
string tableList;
string column;
string schema;
string catalog;
if (!parms.TryGetValue("tables", out tableList))
{
parms.TryGetValue(PersistentIdGeneratorParmsNames.Tables, out tableList);
}
string[] tables = StringHelper.Split(", ", tableList);
if (!parms.TryGetValue("column", out column))
{
parms.TryGetValue(PersistentIdGeneratorParmsNames.PK, out column);
}
returnClass = type.ReturnedClass;
parms.TryGetValue(PersistentIdGeneratorParmsNames.Schema, out schema);
parms.TryGetValue(PersistentIdGeneratorParmsNames.Catalog, out catalog);
StringBuilder buf = new StringBuilder();
for (int i = 0; i < tables.Length; i++)
{
if (tables.Length > 1)
{
buf.Append("select ").Append(column).Append(" from ");
}
buf.Append(dialect.Qualify(catalog, schema, tables[i]));
if (i < tables.Length - 1)
{
buf.Append(" union ");
}
}
if (tables.Length > 1)
{
buf.Insert(0, "( ").Append(" ) ids_");
column = "ids_." + column;
}
sql = "select max(" + column + ") from " + buf;
}
/// <summary>
/// Determine the name of the sequence (or table if this resolves to a physical table) to use.
/// Called during configuration.
/// </summary>
/// <param name="parms"></param>
/// <param name="dialect"></param>
/// <returns></returns>
protected string DetermineSequenceName(IDictionary <string, string> parms, Dialect.Dialect dialect)
{
string sequenceName = PropertiesHelper.GetString(SequenceParam, parms, DefaultSequenceName);
if (sequenceName.IndexOf('.') < 0)
{
string schemaName;
string catalogName;
parms.TryGetValue(PersistentIdGeneratorParmsNames.Schema, out schemaName);
parms.TryGetValue(PersistentIdGeneratorParmsNames.Catalog, out catalogName);
sequenceName = dialect.Qualify(catalogName, schemaName, sequenceName);
}
else
{
// If already qualified there is not much we can do in a portable manner so we pass it
// through and assume the user has set up the name correctly.
}
return(sequenceName);
}
/// <summary>
/// Configures the TableGenerator by reading the value of <c>table</c>,
/// <c>column</c>, and <c>schema</c> from the <c>parms</c> parameter.
/// </summary>
/// <param name="type">The <see cref="IType"/> the identifier should be.</param>
/// <param name="parms">An <see cref="IDictionary"/> of Param values that are keyed by parameter name.</param>
/// <param name="dialect">The <see cref="Dialect"/> to help with Configuration.</param>
public virtual void Configure(IType type, IDictionary <string, string> parms, Dialect.Dialect dialect)
{
tableName = PropertiesHelper.GetString(TableParamName, parms, DefaultTableName);
columnName = PropertiesHelper.GetString(ColumnParamName, parms, DefaultColumnName);
whereClause = PropertiesHelper.GetString(Where, parms, "");
string schemaName = PropertiesHelper.GetString(PersistentIdGeneratorParmsNames.Schema, parms, null);
string catalogName = PropertiesHelper.GetString(PersistentIdGeneratorParmsNames.Catalog, parms, null);
if (tableName.IndexOf('.') < 0)
{
tableName = dialect.Qualify(catalogName, schemaName, tableName);
}
var selectBuilder = new SqlStringBuilder(100);
selectBuilder.Add("select " + columnName)
.Add(" from " + dialect.AppendLockHint(LockMode.Upgrade, tableName));
if (string.IsNullOrEmpty(whereClause) == false)
{
selectBuilder.Add(" where ").Add(whereClause);
}
selectBuilder.Add(dialect.ForUpdateString);
query = selectBuilder.ToString();
columnType = type as PrimitiveType;
if (columnType == null)
{
log.Error("Column type for TableGenerator is not a value type");
throw new ArgumentException("type is not a ValueTypeType", "type");
}
// build the sql string for the Update since it uses parameters
if (type is Int16Type)
{
columnSqlType = SqlTypeFactory.Int16;
}
else if (type is Int64Type)
{
columnSqlType = SqlTypeFactory.Int64;
}
else
{
columnSqlType = SqlTypeFactory.Int32;
}
parameterTypes = new[] { columnSqlType, columnSqlType };
var builder = new SqlStringBuilder(100);
builder.Add("update " + tableName + " set ")
.Add(columnName).Add(" = ").Add(Parameter.Placeholder)
.Add(" where ")
.Add(columnName).Add(" = ").Add(Parameter.Placeholder);
if (string.IsNullOrEmpty(whereClause) == false)
{
builder.Add(" and ").Add(whereClause);
}
updateSql = builder.ToSqlString();
}
private string Identifier(string catalog, string schema, string name)
{
return(dialect.Qualify(catalog, schema, name));
}
