Beispiel #1
0
            /// <summary>
            /// parses <see cref="InsertQuery"/> having <paramref name="tableName"/> from
            /// <paramref name="rowDataXmlNode"/>.
            /// </summary>
            /// <param name="rowDataXmlNode"></param>
            /// <param name="tableName"></param>
            /// <returns>
            /// <see cref="InsertQuery"/> having <paramref name="tableName"/> parsed from
            /// <paramref name="rowDataXmlNode"/>
            /// </returns>
            /// <exception cref="InsertQueryParseException">
            /// thrown if <see cref="InsertQuery"/> parse failed
            /// </exception>
            public static InsertQuery Parse(XmlNode rowDataXmlNode, string tableName)
            {
                try
                {
                    // get ValuedColumns
                    XmlNodeList valuedColumnsXmlNodeList = rowDataXmlNode.GetNodes("column");

                    // number of specified columns might be zero (?)
                    ValuedColumn[] valuedColumns = new ValuedColumn[valuedColumnsXmlNodeList.Count];

                    for (int i = 0; i < valuedColumnsXmlNodeList.Count; i++)
                    {
                        XmlNode valuedColumnXmlNode = valuedColumnsXmlNodeList[0];
                        valuedColumns[i] = ValuedColumn.Parse(valuedColumnXmlNode);
                    }

                    InsertQuery insertQuery = new InsertQuery(tableName, valuedColumns);

                    return(insertQuery);
                }
                catch (XmlNodeMissingAttributeException xmlNodeMissingAttributeException)
                {
                    throw new InsertQueryParseException(xmlNodeMissingAttributeException);
                }
            }
Beispiel #2
0
            /// <summary>
            /// returns undo <see cref="Query"/> corresponding to query performed on
            /// <paramref name="auditedTableName"/>, where <paramref name="auditTableRow"/> contains
            /// the data required to undo a single row in <paramref name="auditedTableName"/>,
            /// which was affected by the query.
            /// </summary>
            /// <param name="auditTableRow"></param>
            /// <param name="auditedTableName"></param>
            /// <param name="queryTypeIdToQueryType"></param>
            /// <returns>
            /// undo <see cref="Query"/> corresponding to query performed on
            /// <paramref name="auditedTableName"/>, where <paramref name="auditTableRow"/> contains
            /// the data required to undo a single row in <paramref name="auditedTableName"/>,
            /// which was affected by the query
            /// </returns>
            /// <exception cref="UnsupportedAuditQueryTypeException">
            /// thrown if <see cref="Query.eQueryType"/> specified in <paramref name="auditTableRow"/>
            /// is not supported for audit
            /// </exception>
            private static WriteQuery getUndoQuery(
                ResultSet.Row auditTableRow,
                string auditedTableName,
                Dictionary <long, Query.eQueryType> queryTypeIdToQueryType)
            {
                WriteQuery undoQuery;

                // type of query that was originally performed on audited table
                long queryTypeId = auditTableRow.GetColumnValue <long>(
                    AuditTableStructure.QUERY_ID_COLUMN_INDEX);

                Query.eQueryType queryType = queryTypeIdToQueryType[queryTypeId];

                // value of _id column of modified row in audit table
                long auditedTableRowId = auditTableRow.GetColumnValue <long>(
                    AuditTableStructure.AUDITED_TABLE_ROW_ID_COLUMN_INDEX);

                // get undo query based on query type
                if (queryType == Query.eQueryType.Insert)
                {
                    undoQuery = new DeleteQuery(
                        auditedTableName,
                        new BasicCondition(
                            new ValuedTableColumn(
                                DatabaseStructure.ID_COLUMN_NAME,
                                auditedTableName,
                                auditedTableRowId),
                            BasicCondition.eOperatorType.Equal
                            )
                        );
                }
                else if (queryType == Query.eQueryType.Update || queryType == Query.eQueryType.Delete)
                {
                    // ValuedColumn of _id column of modified row in audited table
                    ArrayRange <ValuedColumn> auditedTableRowIdArrayRange =
                        new ArrayRange <ValuedColumn>(
                            new ValuedColumn(DatabaseStructure.ID_COLUMN_NAME, auditedTableRowId)
                            );

                    // ValueColumn of columns other than _id of modified row in audited table
                    ArrayRange <ValuedColumn> auditedTableRowValuesArrayRange =
                        new ArrayRange <ValuedColumn>(
                            ValuedColumn.Parse(auditTableRow.ColumnNames, auditTableRow.ColumnValues),
                            AuditTableStructure.AUDITED_TABLE_DATA_COLUMNS_START_INDEX);

                    // unified ValuedColumn list for undo query
                    List <ValuedColumn> queryValuedColumns
                        = ListUtils.ListFromArrayRanges(
                              auditedTableRowIdArrayRange,
                              auditedTableRowValuesArrayRange);

                    if (queryType == Query.eQueryType.Update)
                    {
                        undoQuery = new UpdateQuery(
                            auditedTableName,
                            queryValuedColumns,
                            new BasicCondition(
                                new ValuedTableColumn(
                                    DatabaseStructure.ID_COLUMN_NAME,
                                    auditedTableName,
                                    auditedTableRowId),
                                BasicCondition.eOperatorType.Equal
                                )
                            );
                    }
                    else // queryType == Query.eQueryType.Delete
                    {
                        undoQuery = new InsertQuery(auditedTableName, queryValuedColumns);
                    }
                }
                else
                {
                    throw new UnsupportedAuditQueryTypeException(queryType);
                }

                return(undoQuery);
            }