//***************************************************************************//
// Nevet konvertál SQL szöveg névvé, a konvencióinknak megfelelően.          //
//***************************************************************************//
proc ConvertNameToCommandTextName(COMMANDNAME)
    return [COMMANDNAME] "CommandText";
end proc


//***************************************************************************//
// Névből adatbázisművelethez paraméternevet generál.                        //
//***************************************************************************//
proc ConvertNameToCommandParameterName(name)
    return TruncateString("p" ToUpper([name]), 29);
end proc


//***************************************************************************//
// Legenrálja azt a kódtöredéket, ami egy DataReader objektumból kiolvassa   //
// az adatot, az adat típusának és az oszlop indexének megfelelően.          //
//***************************************************************************//
proc GenerateReaderRead(type, column, readername)
    switch (ToLower([type]))
        case "integer":         return "((int)" [readername] ".GetDecimal(" [column] "))";
        case "string":          return [readername] ".GetString(" [column] ")";
        case "datetime":        return [readername] ".GetDateTime(" [column] ")";
        case "boolean":         return "(" [readername] ".GetString(" [column] ")[0] != 'F')";
        case "char":            //return "(" [readername] ".GetString(" [column] ")[0])";
                                return [readername] ".GetString(" [column] ")";
        case "double":          return [readername] ".GetDouble(" [column] ")";
        case "float":           return [readername] ".GetDouble(" [column] ")";
        case "id":              return "((int)" [readername] ".GetDecimal(" [column] "))";
        case "dictionaryitem":  return "((int)" [readername] ".GetDecimal(" [column] ")) /* XXX DictionaryItem */";
        case "binary":          return "((Byte[])" [readername] ".GetValue(" [column] "))";
        case "longstring":      return [readername] ".GetString(" [column] ")";
        case "guid":            return "((Guid)" [readername] ".GetValue(" [column] "))";
    end switch
    return [readername] ".GetInt32(999) /* XXX Ismeretlen tipus: " [type] " */";
end proc



//***************************************************************************//
// Legenerálja azt az SQL töredéket, ami egy entitáshoz tartozó táblaneveket //
// soroja fel, az ősosztályok tábláival együtt.                              //
//                                                                           //
// REKURZÍV!                                                                 //
//***************************************************************************//
proc GenerateSuperClassTableList(MClass)
    local result;
    [result] = "";
    if (GetInheritance([MClass]) == "tpc")
      return [result];
    end if
    loop (MClass -> SuperClass as MBaseClass)
		    [result] = "inner join " ConvertNameToSQLTableName([MBaseClass.name]) " on (" ConvertNameToSQLTableName([MClass.name]) ".ID = " ConvertNameToSQLTableName([MBaseClass.name]) ".ID)";
        [result] = [result] " " GenerateSuperClassTableList([MBaseClass]);
        break;
    end loop

    return [result];
end proc


//***************************************************************************//
// Legenerálja azt az SQL töredéket, ami egy entitás és az ősosztályainak    //
// tábláit kapcsolja össze az SQL where részében.                            //
//                                                                           //
// REKURZÍV!                                                                 //
//***************************************************************************//
template SDA_GetSuperClassSelectFilter(MClass)
[if (IsMasterEntity([MClass]) == "false")]
"([ConvertNameToSQLTableName(GetBaseClassName([MClass], "/* XXX errorhiba van! */"))].ID = [ConvertNameToSQLTableName([MClass.name])].ID) "[if (GetBaseBaseClassName([MClass], "") != "")] +
        [loop (MClass -> SuperClass as MBaseClass)]
"and " + 
[SDA_GetSuperClassSelectFilter([MBaseClass])][break]
        [end loop]
    [end if]
[end if]
end template


//***************************************************************************//
//***************************************************************************//
proc GetReadAttributeMethodName(ATTRIBUTETYPE)
    switch (ToLower([ATTRIBUTETYPE]))
        case "string":          return "ReadStringAttribute";
        case "integer":         return "ReadIntegerAttribute";
        case "datetime":        return "ReadDateTimeAttribute";
        case "boolean":         return "ReadBooleanAttribute";
        case "dictionaryitem":  return "ReadIntegerAttribute";
        case "binary":          return "ReadBinaryAttribute";
        case "float":           return "ReadDoubleAttribute";
        case "char":            return "ReadStringAttribute";
        case "longstring":      return "ReadStringAttribute";
        case "double":          return "ReadDoubleAttribute";
        case "id":              return "ReadIntegerAttribute";
        case "guid":            return "ReadGuidAttribute";
    end switch
    return "Ismeretlen /* XXX Ismeretlen tipus: " [type] " */";
end proc


template GenerateFieldLoadEntityCore(MClass, offset, entityname, readername)
// [MClass.name] mezői
[setVar("counter", [offset])]
[loop (MClass -> MAttribute where [MAttribute.name] != [MClass.name])]

[if (IsAttributeRequired([MAttribute]) == _True())]
[entityname].m_[MAttribute.name] = DAUtil.[GetReadAttributeMethodName([MAttribute.type])]([readername], [counter], [GetCSharpDefaultValueOfAttribute([MAttribute])]);
[else]
[entityname].m_[MAttribute.name] = DAUtil.[GetReadAttributeMethodName([MAttribute.type])]([readername], [counter]);
[end if]

[setVar("counter", incr([counter]))]
[end loop]
[if (GetBaseClassName([MClass], [""]) != [""] )]
    [loop (MClass -> SuperClass as MBaseClass)]
[GenerateFieldLoadEntityCore([MBaseClass], [counter], [entityname], [readername])][break]
    [end loop]
[end if]
end template

template GenerateAssociationLoadEntityCore(MClass, offset, entityname, readername)
// [MClass.name] kapcsoló mezői
[setVar("counter", [offset])]
[loop (MClass -> Role as StartRole -> MAssociation as CurrentAssoc -> MAssociationEnd as EndRole -> MClass as PartnerClass where (([StartRole.id] != [EndRole.id]) and GetStereoType([PartnerClass]) == "Entity"))]
    [if (HasAssociationClass([CurrentAssoc]) == "")]
        [if ([EndRole.multiplicity] == "1")]
DAUtil.ReadIDAttribute([readername], [counter], ref [entityname].m_[ConvertRoleToName([EndRole])], 0);
            [setVar("counter", incr([counter]))]
        [else]
            [if ([EndRole.multiplicity] == "0..1")]
                [if (([StartRole.multiplicity] == "1..*") or ([StartRole.multiplicity] == "*") or ([StartRole.multiplicity] == "0..*"))]
DAUtil.ReadIDAttribute([readername], [counter], ref [entityname].m_[ConvertRoleToName([EndRole])], -1);
                [setVar("counter", incr([counter]))]
                [end if]
            [end if]
        [end if]
    [end if]
[end loop]
[loop (MClass -> MAssociation as CurrentAssoc -> MAssociationEnd as StartRole -> MClass as StartClass where (GetStereoType([StartClass]) == "Entity"))]
    [loop (CurrentAssoc -> MAssociationEnd as EndRole -> MClass as EndClass where([StartRole.id] < [EndRole.id] and GetStereoType([EndClass]) == "Entity" ))]
DAUtil.ReadIDAttribute([readername], [counter], ref [entityname].m_[ConvertRoleToName([StartRole])], 0);
        [setVar("counter", incr([counter]))]
DAUtil.ReadIDAttribute([readername], [counter], ref [entityname].m_[ConvertRoleToName([EndRole])], 0);
        [setVar("counter", incr([counter]))]
    [end loop]
[end loop]
[if (GetBaseClassName([MClass], [""]) != [""] )]
    [loop (MClass -> SuperClass as MBaseClass)]
[GenerateAssociationLoadEntityCore([MBaseClass], [counter], [entityname], [readername])][break]
    [end loop]
[end if]
end template

//***************************************************************************//
// Legenerálja azt a ciklusmagot, amely egy DataReader-ből kiszippantja      //
// az entitás összes mezőjét.                                                //
//                                                                           //
// REKURZÍV!                                                                 //
//***************************************************************************//
template GenerateLoadEntityCore(MClass, offset, entityname, readername)
// [MClass.name] betöltése
[setVar("counter", [offset])]
[GenerateFieldLoadEntityCore([MClass], [counter], [entityname], [readername])]
[GenerateAssociationLoadEntityCore([MClass], [counter], [entityname], [readername])]
end template

template GenerateFieldDynamicLoadEntityCore(MClass, entityname, readername)
// [MClass.name] mezői
[loop (MClass -> MAttribute where [MAttribute.name] != [MClass.name])]
if (((columnFilterMode == ColumnFilterMode.DEFAULT_ALLOWED) ^ (columns.Contains("[MAttribute.name]"))))
{
[if (IsAttributeRequired([MAttribute]) == _True())]
    [entityname].m_[MAttribute.name] = DAUtil.[GetReadAttributeMethodName([MAttribute.type])]([readername], index++, [GetCSharpDefaultValueOfAttribute([MAttribute])]);
[else]
    [entityname].m_[MAttribute.name] = DAUtil.[GetReadAttributeMethodName([MAttribute.type])]([readername], index++);
[end if]
}
[end loop]
[if (GetBaseClassName([MClass], [""]) != [""] )]
    [loop (MClass -> SuperClass as MBaseClass)]
[GenerateFieldDynamicLoadEntityCore([MBaseClass], [entityname], [readername])]
    [end loop]
[end if]
end template

template GenerateAssociationDynamicLoadEntityCore(MClass, entityname, readername)
// [MClass.name] kapcsoló mezői
[loop (MClass -> Role as StartRole -> MAssociation as CurrentAssoc -> MAssociationEnd as EndRole -> MClass as PartnerClass where (([StartRole.id] != [EndRole.id]) and GetStereoType([PartnerClass]) == "Entity"))]
    [if (HasAssociationClass([CurrentAssoc]) == "")]
        [if ([EndRole.multiplicity] == "1")]
DAUtil.ReadIDAttribute([readername], index++, ref [entityname].m_[ConvertRoleToName([EndRole])], 0);
        [else]
            [if ([EndRole.multiplicity] == "0..1")]
                [if (([StartRole.multiplicity] == "1..*") or ([StartRole.multiplicity] == "*") or ([StartRole.multiplicity] == "0..*"))]
DAUtil.ReadIDAttribute([readername], index++, ref [entityname].m_[ConvertRoleToName([EndRole])], -1);
                [end if]
            [end if]
        [end if]
    [end if]
[end loop]
[loop (MClass -> MAssociation as CurrentAssoc -> MAssociationEnd as StartRole -> MClass as StartClass where (GetStereoType([StartClass]) == "Entity"))]
    [loop (CurrentAssoc -> MAssociationEnd as EndRole -> MClass as EndClass where([StartRole.id] < [EndRole.id] and GetStereoType([EndClass]) == "Entity" ))]
DAUtil.ReadIDAttribute([readername], index++, ref [entityname].m_[ConvertRoleToName([StartRole])], 0);
DAUtil.ReadIDAttribute([readername], index++, ref [entityname].m_[ConvertRoleToName([EndRole])], 0);
    [end loop]
[end loop]
[if (GetBaseClassName([MClass], [""]) != [""] )]
    [loop (MClass -> SuperClass as MBaseClass)]
[GenerateAssociationDynamicLoadEntityCore([MBaseClass], [entityname], [readername])]
    [end loop]
[end if]
end template

//***************************************************************************//
// Legenerálja azt a ciklusmagot, amely egy DataReader-ből kiszippantja      //
// az entitás összes mezőjét.                                                //
//                                                                           //
// REKURZÍV!                                                                 //
//***************************************************************************//
template GenerateDynamicLoadEntityCore(MClass, entityname, readername)
// [MClass.name] betöltése
[GenerateFieldDynamicLoadEntityCore([MClass], [entityname], [readername])]
[GenerateAssociationDynamicLoadEntityCore([MClass], [entityname], [readername])]
end template


//***************************************************************************//
// Legenerálja azt az SQL töredéket, ami egy entitás attribútumaihoz tartozó //
// mezőket, és az asszociációs kapcsolómezőket tartalmazza.                  //
//                                                                           //
// REKURZÍV!                                                                 //
//***************************************************************************//
template GenerateFieldListWithBaseClassFields(MClass, entityname)
// [MClass.name] betöltése
[GenerateAttributeFieldListWithBaseClassFields([MClass], [entityname])]
[GenerateAssociationFieldListWithBaseClassFields([MClass], [entityname] )]
[GenerateIdAndSerialFields([MClass], [entityname] )]
end template

template GenerateIdAndSerialFields(MClass, entityname)
[if (IsMasterEntity([MClass]) == "false")]
    [loop (MClass -> SuperClass as MBaseClass)]
      [if (GetInheritance([MClass]) == "tpc")]
[GenerateIdAndSerialFields([MBaseClass], [entityname])][break]     
      [else]
[GenerateIdAndSerialFields([MBaseClass], [MBaseClass.name])][break]
      [end if]
    [end loop]
[else]
"[ConvertNameToSQLTableName([entityname])].TOROLT, " +
"[ConvertNameToSQLTableName([entityname])].SERIAL, " +
"[ConvertNameToSQLTableName([entityname])].CREATED, " +
"[ConvertNameToSQLTableName([entityname])].CREATOR, " +
"[ConvertNameToSQLTableName([entityname])].LASTCHANGED, " +
"[ConvertNameToSQLTableName([entityname])].MODIFIER " +
[end if]
end template

template GenerateAssociationFieldListWithBaseClassFields(MClass, entityname)
// [MClass.name] kapcsoló mezői
[loop (MClass -> Role as StartRole -> MAssociation as CurrentAssoc -> MAssociationEnd as EndRole -> MClass as PartnerClass where (([StartRole.id] != [EndRole.id]) and GetStereoType([PartnerClass]) == "Entity"))]
    [if (HasAssociationClass([CurrentAssoc]) == "")]
        [if ([EndRole.multiplicity] == "1")]
"[ConvertNameToSQLTableName([entityname])].[ConvertNameToSQLColumnName(ConvertRoleToName([EndRole]))], " + /* Kötelező asszociációs kapcsolómező */
        [else]
            [if ([EndRole.multiplicity] == "0..1")]
                [if (([StartRole.multiplicity] == "1..*") or ([StartRole.multiplicity] == "*") or ([StartRole.multiplicity] == "0..*"))]
"[ConvertNameToSQLTableName([entityname])].[ConvertNameToSQLColumnName(ConvertRoleToName([EndRole]))], " + /* Opcionális asszociációs kapcsolómező */
                [end if]
            [end if]
        [end if]
    [end if]
[end loop]
[loop (MClass -> MAssociation as CurrentAssoc -> MAssociationEnd as StartRole -> MClass as StartClass where (GetStereoType([StartClass]) == "Entity"))]
    [loop (CurrentAssoc -> MAssociationEnd as EndRole -> MClass as EndClass where([StartRole.id] < [EndRole.id] and GetStereoType([EndClass]) == "Entity" ))]
"[ConvertNameToSQLTableName([entityname])].[ConvertNameToSQLColumnName(ConvertRoleToName([StartRole]))], " + /* Asszociációs mező */
"[ConvertNameToSQLTableName([entityname])].[ConvertNameToSQLColumnName(ConvertRoleToName([EndRole]))], " + /* Asszociációs mező */
    [end loop]
[end loop]
[if (IsMasterEntity([MClass]) == "false")]
    [loop (MClass -> SuperClass as MBaseClass)]
    [if (GetInheritance([MClass]) == "tpc")]    
[GenerateAssociationFieldListWithBaseClassFields([MBaseClass], [entityname])][break]
    [else]
[GenerateAssociationFieldListWithBaseClassFields([MBaseClass], [MBaseClass.name])][break]    
    [end if]
    [end loop]
[end if]
end template

template GenerateAttributeFieldListWithBaseClassFields(MClass, entityname)
// [MClass.name] mezői
[loop (MClass->MAttribute)]
"[ConvertNameToSQLTableName([entityname])].[ConvertNameToSQLColumnName([MAttribute.name])], " +
[end loop]
[if (IsMasterEntity([MClass]) == "false")]
    [loop (MClass -> SuperClass as MBaseClass)]
    [if (GetInheritance([MClass]) == "tpc")]    
[GenerateAttributeFieldListWithBaseClassFields([MBaseClass], [entityname])][break]
    [else]
[GenerateAttributeFieldListWithBaseClassFields([MBaseClass], [MBaseClass.name])][break]  
    [end if]
    [end loop]
[end if]
end template

//********************************************************************************//
// Legenerálja azt az SQL töredéket, ami egy entitás alap attribútumaihoz tartozó //
// mezőket, és az asszociációs kapcsolómezőket tartalmazza.                       //
//                                                                                //
// REKURZÍV!                                                                      //
//********************************************************************************//
template GenerateDynamicFieldListWithBaseClassFields(MClass, entityname)
// [MClass.name] betöltése
[GenerateAssociationFieldListWithBaseClassFields([MClass], [entityname])]
[GenerateIdAndSerialFields([MClass], [entityname])]
end template

//***************************************************************************//
// Legenerálja a DataAccess.csproj fájl szerelvény hivatkozási szekciójának  //
// azt a részét, ami az adatbáziskezelésre vonatkozik. Ez adatbázisonként    //
// más.                                                                      //
//***************************************************************************//
template GenerateDataAccessAssemblyReferences()
[if ([DBTYPE] == "UniDirect")]
<Reference
    Name = "CoreLab.UniDirect"
    AssemblyName = "CoreLab.UniDirect"
    HintPath = "..\References\CoreLab.UniDirect.dll"
/>
[else][if ([DBTYPE] == "ODP")]
<Reference
    Name = "Oracle.DataAccess"
    AssemblyName = "Oracle.DataAccess"
    HintPath = "..\References\Oracle.DataAccess.dll"
    AssemblyFolderKey = "hklm\dn\odp.net"
/>
[else][if ([DBTYPE] == "OracleClient")]
<Reference
    Name = "System.Data.OracleClient"
    AssemblyName = "System.Data.OracleClient"
    HintPath = "..\References\System.Data.OracleClient.dll"
/>
[else][if ([DBTYPE] == "SDA")]
<Reference
    Name = "SDA.DataProvider"
    AssemblyName = "SDA.DataProvider"
    HintPath = "..\References\SDA.DataProvider.dll"
/>
[end if][end if][end if][end if]
end template


//***************************************************************************//
// Legenerálja azt a kóddarabot, ami egy command obejktum inicializálását    //
// végzi. Ez adatbázisonként más.                                            //
//***************************************************************************//
template GenerateCommandInit(COMMANDNAME)
[if ([DBTYPE] == "SDA")]
[COMMANDNAME].Connection = UserContext.Instance.SDAConnection;
[COMMANDNAME].Transaction = UserContext.Instance.SDATransaction;
[else]
[COMMANDNAME].Connection = UserContext.Instance.DBConnection;
    [if ([DBTYPE] != "ODP")]
[COMMANDNAME].Transaction = UserContext.Instance.Transaction;
    [end if]
[end if]
end template


//***************************************************************************//
// Visszaadja a megadott típusnak megfelelő adatbázistípus nevét a C# nyelv  //
// és a .NET keretrendszernek megfelelően. Ez adatbázisonként más.           //
//***************************************************************************//
proc GetCSharpDatasetType(type, isunicode)
    switch ([DBTYPE])
        case "SDA":
            switch(ToLower([type]))
                case "string":          
                  if ([isunicode] == "true")
                    return "SDA.DataProvider.SDADBType.String";
                  else
                    return "SDA.DataProvider.SDADBType.NonUnicodeString";
                  end if
                case "integer":         return "SDA.DataProvider.SDADBType.Int";
                case "datetime":        return "SDA.DataProvider.SDADBType.DateTime";
                case "boolean":         return "SDA.DataProvider.SDADBType.Boolean /* Boolean */";
                case "dictionaryitem":  return "SDA.DataProvider.SDADBType.Int /* DictionaryItem */";
                case "binary":          return "SDA.DataProvider.SDADBType.Binary /* Binary */";
                case "float":           return "SDA.DataProvider.SDADBType.Double";
                case "char":            return "SDA.DataProvider.SDADBType.Char";
                case "id":              return "SDA.DataProvider.SDADBType.Int";
                case "longstring":      return "SDA.DataProvider.SDADBType.LongString";
                case "guid":            return "SDA.DataProvider.SDADBType.Guid";
                
            end switch
            return "0 /* ERROR Ismeretlen tipus: " [type] " */";
        case "UniDirect":
            switch(ToLower([type]))
                case "string":          return "System.Data.DbType.String";
                case "integer":         return "System.Data.DbType.Int32";
                case "datetime":        return "System.Data.DbType.DateTime";
                case "boolean":         return "System.Data.DbType.Boolean";
                case "dictionaryitem":  return "System.Data.DbType.Int32 /* DictionaryItem */";
                case "binary":          return "System.Data.DbType.Binary /* Binary */";
                case "float":           return "System.Data.DbType.Double";
                case "char":            return "System.Data.DbType.StringFixedLength";
                case "id":              return "System.Data.DbType.Int32";
            end switch
            return "0 /* ERROR Ismeretlen tipus: " [type] " */";
        case "ODP":
            switch(ToLower([type]))
                case "string":          return "Oracle.DataAccess.Client.OracleDbType.Varchar2";
                case "integer":         return "Oracle.DataAccess.Client.OracleDbType.Int32";
                case "datetime":        return "Oracle.DataAccess.Client.OracleDbType.Date";
                case "boolean":         return "Oracle.DataAccess.Client.OracleDbType.Char";
                case "dictionaryitem":  return "Oracle.DataAccess.Client.OracleDbType.Int32 /* DictionaryItem */";
                case "binary":          return "Oracle.DataAccess.Client.OracleDbType.Raw /* Binary */";
                case "float":           return "Oracle.DataAccess.Client.OracleDbType.Double";
                case "char":            //return "Oracle.DataAccess.Client.OracleDbType.Char";
                                        return "Oracle.DataAccess.Client.OracleDbType.Varchar2";
                case "id":              return "Oracle.DataAccess.Client.OracleDbType.Int32";
            end switch
            return "0 /* ERROR Ismeretlen tipus: " [type] " */";
        case "OracleClient":
            switch(ToLower([type]))
                case "string":          return "System.Data.OracleClient.OracleType.VarChar";
                case "integer":         return "System.Data.OracleClient.OracleType.Number";
                case "datetime":        return "System.Data.OracleClient.OracleType.DateTime";
                case "boolean":         return "System.Data.OracleClient.OracleType.Char";
                case "dictionaryitem":  return "System.Data.OracleClient.OracleType.Number /* DictionaryItem */";
                case "binary":          return "System.Data.OracleClient.OracleType.Raw /* Binary */";
                case "float":           return "System.Data.OracleClient.OracleType.Float";
                case "char":            return "System.Data.OracleClient.OracleType.Char";
                case "id":              return "System.Data.OracleClient.OracleType.Number";
            end switch
            return "System.Data.SqlDbType.Variant /* ERROR Ismeretlen tipus: " [type] " */";
    end switch

    return "/* Érvénytelen adatbázistípus: " [DBTYPE] " */";
end proc


//***************************************************************************//
// Visszaadja az adatbázisspecifikus C# ID típus nevét. Ez adatbázisonként   //
// más.                                                                      //
//***************************************************************************//
proc GetCSharpSQLIDType()
    switch ([DBTYPE])
        case "SDA":             return "SDA.DataProvider.SDADBType.Int";
        case "UniDirect":       return "System.Data.DbType.Int32";
        case "ODP":             return "Oracle.DataAccess.Client.OracleDbType.Int32";
        case "OracleClient":    return "System.Data.OracleClient.OracleType.Number";
    end switch
    return "/* Érvénytelen adatbázistípus: " [DBTYPE] " */";
end proc


//***************************************************************************//
// Visszaadja az adatbázisspecifikus C# ROWID típus nevét. Ez                //
// adatbázisonként más.                                                      //
//***************************************************************************//
proc GetCSharpSQLRowIDType()
    switch ([DBTYPE])
        case "SDA":             return "SDA.DataProvider.SDADBType.String";
        case "UniDirect":       return "System.Data.DbType.String";
        case "ODP":             return "Oracle.DataAccess.Client.OracleDbType.Varchar2";
        case "OracleClient":    return "System.Data.OracleClient.OracleType.VarChar";
    end switch
    return "/* Érvénytelen adatbázistípus: " [DBTYPE] " */";
end proc


//***************************************************************************//
// Visszaadja az adatbázisspecifikus C# DBCommand típus nevét. Ez            //
// adatbázisonként más.                                                      //
//***************************************************************************//
proc GetCSharpSQLCommandType()
    switch ([DBTYPE])
        case "SDA":             return "SDA.DataProvider.SDACommand";
        case "UniDirect":       return "CoreLab.UniDirect.UniCommand";
        case "ODP":             return "Oracle.DataAccess.Client.OracleCommand";
        case "OracleClient":    return "System.Data.OracleClient.OracleCommand";
    end switch
    return "/* Érvénytelen adatbázistípus: " [DBTYPE] " */";
end proc


//***************************************************************************//
// Visszaadja az adatbázisspecifikus C# CommandParameter típus nevét. Ez     //
// adatbázisonként más.                                                      //
//***************************************************************************//
proc GetCSharpSQLCommandParameterType()
    switch ([DBTYPE])
        case "SDA":             return "SDA.DataProvider.SDACommandParameter";
        case "UniDirect":       return "CoreLab.UniDirect.UniParameter";
        case "ODP":             return "Oracle.DataAccess.Client.OracleParameter";
        case "OracleClient":    return "System.Data.OracleClient.OracleParameter";
    end switch
    return "/* Érvénytelen adatbázistípus: " [DBTYPE] " */";
end proc


//***************************************************************************//
// Visszaadja az adatbázisspecifikus C# DBConnection típus nevét. Ez         //
// adatbázisonként más.                                                      //
//***************************************************************************//
proc GetCSharpSQLConnectionType()
    switch ([DBTYPE])
        case "SDA":             return "SDA.DataProvider.SDAConnection";
        case "UniDirect":       return "CoreLab.UniDirect.UniConnection";
        case "ODP":             return "Oracle.DataAccess.Client.OracleConnection";
        case "OracleClient":    return "System.Data.OracleClient.OracleConnection";
    end switch
    return "/* Érvénytelen adatbázistípus: " [DBTYPE] " */";
end proc


//***************************************************************************//
// Visszaadja az adatbázisspecifikus C# Transaction típus nevét. Ez          //
// adatbázisonként más.                                                      //
//***************************************************************************//
proc GetCSharpSQLTransactionType()
    switch ([DBTYPE])
        case "SDA":             return "SDA.DataProvider.SDATransaction";
        case "UniDirect":       return "CoreLab.UniDirect.UniTransaction";
        case "ODP":             return "Oracle.DataAccess.Client.OracleTransaction";
        case "OracleClient":    return "System.Data.OracleClient.OracleTransaction";
    end switch
    return "/* Érvénytelen adatbázistípus: " [DBTYPE] " */";
end proc


//***************************************************************************//
// Visszaadja az adatbázisspecifikus C# DataReader típus nevét. Ez           //
// adatbázisonként más.                                                      //
//***************************************************************************//
proc GetCSharpSQLDataReaderType()
    switch ([DBTYPE])
        case "SDA":             return "SDA.DataProvider.SDADataReader";
        case "UniDirect":       return "CoreLab.UniDirect.UniDataReader";
        case "ODP":             return "Oracle.DataAccess.Client.OracleDataReader";
        case "OracleClient":    return "System.Data.OracleClient.OracleDataReader";
    end switch
    return "/* Érvénytelen adatbázistípus: " [DBTYPE] " */";
end proc


//***************************************************************************//
// Visszaadja egy művelethez tartozó SQL parancsobjektum nevét.              //
//***************************************************************************//
proc ConvertNameToCommandName(operation)
    return [operation] "Command";
end proc


//***************************************************************************//
// Visszaadja egy művelethez tartozó SQL parancsobjektum                     //
// megcsinálómetódusának a nevét.                                            //
//***************************************************************************//
proc GenerateCommandCreatorName(CommandName)
    return "Create" [CommandName] "Command";
end proc


//***************************************************************************//
// Egy SQL parancs típusú property-t generál.                                //
//***************************************************************************//
template GenerateCommandGetterProperty(COMMANDNAME)
[if ([COMMANDCACHE] == "True")]
private [GetCSharpSQLCommandType()] m_[ConvertNameToCommandName([COMMANDNAME])] = null;
[end if]
private [GetCSharpSQLCommandType()] [ConvertNameToCommandName([COMMANDNAME])]
{
    get
    {
        [if ([COMMANDCACHE] == "True")]
        if (this.m_[ConvertNameToCommandName([COMMANDNAME])] == null)
        {
            this.m_[ConvertNameToCommandName([COMMANDNAME])] = this.[GenerateCommandCreatorName([COMMANDNAME])]();
        }

        return this.m_[ConvertNameToCommandName([COMMANDNAME])];
        [else]
        return this.[GenerateCommandCreatorName([COMMANDNAME])]();
        [end if]
    }
}
end template


//***************************************************************************//
// Legenerálja egy entitás SERIAL rendszeroszlopának SQL töredékét, teljesen //
// minősített névvel.                                                        //
//***************************************************************************//
template GenerateSerialColumn(MClass as ENTITY)
[if (IsMasterEntity([ENTITY]) == "false")]
    [loop (ENTITY -> SuperClass as BASECLASS)]
[GenerateSerialColumn([BASECLASS])][break]
    [end loop]
[else]
[ConvertNameToSQLTableName([ENTITY.name])].SERIAL
[end if]
end template


//***************************************************************************//
// Legenerálja azt a kóddarabot, ami egy command obejktum inicializálását    //
// végzi. Ez adatbázisonként más. Szükség esetén a szűréket is réteszi az    //
// SQL parancsszövegre.                                                      //
//***************************************************************************//
template GenerateCommandInitialization(COMMANDNAME, COMMANDTEXTNAME, ENTITYNAME, OPERATIONNAME, APPLYFILTERS, MASTERNAME)
[if ([DBTYPE] == "SDA")]
[COMMANDNAME].Connection = UserContext.Instance.SDAConnection;
[COMMANDNAME].Transaction = UserContext.Instance.SDATransaction;
    [if ([APPLYFILTERS] == "False")]
[COMMANDNAME].CommandText = [ConvertNameToCommandTextName([COMMANDTEXTNAME])];
    [else]
[COMMANDNAME].CommandText = [ConvertNameToCommandTextName([COMMANDTEXTNAME])];
Kreta.Framework.FilterApplier.ApplyFilters([COMMANDNAME], "[ENTITYNAME]", "[MASTERNAME]");
    [end if]
[else]
[COMMANDNAME].Connection = UserContext.Instance.DBConnection;
    [if ([DBTYPE] != "ODP")]
[COMMANDNAME].Transaction = UserContext.Instance.Transaction;
    [end if]
    [if ([APPLYFILTERS] == "False")]
[COMMANDNAME].CommandText = [ConvertNameToCommandTextName([COMMANDTEXTNAME])];
    [else]
[COMMANDNAME].CommandText = [ConvertNameToCommandTextName([COMMANDTEXTNAME])];
Kreta.Framework.FilterApplier.ApplyFilters([COMMANDNAME], "[ENTITYNAME]", "[MASTERNAME]");
    [end if]
[end if]
end template


////***************************************************************************////
////***************************************************************************////
////***************************************************************************////
////                                                                           //// 
//// Valószínüleg már nem használt kód                                         ////
////                                                                           //// 
////***************************************************************************////
////***************************************************************************////
////***************************************************************************////




//***************************************************************************//
// Megjegyzés?                                                               //
//***************************************************************************//
template GenerateDuoSelectWhere(MClass as CurrentClass, MAssociationEnd as StartRole, MAssociation as CurrentAssoc, MAssociationEnd as EndRole, MClass as PartnerClass, MClass as AssocClass)
"([ConvertNameToSQLTableName([AssocClass.name])].[ConvertNameToSQLColumnName(ConvertRoleToName([StartRole]))] = [ConvertNameToSQLParamName(ConvertRoleToName([StartRole]))]) " +
[if (IsMasterEntity([PartnerClass]) == "true")]
"and ([ConvertNameToSQLTableName([PartnerClass.name])].ID = [ConvertNameToSQLTableName([AssocClass.name])].[ConvertNameToSQLColumnName(ConvertRoleToName([EndRole]))])"
[else]
"and ([ConvertNameToSQLTableName([PartnerClass.name])].ID = [ConvertNameToSQLTableName([AssocClass.name])].[ConvertNameToSQLColumnName(ConvertRoleToName([EndRole]))]) " +
"and " +
[SDA_GetSuperClassSelectFilter([PartnerClass])]
[end if]
end template


//***************************************************************************//
// Megjegyzés?                                                               //
//***************************************************************************//
template GenerateDuoSelectFrom(MClass as CurrentClass, MAssociationEnd as StartRole, MAssociation as CurrentAssoc, MAssociationEnd as EndRole, MClass as PartnerClass, MClass as AssociationClass)
[/*
"[ConvertNameToSQLTableName([AssociationClass.name])], " +
"[ConvertNameToSQLTableName([PartnerClass.name])] " +
*/]
"[GenerateSuperClassTableList([AssociationClass])], " +
"[GenerateSuperClassTableList([PartnerClass])] " +
end template


//***************************************************************************//
// Megjegyzés?                                                               //
//***************************************************************************//
proc SDA_GetFieldLength(MAttribute)
    local result;
    [result] = GetAttributeLength([MAttribute]);
    if ([result] != "")
        [result] = ", " [result];
    end if
    return [result];
end proc