private DBSqlParserColumn FindConstraintColumn( string schemaName, string tableName, string columnName ) { // Searches the collection of parsed column information for the // specific column in the specific table, and returns the parsed // column information if it's found. If not found then it returns // null instead. DBSqlParserColumnCollection columns = Columns; int columnCount = columns.Count; for (int i = 0; i < columnCount; ++i) { DBSqlParserColumn column = columns[i]; if (CatalogMatch(column.SchemaName, schemaName) && CatalogMatch(column.TableName, tableName) && CatalogMatch(column.ColumnName, columnName)) { return(column); } } return(null); }
internal DBSqlParserTable FindTableForColumn( DBSqlParserColumn column ) { DBSqlParserTableCollection tables = Tables; int tableCount = tables.Count; for (int i = 0; i < tableCount; ++i) { DBSqlParserTable table = tables[i]; // if the table name matches the correlation name, then we're certain // of a match if (string.Empty == column.DatabaseName && string.Empty == column.SchemaName && CatalogMatch(column.TableName, table.CorrelationName)) { return(table); } // otherwise, compare each part of the name (if they exist) with the // table and pick the one that matches all the parts that exist. if ((string.Empty == column.DatabaseName || CatalogMatch(column.DatabaseName, table.DatabaseName)) && (string.Empty == column.SchemaName || CatalogMatch(column.SchemaName, table.SchemaName)) && (string.Empty == column.TableName || CatalogMatch(column.TableName, table.TableName))) { return(table); } } Debug.Assert(false, "Why didn't we find a match for the column?"); return(null); }
//---------------------------------------------------------------------- // this[] // internal DBSqlParserColumn this[int i] { get { DBSqlParserColumn value = (DBSqlParserColumn)InnerList[i]; return(value); } }
//////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////// // // Methods // //////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////// internal void CopySchemaInfoFrom(DBSqlParserColumn completedColumn) { _databaseName = completedColumn.DatabaseName; _schemaName = completedColumn.SchemaName; _tableName = completedColumn.TableName; _columnName = completedColumn.ColumnName; _isKey = completedColumn.IsKey; _isUnique = completedColumn.IsUnique; }
internal DBSqlParserColumn Add( string databaseName, string schemaName, string tableName, string columnName, string alias ) { DBSqlParserColumn p = new DBSqlParserColumn(databaseName, schemaName, tableName, columnName, alias); return(Add(p)); }
protected DBSqlParserColumn FindCompletedColumn( DBSqlParserTable table, DBSqlParserColumn searchColumn ) { DBSqlParserColumnCollection columns = table.Columns; int columnsCount = columns.Count; for (int i = 0; i < columnsCount; ++i) { DBSqlParserColumn column = columns[i]; // Compare each part of the name (if they exist) with the // table and pick the one that matches all the parts that exist. if (CatalogMatch(column.ColumnName, searchColumn.ColumnName)) { return(column); } } // MDAC 87152: ROWID and ROWNUM shouldn't fire an assert here: //Debug.Assert(false, "Why didn't we find a match for the search column?"); return(null); }
private void CompleteSchemaInformation() { DBSqlParserColumnCollection columns = Columns; DBSqlParserTableCollection tables = Tables; int columnCount = columns.Count; int tableCount = tables.Count; // First, derive all of the information we can about each table for (int i = 0; i < tableCount; i++) { DBSqlParserTable table = tables[i]; DBSqlParserColumnCollection tableColumns = GatherTableColumns(table); table.Columns = tableColumns; } // Next, derive all of the column information we can. for (int i = 0; i < columnCount; i++) { DBSqlParserColumn column = columns[i]; DBSqlParserTable table = FindTableForColumn(column); if (!column.IsExpression) { // If this is a '*' column, then we have to expand the '*' into // its component parts. if ("*" == column.ColumnName) { // Remove the existing "*" column entry and replace it with the // complete list of columns in the table. columns.RemoveAt(i); // If this is a tablename.* column, then add references to the // all columns in the specified table, otherwise add references // to all columns in all tables. if (String.Empty != column.TableName) { DBSqlParserColumnCollection tableColumns = table.Columns; int tableColumnCount = tableColumns.Count; for (int j = 0; j < tableColumnCount; ++j) { columns.Insert(i + j, tableColumns[j]); } columnCount += tableColumnCount - 1; // don't forget to adjust our loop end i += tableColumnCount - 1; } else { for (int k = 0; k < tableCount; k++) { table = tables[k]; DBSqlParserColumnCollection tableColumns = table.Columns; int tableColumnCount = tableColumns.Count; for (int j = 0; j < tableColumnCount; ++j) { columns.Insert(i + j, tableColumns[j]); } columnCount += tableColumnCount - 1; // don't forget to adjust our loop end i += tableColumnCount; } } } else { // if this isn't a '*' column, we find the table that the column belongs // to, and ask it's column collection for the completed column info (that // contains information about key values, etc.) DBSqlParserColumn completedColumn = FindCompletedColumn(table, column); if (null != completedColumn) // MDAC 87152 { column.CopySchemaInfoFrom(completedColumn); } else { column.CopySchemaInfoFrom(table); } } } } // Finally, derive the key column information for each table for (int i = 0; i < tableCount; i++) { DBSqlParserTable table = tables[i]; GatherKeyColumns(table); } }
protected override void GatherKeyColumns( DBSqlParserTable table ) { // Called after the table and column information is completed to // identify which columns in the select-list are key columns for // their table. OracleCommand cmd = null; OracleDataReader rdr = null; try { try { cmd = _connection.CreateCommand(); cmd.Transaction = _connection.Transaction; // must set the transaction context to be the same as the command, or we'll throw when we execute. string schemaName = CatalogCase(table.SchemaName); string tableName = CatalogCase(table.TableName); string synonymSchemaName = schemaName; string synonymTableName = tableName; // First, we have to "dereference" a synonym, if it was specified, because // synonyms don't have catalog items stored for them, they're for the table // or view that the synonym references. cmd.CommandText = GetSynonymQueryStatement(schemaName, tableName); rdr = cmd.ExecuteReader(); if (rdr.Read()) { synonymSchemaName = rdr.GetString(0); synonymTableName = rdr.GetString(1); } rdr.Dispose(); // Now we have the real schema name and table name, go and derive the key // columns cmd.CommandText = GetConstraintQueryStatement(synonymSchemaName, synonymTableName); rdr = cmd.ExecuteReader(); ArrayList constraintColumnNames = new ArrayList(); bool isUniqueConstraint; if (true == (_moreConstraints = rdr.Read())) { while (GetConstraint(rdr, out isUniqueConstraint, constraintColumnNames)) { bool foundAllColumns = true; int constraintColumnCount = constraintColumnNames.Count; DBSqlParserColumn[] constraintColumn = new DBSqlParserColumn[constraintColumnCount]; for (int j = 0; j < constraintColumnCount; ++j) { DBSqlParserColumn column = FindConstraintColumn( schemaName, tableName, (string)constraintColumnNames[j] ); if (null == column) { foundAllColumns = false; break; } constraintColumn[j] = column; } if (foundAllColumns) { for (int j = 0; j < constraintColumnCount; ++j) { constraintColumn[j].SetAsKey(isUniqueConstraint); } break; } } } } finally { if (null != cmd) { cmd.Dispose(); cmd = null; } if (null != rdr) { rdr.Dispose(); rdr = null; } } } catch { // Prevent exception filters from running in our space throw; } }
private void BuildSchemaTable() { Debug.Assert(null == _schemaTable, "BuildSchemaTable: schema table already exists"); Debug.Assert(null != _columnInfo, "BuildSchemaTable: no columnInfo"); int columnCount = FieldCount; OracleSqlParser parser; DBSqlParserColumnCollection parsedColumns = null; int parsedColumnsCount = 0; if (_keyInfoRequested) { parser = new OracleSqlParser(); parser.Parse(_statementText, _connection); parsedColumns = parser.Columns; parsedColumnsCount = parsedColumns.Count; } DataTable schemaTable = new DataTable("SchemaTable"); schemaTable.MinimumCapacity = columnCount; DataColumn name = new DataColumn("ColumnName", typeof(System.String)); DataColumn ordinal = new DataColumn("ColumnOrdinal", typeof(System.Int32)); DataColumn size = new DataColumn("ColumnSize", typeof(System.Int32)); DataColumn precision = new DataColumn("NumericPrecision", typeof(System.Int16)); DataColumn scale = new DataColumn("NumericScale", typeof(System.Int16)); DataColumn dataType = new DataColumn("DataType", typeof(System.Type)); DataColumn oracleType = new DataColumn("ProviderType", typeof(System.Int32)); DataColumn isLong = new DataColumn("IsLong", typeof(System.Boolean)); DataColumn isNullable = new DataColumn("AllowDBNull", typeof(System.Boolean)); DataColumn isAliased = new DataColumn("IsAliased", typeof(System.Boolean)); DataColumn isExpression = new DataColumn("IsExpression", typeof(System.Boolean)); DataColumn isKey = new DataColumn("IsKey", typeof(System.Boolean)); DataColumn isUnique = new DataColumn("IsUnique", typeof(System.Boolean)); DataColumn baseSchemaName = new DataColumn("BaseSchemaName", typeof(System.String)); DataColumn baseTableName = new DataColumn("BaseTableName", typeof(System.String)); DataColumn baseColumnName = new DataColumn("BaseColumnName", typeof(System.String)); ordinal.DefaultValue = 0; isLong.DefaultValue = false; DataColumnCollection columns = schemaTable.Columns; columns.Add(name); columns.Add(ordinal); columns.Add(size); columns.Add(precision); columns.Add(scale); columns.Add(dataType); columns.Add(oracleType); columns.Add(isLong); columns.Add(isNullable); columns.Add(isAliased); columns.Add(isExpression); columns.Add(isKey); columns.Add(isUnique); columns.Add(baseSchemaName); columns.Add(baseTableName); columns.Add(baseColumnName); for (int i = 0; i < columnCount; ++i) { OracleColumn column = _columnInfo[i]; DataRow newRow = schemaTable.NewRow(); newRow[name] = column.ColumnName; newRow[ordinal] = column.Ordinal; if (column.IsLong | column.IsLob) { newRow[size] = Int32.MaxValue; //MDAC 82554 } else { newRow[size] = column.Size; } newRow[precision] = column.Precision; newRow[scale] = column.Scale; newRow[dataType] = column.GetFieldType(); newRow[oracleType] = column.OracleType; newRow[isLong] = column.IsLong | column.IsLob; newRow[isNullable] = column.IsNullable; if (_keyInfoRequested && parsedColumnsCount == columnCount) { DBSqlParserColumn parsedColumn = parsedColumns[i]; newRow[isAliased] = parsedColumn.IsAliased; newRow[isExpression] = parsedColumn.IsExpression; newRow[isKey] = parsedColumn.IsKey; newRow[isUnique] = parsedColumn.IsUnique; newRow[baseSchemaName] = SetSchemaValue(OracleSqlParser.CatalogCase(parsedColumn.SchemaName)); newRow[baseTableName] = SetSchemaValue(OracleSqlParser.CatalogCase(parsedColumn.TableName)); newRow[baseColumnName] = SetSchemaValue(OracleSqlParser.CatalogCase(parsedColumn.ColumnName)); } else { newRow[isAliased] = DBNull.Value; // don't know newRow[isExpression] = DBNull.Value; // don't know newRow[isKey] = DBNull.Value; // don't know newRow[isUnique] = DBNull.Value; // don't know newRow[baseSchemaName] = DBNull.Value; // don't know newRow[baseTableName] = DBNull.Value; // don't know newRow[baseColumnName] = DBNull.Value; // don't know } schemaTable.Rows.Add(newRow); newRow.AcceptChanges(); } // mark all columns as readonly for (int i = 0; i < columns.Count; i++) { columns[i].ReadOnly = true; } // DataSet dataset = new DataSet(); // dataset.Tables.Add(schemaTable); // Debug.WriteLine(dataset.GetXml()); // dataset.Tables.Remove(schemaTable); _schemaTable = schemaTable; }
//---------------------------------------------------------------------- // Insert // internal void Insert(int index, DBSqlParserColumn value) { InnerList.Insert(index, value); }
//////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////// // // Methods // //////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////// //---------------------------------------------------------------------- // Add() // internal DBSqlParserColumn Add(DBSqlParserColumn value) { OnValidate(value); InnerList.Add(value); return(value); }