public class OracleNamingStrategy : INamingStrategy
    {
        public string ClassToTableName(string className)
        {
            return AbbreviateName(TableName(StringHelper.Unqualify(className)));
        }

        public string PropertyToColumnName(string propertyName)
        {
            return AbbreviateName(AddUnderscores(propertyName));
        }

        public string TableName(string tableName)
        {
            return AbbreviateName(AddUnderscores(tableName));
        }

        public string ColumnName(string columnName)
        {
            return AbbreviateName(AddUnderscores(columnName));
        }

        public string PropertyToTableName(string className, string propertyName)
        {
            string tableName = "Lt";
            tableName += className.Substring(className.LastIndexOf(".")).Remove(0,1);
            tableName += propertyName.Substring(propertyName.LastIndexOf(".")).Remove(0,1);
            return AbbreviateName(AddUnderscores(tableName));
        }

        public string LogicalColumnName(string columnName, string propertyName)
        {
            return ColumnName(columnName) + '_' + PropertyToColumnName(propertyName);
        }

        private static string AddUnderscores(string name)
        {
            if (name == null)
                return null;
            StringBuilder buf = new StringBuilder(name.Replace('.', '_'));
            for (int i = 1; i < buf.Length - 1; i++)
            {
                if ((IsLowerToUpper(buf, i)))
                {
                    buf.Insert(i++, '_');
                }
            }
            return buf.ToString().ToLower();
        }

        private static bool IsMultipleUpperToLower(StringBuilder buf, int i)
        {
            return i > 1 && char.IsUpper(buf[i - 1])
                    && char.IsUpper(buf[i - 2])
                    && char.IsLower(buf[i]);
        }

        private static bool IsLowerToUpper(StringBuilder buf, int i)
        {
            return char.IsLower(buf[i - 1])
                    && char.IsUpper(buf[i]);
        }

        private static int MAX_LENGTH = 30;

        public static string AbbreviateName(string someName)
        {
            if (someName.Length <= MAX_LENGTH)
                return someName;

            string[] tokens = SplitName(someName);
            ShortenName(someName, tokens);

            return AssembleResults(tokens);
        }

        private static string[] SplitName(string someName)
        {
            string[] tokens = someName.Split(char.Parse("_"));
            return tokens;
        }

        private static void ShortenName(string someName, string[] tokens)
        {
            int currentLength = someName.Length;
            while (currentLength > MAX_LENGTH)
            {
                int tokenIndex = GetIndexOfLongest(tokens);
                string oldToken = tokens[tokenIndex];
                tokens[tokenIndex] = Abbreviate(oldToken);
                currentLength -= oldToken.Length - tokens[tokenIndex].Length;
            }
        }

        private static string AssembleResults(string[] tokens)
        {
            StringBuilder result = new StringBuilder(tokens[0]);
            for (int j = 1; j < tokens.Length; j++)
            {
                result.Append("_").Append(tokens[j]);
            }
            return result.ToString();
        }

        private static string Abbreviate(string token)
        {
            string VOWELS = "AEIOUaeiou";
            bool vowelFound = false;
            for (int i = token.Length - 1; i >= 0; i--)
            {
                if (!vowelFound)
                    vowelFound = VOWELS.Contains(token[i].ToString());
                else if (!VOWELS.Contains(token[i].ToString()))
                    return token.Substring(0, i + 1);
            }
            return "";
        }

        private static int GetIndexOfLongest(string[] tokens)
        {
            int maxLength = 0;
            int index = -1;
            for (int i = 0; i < tokens.Length; i++)
            {
                string tString = tokens[i];
                if (maxLength < tString.Length)
                {
                    maxLength = tString.Length;
                    index = i;
                }
            }
            return index;
        }

    }

Es hat darin noch eine kleine Modifikation: Collection tables werden bei uns mit einem vorangestellten “lt_” benannt.

Hoffe, das nützt jemandem.

– English summary:

I’ve translated the NamingStrategy for Oracle to NHibernate and C#. Small additions:
- I’m not using the IsMultipleUpperToLower() method in AddUnderscores() because I’m not happy with the result when there’s a bunch of consecutive uppercase characters present.
- We want our collection tables to be called lt_* so the above code reflects that.

http://blog.schauderhaft.de/2009/03/07/oracle-naming-strategy-for-hibernate-released-as-a-proper-open-source-project/

And of course the Open Source Project

http://code.google.com/p/hibernate-naming-strategy-for-oracle/