← Back to branch summary

~halega/+junk/sharpdevelop

« back to all changes in this revision

Viewing changes to src/AddIns/DisplayBindings/Data/ICSharpCode.Data.SQLServer/SQLServerDatabaseDriver.cs

  • Committer: sk
  • Date: 2011-09-10 05:17:57 UTC
  • Revision ID: halega@halega.com-20110910051757-qfouz1llya9m6boy
4.1.0.7915 Release Candidate 1

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/AddIns/DisplayBindings/Data/ICSharpCode.Data.SQLServer/SQLServerDatabaseDriver.cs
 
1
// Copyright (c) AlphaSierraPapa for the SharpDevelop Team (for details please see \doc\copyright.txt)
 
2
// This code is distributed under the GNU LGPL (for details please see \doc\license.txt)
 
3
 
 
4
#region Usings
 
5
 
 
6
using System;
 
7
using System.Collections.Generic;
 
8
using System.Linq;
 
9
using System.Text;
 
10
using System.Data;
 
11
using System.Data.Sql;
 
12
using ICSharpCode.Data.Core.Common;
 
13
using ICSharpCode.Data.Core.Interfaces;
 
14
using System.Collections.ObjectModel;
 
15
using ICSharpCode.Data.Core.DatabaseObjects;
 
16
using System.Data.SqlClient;
 
17
using System.Collections.Specialized;
 
18
using ICSharpCode.Data.Core.Enums;
 
19
using System.Windows;
 
20
using System.Windows.Threading;
 
21
 
 
22
#endregion
 
23
 
 
24
namespace ICSharpCode.Data.Core.DatabaseDrivers.SQLServer
 
25
{
 
26
    public class SQLServerDatabaseDriver : DatabaseDriver<SQLServerDatasource>
 
27
    {
 
28
        #region Consts
 
29
        
 
30
        private const string _getTables = @"SELECT TABLE_SCHEMA, TABLE_NAME from INFORMATION_SCHEMA.TABLES WHERE TABLE_TYPE='BASE TABLE' AND TABLE_NAME<>'dtproperties' ORDER BY TABLE_SCHEMA, TABLE_NAME";
 
31
 
 
32
        private const string _getColumnsScript = @"DECLARE @tablename varchar(100) SET @tablename = N'{0}'
 
33
            SELECT
 
34
                clmns.column_id AS [ColumnId],
 
35
                clmns.name AS [Name],
 
36
                usrt.name AS [DataType],
 
37
                ISNULL(baset.name, N'') AS [SystemType],
 
38
                CAST(CASE WHEN baset.name IN (N'nchar', N'nvarchar') AND clmns.max_length <> -1 THEN
 
39
                clmns.max_length/2 ELSE 0 END AS INT) AS [Length],
 
40
                CAST(clmns.precision AS int) AS [NumericPrecision],
 
41
                clmns.default_object_id AS [DefaultObjectId],
 
42
                clmns.is_ansi_padded AS [IsAnsiPadded],
 
43
                clmns.is_column_set AS [IsColumnSet],
 
44
                clmns.is_computed AS [IsComputed],
 
45
                clmns.is_dts_replicated AS [IsDtsReplicated],
 
46
                clmns.is_filestream AS [IsFileStream],
 
47
                clmns.is_identity AS [IsIdentity],
 
48
                clmns.is_merge_published AS [IsMergePublished],
 
49
                clmns.is_non_sql_subscribed AS [IsNonSqlSubscribed],
 
50
                clmns.is_nullable AS [IsNullable],
 
51
                clmns.is_replicated AS [IsReplicated],
 
52
                clmns.is_rowguidcol AS [IsRowGuidCol],
 
53
                clmns.is_sparse AS [IsSparse],
 
54
                clmns.is_xml_document AS [IsXmlDocument],
 
55
                clmns.object_id AS [ObjectId],
 
56
                clmns.rule_object_id AS [RuleObjectId],
 
57
                clmns.scale AS [Scale],
 
58
                clmns.system_type_id AS [SystemTypeId],
 
59
                clmns.user_type_id AS [UserTypeId],
 
60
                clmns.xml_collection_id AS [XMLCollectionId],
 
61
                CAST(
 
62
                                        CASE WHEN (
 
63
                                                SELECT c.name AS ColumnName
 
64
                                                        FROM sys.key_constraints AS k
 
65
                                                        JOIN sys.tables AS t ON t.object_id = k.parent_object_id
 
66
                                                        JOIN sys.schemas AS s ON s.schema_id = t.schema_id
 
67
                                                        JOIN sys.index_columns AS ic ON ic.object_id = t.object_id AND ic.index_id = k.unique_index_id
 
68
                                                        JOIN sys.columns AS c ON c.object_id = t.object_id AND c.column_id = ic.column_id
 
69
                                                        WHERE t.name=@tablename AND c.name = clmns.name) 
 
70
                                        IS NULL THEN 0 ELSE 1 END AS BIT) AS [IsPrimaryKey]
 
71
            FROM
 
72
            sys.{1} AS tbl
 
73
            INNER JOIN sys.all_columns AS clmns ON clmns.object_id=tbl.object_id
 
74
            LEFT OUTER JOIN sys.types AS usrt ON usrt.user_type_id = clmns.user_type_id
 
75
            LEFT OUTER JOIN sys.types AS baset ON baset.user_type_id = clmns.system_type_id and 
 
76
            baset.user_type_id = baset.system_type_id
 
77
            WHERE
 
78
            (tbl.name=@tablename and SCHEMA_NAME(tbl.schema_id)=N'{2}')
 
79
            ORDER BY
 
80
            clmns.column_id ASC";
 
81
 
 
82
        private const string _getConstraintsScript = @"SELECT 
 
83
                FKTable  = FK.TABLE_NAME, 
 
84
                FKColumn = CU.COLUMN_NAME, 
 
85
                PKTable  = PK.TABLE_NAME, 
 
86
                PKColumn = PT.COLUMN_NAME, 
 
87
                ConstraintName = C.CONSTRAINT_NAME 
 
88
            FROM 
 
89
                INFORMATION_SCHEMA.REFERENTIAL_CONSTRAINTS C 
 
90
                INNER JOIN 
 
91
                INFORMATION_SCHEMA.TABLE_CONSTRAINTS FK 
 
92
                    ON C.CONSTRAINT_NAME = FK.CONSTRAINT_NAME 
 
93
                INNER JOIN 
 
94
                INFORMATION_SCHEMA.TABLE_CONSTRAINTS PK 
 
95
                    ON C.UNIQUE_CONSTRAINT_NAME = PK.CONSTRAINT_NAME 
 
96
                INNER JOIN 
 
97
                INFORMATION_SCHEMA.KEY_COLUMN_USAGE CU 
 
98
                    ON C.CONSTRAINT_NAME = CU.CONSTRAINT_NAME 
 
99
                INNER JOIN 
 
100
                ( 
 
101
                    SELECT 
 
102
                        i1.TABLE_NAME, i2.COLUMN_NAME 
 
103
                    FROM 
 
104
                        INFORMATION_SCHEMA.TABLE_CONSTRAINTS i1 
 
105
                        INNER JOIN 
 
106
                        INFORMATION_SCHEMA.KEY_COLUMN_USAGE i2 
 
107
                        ON i1.CONSTRAINT_NAME = i2.CONSTRAINT_NAME 
 
108
                        WHERE i1.CONSTRAINT_TYPE = 'PRIMARY KEY' 
 
109
                ) PT 
 
110
                ON PT.TABLE_NAME = PK.TABLE_NAME 
 
111
            -- optional: 
 
112
            ORDER BY 
 
113
                1,2,3,4";
 
114
 
 
115
        private const string _getViews = @"SELECT TABLE_SCHEMA, TABLE_NAME FROM INFORMATION_SCHEMA.TABLES WHERE TABLE_TYPE='VIEW' AND TABLE_NAME<>'dtproperties' ORDER BY TABLE_SCHEMA, TABLE_NAME";
 
116
        private const string _getViewDefiningQuery = @"EXEC sp_helptext '{0}'";
 
117
        private const string _getProcedures = "SELECT ROUTINE_NAME, ROUTINE_SCHEMA, ROUTINE_BODY, DATA_TYPE, CHARACTER_MAXIMUM_LENGTH FROM INFORMATION_SCHEMA.ROUTINES WHERE ROUTINE_TYPE = 'PROCEDURE'";
 
118
        private const string _getProcedureParameters = @"SELECT PARAMETER_NAME, DATA_TYPE, CHARACTER_MAXIMUM_LENGTH, PARAMETER_MODE, IS_RESULT FROM information_schema.PARAMETERS WHERE SPECIFIC_NAME = '{0}' AND SPECIFIC_SCHEMA = '{1}' AND SPECIFIC_CATALOG = '{2}'";
 
119
 
 
120
        #endregion
 
121
        
 
122
        public override string Name
 
123
        {
 
124
            get { return "MS SQL Server"; }
 
125
        }
 
126
 
 
127
        public override string ProviderName
 
128
        {
 
129
            get { return "System.Data.SqlClient"; }
 
130
        }
 
131
 
 
132
        public override string ODBCProviderName
 
133
        {
 
134
            get { return "SQLNCLI10.1"; }
 
135
        }
 
136
 
 
137
        public override void PopulateDatasources()
 
138
        {
 
139
            DatabaseObjectsCollection<SQLServerDatasource> datasources = new DatabaseObjectsCollection<SQLServerDatasource>(null);
 
140
            
 
141
            DataTable dt = SqlDataSourceEnumerator.Instance.GetDataSources();
 
142
 
 
143
            foreach (DataRow dr in dt.Rows)
 
144
            {
 
145
                string serverName = dr["ServerName"].ToString().Trim().ToUpper();
 
146
                string instanceName = null;
 
147
                string version = null;
 
148
 
 
149
                if (dr["InstanceName"] != null && dr["InstanceName"] != DBNull.Value)
 
150
                    instanceName = dr["InstanceName"].ToString().Trim().ToUpper();
 
151
 
 
152
                if (dr["Version"] != null && dr["Version"] != DBNull.Value)
 
153
                    version = dr["Version"].ToString().Trim().Split('.').FirstOrDefault();
 
154
                   
 
155
                SQLServerDatasource datasource = new SQLServerDatasource(this) { Name = serverName };
 
156
 
 
157
                if (version == "8")
 
158
                    datasource.ProviderManifestToken = "2000";
 
159
                else if (version == "9")
 
160
                    datasource.ProviderManifestToken = "2005";
 
161
                else if (version == "10")
 
162
                    datasource.ProviderManifestToken = "2008";
 
163
 
 
164
                if (!String.IsNullOrEmpty(instanceName))
 
165
                    datasource.Name += "\\" + instanceName;
 
166
 
 
167
                datasources.Add(datasource);
 
168
            }
 
169
 
 
170
            Datasources = datasources;
 
171
        }
 
172
 
 
173
        public override void PopulateDatabases(IDatasource datasource)
 
174
        {
 
175
            DatabaseObjectsCollection<IDatabase> databases = new DatabaseObjectsCollection<IDatabase>(datasource);
 
176
            
 
177
            SqlConnection sqlConnection = null;
 
178
            sqlConnection = new SqlConnection();
 
179
            sqlConnection.ConnectionString = datasource.ConnectionString; 
 
180
            try
 
181
            {
 
182
                sqlConnection.Open();
 
183
            }
 
184
            catch (SqlException ex)
 
185
            {
 
186
                switch (ex.Number)
 
187
                { 
 
188
                    case 2:
 
189
                    case 3:
 
190
                    case 53:
 
191
                        Application.Current.Dispatcher.BeginInvoke(DispatcherPriority.Background, new Action(() =>
 
192
                        {
 
193
                            Datasources.Remove(datasource as SQLServerDatasource);
 
194
                        }));
 
195
                        break;
 
196
                    default:
 
197
                        break;
 
198
                }
 
199
 
 
200
                throw ex;
 
201
            }
 
202
 
 
203
            string sqlversion = sqlConnection.ServerVersion;
 
204
            sqlversion = sqlversion.Split('.').FirstOrDefault(); //major version
 
205
            int intsqlversion = Convert.ToInt32(sqlversion);
 
206
            string sql = string.Empty;
 
207
 
 
208
            if (intsqlversion == 8)
 
209
                datasource.ProviderManifestToken = "2000";
 
210
            else if (intsqlversion == 9)
 
211
                datasource.ProviderManifestToken = "2005";
 
212
            else if (intsqlversion == 10)
 
213
                datasource.ProviderManifestToken = "2008";
 
214
 
 
215
            if (intsqlversion >= 9)
 
216
                sql = "use master; select name from sys.databases order by name";
 
217
            else
 
218
                sql = "use master; select name from sysdatabases order by name";
 
219
 
 
220
            SqlCommand sqlCommand = new SqlCommand(sql, sqlConnection);
 
221
            sqlCommand.CommandTimeout = 20;
 
222
 
 
223
            SqlDataReader sqlDataReader = sqlCommand.ExecuteReader();
 
224
            
 
225
            while (sqlDataReader.Read())
 
226
            {
 
227
                databases.Add(new Database(datasource) { Name = sqlDataReader["name"].ToString() });
 
228
            }
 
229
 
 
230
            sqlDataReader.Close();
 
231
 
 
232
            datasource.Databases = databases;
 
233
 
 
234
            if (sqlConnection != null && sqlConnection.State == ConnectionState.Open)
 
235
                sqlConnection.Close();
 
236
        }
 
237
 
 
238
        private void LoadColumns(SqlConnection sqlConnection, ITable table, TableType tableType)
 
239
        {
 
240
            string tableTypeName = "tables";
 
241
 
 
242
            if (tableType == TableType.View)
 
243
                tableTypeName = "views";
 
244
 
 
245
            using (SqlDataAdapter dataAdapter =
 
246
                new SqlDataAdapter(string.Format(_getColumnsScript, table.TableName, tableTypeName, table.SchemaName), sqlConnection))
 
247
            {
 
248
                DataTable dtColumns = new DataTable("Columns");
 
249
                dataAdapter.Fill(dtColumns);
 
250
 
 
251
                for (int j = 0; j < dtColumns.Rows.Count; j++)
 
252
                {
 
253
                    Column column = new Column(table);
 
254
                    column.ColumnId = (int)dtColumns.Rows[j]["ColumnId"];
 
255
                    column.Name = (string)dtColumns.Rows[j]["Name"];
 
256
                    column.DataType = (string)dtColumns.Rows[j]["DataType"];
 
257
                    column.SystemType = (string)dtColumns.Rows[j]["SystemType"];
 
258
                    column.Length = Convert.ToInt32(dtColumns.Rows[j]["Length"]);
 
259
 
 
260
                    if (column.Length == -1)
 
261
                    {
 
262
                        switch (column.DataType.ToLower())
 
263
                        {
 
264
                            case "varchar":
 
265
                            case "nvarchar":
 
266
                                column.DataType += "(max)";
 
267
                                break;
 
268
                            default:
 
269
                                break;
 
270
                        }
 
271
 
 
272
                        switch (column.SystemType.ToLower())
 
273
                        {
 
274
                            case "varchar":
 
275
                            case "nvarchar":
 
276
                                column.SystemType += "(max)";
 
277
                                break;
 
278
                            default:
 
279
                                break;
 
280
                        }
 
281
                    }
 
282
 
 
283
                    column.Precision = Convert.ToInt32(dtColumns.Rows[j]["NumericPrecision"]);
 
284
                    column.Scale = Convert.ToInt32(dtColumns.Rows[j]["Scale"]);                    
 
285
                    column.IsIdentity = (bool)dtColumns.Rows[j]["IsIdentity"];
 
286
                    column.IsNullable = (bool)dtColumns.Rows[j]["IsNullable"];
 
287
                    column.IsPrimaryKey = (bool)dtColumns.Rows[j]["IsPrimaryKey"];
 
288
 
 
289
                    table.Items.Add(column);
 
290
                }
 
291
            }
 
292
        }
 
293
 
 
294
        public override DatabaseObjectsCollection<ITable> LoadTables(IDatabase database)
 
295
        {
 
296
            DatabaseObjectsCollection<ITable> tables = new DatabaseObjectsCollection<ITable>(database);
 
297
 
 
298
            SqlConnection sqlConnection = new SqlConnection(database.ConnectionString);
 
299
 
 
300
            using (SqlDataAdapter da = new SqlDataAdapter(_getConstraintsScript, sqlConnection))
 
301
            {
 
302
                DataTable dtConstraints = new DataTable("Constraints");
 
303
                da.Fill(dtConstraints);
 
304
 
 
305
                for (int i = 0; i < dtConstraints.Rows.Count; i++)
 
306
                {
 
307
                    string constraintName = (string)dtConstraints.Rows[i]["ConstraintName"];
 
308
 
 
309
                    IConstraint constraint = database.Constraints.FirstOrDefault(c => c.Name == constraintName);
 
310
 
 
311
                    if (constraint == null)
 
312
                    {
 
313
                        constraint = new ICSharpCode.Data.Core.DatabaseObjects.Constraint();
 
314
                        constraint.Name = constraintName;
 
315
                        constraint.FKTableName = (string)dtConstraints.Rows[i]["FKTable"];
 
316
                        constraint.PKTableName = (string)dtConstraints.Rows[i]["PKTable"];
 
317
 
 
318
                        database.Constraints.Add(constraint);
 
319
                    }
 
320
 
 
321
                    constraint.FKColumnNames.Add((string)dtConstraints.Rows[i]["FKColumn"]);
 
322
                    constraint.PKColumnNames.Add((string)dtConstraints.Rows[i]["PKColumn"]);                
 
323
                }
 
324
            }
 
325
 
 
326
            using (SqlDataAdapter da = new SqlDataAdapter(_getTables, sqlConnection))
 
327
            {
 
328
                DataTable dtTables = new DataTable("Tables");
 
329
                da.Fill(dtTables);
 
330
 
 
331
                for (int i = 0; i < dtTables.Rows.Count; i++)
 
332
                {
 
333
                    string schemaName = (string)dtTables.Rows[i]["TABLE_SCHEMA"];
 
334
                    string tableName = (string)dtTables.Rows[i]["TABLE_NAME"];
 
335
 
 
336
                    Table table = new Table() { SchemaName = schemaName, TableName = tableName };
 
337
                    LoadColumns(sqlConnection, table, TableType.Table);
 
338
 
 
339
                    table.Constraints = database.Constraints.Where(constraint => constraint.FKTableName == tableName).ToDatabaseObjectsCollection(table);
 
340
                    tables.Add(table);
 
341
                }
 
342
            }
 
343
 
 
344
            return tables;
 
345
        }
 
346
 
 
347
        public override DatabaseObjectsCollection<IView> LoadViews(IDatabase database)
 
348
        {
 
349
            DatabaseObjectsCollection<IView> views = new DatabaseObjectsCollection<IView>(database);
 
350
 
 
351
            SqlConnection sqlConnection = new SqlConnection(database.ConnectionString);
 
352
 
 
353
            using (SqlDataAdapter da = new SqlDataAdapter(_getViews, sqlConnection))
 
354
            {
 
355
                DataTable dtViews = new DataTable("Views");
 
356
                da.Fill(dtViews);
 
357
 
 
358
                for (int i = 0; i < dtViews.Rows.Count; i++)
 
359
                {
 
360
                    string schemaName = (string)dtViews.Rows[i]["TABLE_SCHEMA"];
 
361
                    string viewName = (string)dtViews.Rows[i]["TABLE_NAME"];
 
362
 
 
363
                    View view = new View() { SchemaName = schemaName, TableName = viewName, Query = LoadViewQuery(sqlConnection, schemaName, viewName) };            
 
364
                    LoadColumns(sqlConnection, view, TableType.View);
 
365
                    views.Add(view);
 
366
                }
 
367
            }
 
368
 
 
369
            return views;
 
370
        }
 
371
 
 
372
        private string LoadViewQuery(SqlConnection sqlConnection, string schemaName, string tableName)
 
373
        {
 
374
            string definingQuery = string.Empty;
 
375
            
 
376
            using (SqlDataAdapter dataAdapter =
 
377
                new SqlDataAdapter(string.Format(_getViewDefiningQuery, schemaName + "." + tableName), sqlConnection))
 
378
            {
 
379
                DataTable dtQuery = new DataTable("Text");
 
380
                dataAdapter.Fill(dtQuery);
 
381
 
 
382
                for (int i = 0; i < dtQuery.Rows.Count; i++)
 
383
                {
 
384
                    definingQuery += (string)dtQuery.Rows[i]["Text"];
 
385
                }
 
386
            }
 
387
 
 
388
            return definingQuery;
 
389
        }
 
390
 
 
391
        public override DatabaseObjectsCollection<IProcedure> LoadProcedures(IDatabase database)
 
392
        {
 
393
            DatabaseObjectsCollection<IProcedure> procedures = new DatabaseObjectsCollection<IProcedure>(database);
 
394
 
 
395
            SqlConnection sqlConnection = new SqlConnection(database.ConnectionString);
 
396
 
 
397
            using (SqlDataAdapter da = new SqlDataAdapter(_getProcedures, sqlConnection))
 
398
            {
 
399
                DataTable dtProcedures = new DataTable("Procedures");
 
400
                da.Fill(dtProcedures);
 
401
 
 
402
                for (int i = 0; i < dtProcedures.Rows.Count; i++)
 
403
                {
 
404
                    Procedure procedure = new Procedure();
 
405
                    procedure.Name = (string)dtProcedures.Rows[i]["ROUTINE_NAME"];
 
406
                    procedure.SchemaName = (string)dtProcedures.Rows[i]["ROUTINE_SCHEMA"];
 
407
                    if (dtProcedures.Rows[i]["DATA_TYPE"] != DBNull.Value)
 
408
                        procedure.DataType = (string)dtProcedures.Rows[i]["DATA_TYPE"];
 
409
                    if (dtProcedures.Rows[i]["CHARACTER_MAXIMUM_LENGTH"] != DBNull.Value)
 
410
                        procedure.Length = Convert.ToInt32(dtProcedures.Rows[i]["CHARACTER_MAXIMUM_LENGTH"]);
 
411
 
 
412
                    if (procedure.Length == -1)
 
413
                    {
 
414
                        switch (procedure.DataType.ToLower())
 
415
                        {
 
416
                            case "varchar":
 
417
                            case "nvarchar":
 
418
                                procedure.DataType += "(max)";
 
419
                                break;
 
420
                            default:
 
421
                                break;
 
422
                        }
 
423
                    }
 
424
 
 
425
                    string procedureType = (string)dtProcedures.Rows[i]["ROUTINE_BODY"];
 
426
                    if (procedureType == "SQL")
 
427
                        procedure.ProcedureType = ProcedureType.SQL;
 
428
                    else
 
429
                        procedure.ProcedureType = ProcedureType.External;
 
430
 
 
431
 
 
432
                    procedure.Items = new DatabaseObjectsCollection<IProcedureParameter>(procedure);
 
433
 
 
434
                    DatabaseObjectsCollection<IProcedureParameter> procedureParameters =  new DatabaseObjectsCollection<IProcedureParameter>(procedure);
 
435
 
 
436
                    da.SelectCommand = new SqlCommand(string.Format(_getProcedureParameters, procedure.Name, procedure.SchemaName, database.Name), sqlConnection);
 
437
                    DataTable dtProcedureParameters = new DataTable("ProcedureParameters");
 
438
                    da.Fill(dtProcedureParameters);
 
439
 
 
440
                    for (int j = 0; j < dtProcedureParameters.Rows.Count; j++)
 
441
                    {
 
442
                        if (string.IsNullOrEmpty((string)dtProcedureParameters.Rows[j]["PARAMETER_NAME"]) && 
 
443
                            (string)dtProcedureParameters.Rows[j]["IS_RESULT"] == "YES") // = ReturnValue
 
444
                            continue;
 
445
                        
 
446
                        ProcedureParameter procedureParameter = new ProcedureParameter();
 
447
                        procedureParameter.Name = (string)dtProcedureParameters.Rows[j]["PARAMETER_NAME"];
 
448
                        if (procedureParameter.Name.StartsWith("@"))
 
449
                            procedureParameter.Name = procedureParameter.Name.Substring(1);
 
450
 
 
451
                        if (dtProcedureParameters.Rows[j]["DATA_TYPE"] != DBNull.Value)
 
452
                            procedureParameter.DataType = (string)dtProcedureParameters.Rows[j]["DATA_TYPE"];
 
453
 
 
454
                        if (dtProcedureParameters.Rows[j]["CHARACTER_MAXIMUM_LENGTH"] != DBNull.Value)
 
455
                            procedureParameter.Length = Convert.ToInt32(dtProcedureParameters.Rows[j]["CHARACTER_MAXIMUM_LENGTH"]);
 
456
 
 
457
                        string parameterMode = (string)dtProcedureParameters.Rows[j]["PARAMETER_MODE"];
 
458
                        if (parameterMode == "IN")
 
459
                            procedureParameter.ParameterMode = ParameterMode.In;
 
460
                        else if (parameterMode == "OUT")
 
461
                            procedureParameter.ParameterMode = ParameterMode.Out;
 
462
                        else
 
463
                            procedureParameter.ParameterMode = ParameterMode.InOut;
 
464
                        
 
465
                        procedure.Items.Add(procedureParameter);
 
466
                    }
 
467
 
 
468
                    procedures.Add(procedure);
 
469
                }
 
470
            }
 
471
 
 
472
            return procedures;
 
473
        }
 
474
    }
 
475
}