diff options
Diffstat (limited to 'Source/SPTableContent.m')
| -rw-r--r-- | Source/SPTableContent.m | 3413 |
1 files changed, 3413 insertions, 0 deletions
diff --git a/Source/SPTableContent.m b/Source/SPTableContent.m new file mode 100644 index 00000000..a040fb1c --- /dev/null +++ b/Source/SPTableContent.m @@ -0,0 +1,3413 @@ +// +// $Id$ +// +// TableDocument.h +// sequel-pro +// +// Created by lorenz textor (lorenz@textor.ch) on Wed May 01 2002. +// Copyright (c) 2002-2003 Lorenz Textor. All rights reserved. +// +// Forked by Abhi Beckert (abhibeckert.com) 2008-04-04 +// +// This program is free software; you can redistribute it and/or modify +// it under the terms of the GNU General Public License as published by +// the Free Software Foundation; either version 2 of the License, or +// (at your option) any later version. +// +// This program is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. +// +// You should have received a copy of the GNU General Public License +// along with this program; if not, write to the Free Software +// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA +// +// More info at <http://code.google.com/p/sequel-pro/> + +#import "SPTableContent.h" +#import "TableDocument.h" +#import "SPTableStructure.h" +#import "SPTableInfo.h" +#import "SPTablesList.h" +#import "SPImageView.h" +#import "CMCopyTable.h" +#import "SPDataCellFormatter.h" +#import "SPTableData.h" +#import "SPQueryController.h" +#import "SPStringAdditions.h" +#import "SPArrayAdditions.h" +#import "SPTextViewAdditions.h" +#import "SPDataAdditions.h" +#import "SPTextAndLinkCell.h" +#import "QLPreviewPanel.h" +#import "SPFieldEditorController.h" +#import "SPTooltip.h" +#import "RegexKitLite.h" +#import "SPContentFilterManager.h" +#import "SPNotLoaded.h" +#import "SPConstants.h" +#import "SPDataStorage.h" +#import "SPAlertSheets.h" +#import "SPMainThreadTrampoline.h" +#import "SPHistoryController.h" + +@implementation SPTableContent + +/** + * Standard init method. Initialize various ivars. + */ +- (id)init +{ + if ((self == [super init])) { + _mainNibLoaded = NO; + isWorking = NO; + pthread_mutex_init(&tableValuesLock, NULL); + nibObjectsToRelease = [[NSMutableArray alloc] init]; + + tableValues = [[SPDataStorage alloc] init]; + tableRowsCount = 0; + previousTableRowsCount = 0; + dataColumns = [[NSMutableArray alloc] init]; + oldRow = [[NSMutableArray alloc] init]; + + selectedTable = nil; + sortCol = nil; + isDesc = NO; + keys = nil; + + currentlyEditingRow = -1; + contentPage = 1; + + sortColumnToRestore = nil; + sortColumnToRestoreIsAsc = YES; + pageToRestore = 1; + selectionIndexToRestore = nil; + selectionViewportToRestore = NSZeroRect; + filterFieldToRestore = nil; + filterComparisonToRestore = nil; + filterValueToRestore = nil; + firstBetweenValueToRestore = nil; + secondBetweenValueToRestore = nil; + tableRowsSelectable = YES; + contentFilterManager = nil; + + isFiltered = NO; + isLimited = NO; + isInterruptedLoad = NO; + + prefs = [NSUserDefaults standardUserDefaults]; + + usedQuery = [[NSString alloc] initWithString:@""]; + + // Init default filters for Content Browser + contentFilters = nil; + contentFilters = [[NSMutableDictionary alloc] init]; + numberOfDefaultFilters = [[NSMutableDictionary alloc] init]; + + NSError *readError = nil; + NSString *convError = nil; + NSPropertyListFormat format; + NSData *defaultFilterData = [NSData dataWithContentsOfFile:[NSBundle pathForResource:@"ContentFilters.plist" ofType:nil inDirectory:[[NSBundle mainBundle] bundlePath]] + options:NSMappedRead error:&readError]; + + [contentFilters setDictionary:[NSPropertyListSerialization propertyListFromData:defaultFilterData + mutabilityOption:NSPropertyListMutableContainersAndLeaves format:&format errorDescription:&convError]]; + if(contentFilters == nil || readError != nil || convError != nil) { + NSLog(@"Error while reading 'ContentFilters.plist':\n%@\n%@", [readError localizedDescription], convError); + NSBeep(); + } else { + [numberOfDefaultFilters setObject:[NSNumber numberWithInteger:[[contentFilters objectForKey:@"number"] count]] forKey:@"number"]; + [numberOfDefaultFilters setObject:[NSNumber numberWithInteger:[[contentFilters objectForKey:@"date"] count]] forKey:@"date"]; + [numberOfDefaultFilters setObject:[NSNumber numberWithInteger:[[contentFilters objectForKey:@"string"] count]] forKey:@"string"]; + } + + + } + + return self; +} + +/** + * Initialise various interface controls + */ +- (void)awakeFromNib +{ + if (_mainNibLoaded) return; + _mainNibLoaded = YES; + + // Set the table content view's vertical gridlines if required + [tableContentView setGridStyleMask:([prefs boolForKey:SPDisplayTableViewVerticalGridlines]) ? NSTableViewSolidVerticalGridLineMask : NSTableViewGridNone]; + + // Load the pagination view, keeping references to the top-level objects for later release + NSArray *paginationViewTopLevelObjects = nil; + NSNib *nibLoader = [[NSNib alloc] initWithNibNamed:@"ContentPaginationView" bundle:[NSBundle mainBundle]]; + if (![nibLoader instantiateNibWithOwner:self topLevelObjects:&paginationViewTopLevelObjects]) { + NSLog(@"Content pagination nib could not be loaded; pagination will not function correctly."); + } else { + [nibObjectsToRelease addObjectsFromArray:paginationViewTopLevelObjects]; + } + [nibLoader release]; + + // Add the pagination view to the content area + NSRect paginationViewFrame = [paginationView frame]; + NSRect paginationButtonFrame = [paginationButton frame]; + paginationViewHeight = paginationViewFrame.size.height; + paginationViewFrame.origin.x = paginationButtonFrame.origin.x + paginationButtonFrame.size.width - paginationViewFrame.size.width; + paginationViewFrame.origin.y = paginationButtonFrame.origin.y + paginationButtonFrame.size.height - 2; + paginationViewFrame.size.height = 0; + [paginationView setFrame:paginationViewFrame]; + [contentViewPane addSubview:paginationView]; + + // Add observers for document task activity + [[NSNotificationCenter defaultCenter] addObserver:self + selector:@selector(startDocumentTaskForTab:) + name:SPDocumentTaskStartNotification + object:tableDocumentInstance]; + [[NSNotificationCenter defaultCenter] addObserver:self + selector:@selector(endDocumentTaskForTab:) + name:SPDocumentTaskEndNotification + object:tableDocumentInstance]; +} + +#pragma mark - +#pragma mark Table loading methods and information + +/* + * Loads aTable, retrieving column information and updating the tableViewColumns before + * reloading table data into the data array and redrawing the table. + */ +- (void)loadTable:(NSString *)aTable +{ + + // Abort the reload if the user is still editing a row + if ( isEditingRow ) + return; + + // If no table has been supplied, clear the table interface and return + if (!aTable || [aTable isEqualToString:@""]) { + [self performSelectorOnMainThread:@selector(setTableDetails:) withObject:nil waitUntilDone:YES]; + return; + } + + // Attempt to retrieve the table encoding; if that fails (indicating an error occurred + // while retrieving table data), or if the Rows variable is null, clear and return + if (![tableDataInstance tableEncoding] || [[[tableDataInstance statusValues] objectForKey:@"Rows"] isNSNull]) { + [self performSelectorOnMainThread:@selector(setTableDetails:) withObject:nil waitUntilDone:YES]; + return; + } + + // Post a notification that a query will be performed + [[NSNotificationCenter defaultCenter] postNotificationName:@"SMySQLQueryWillBePerformed" object:tableDocumentInstance]; + + // Set up the table details for the new table, and trigger an interface update + NSDictionary *tableDetails = [NSDictionary dictionaryWithObjectsAndKeys: + aTable, @"name", + [tableDataInstance columns], @"columns", + [tableDataInstance columnNames], @"columnNames", + [tableDataInstance getConstraints], @"constraints", + nil]; + [self performSelectorOnMainThread:@selector(setTableDetails:) withObject:tableDetails waitUntilDone:YES]; + + // Trigger a data refresh + [self loadTableValues]; + + // Restore the view origin if appropriate + if (!NSEqualRects(selectionViewportToRestore, NSZeroRect)) { + + // Scroll the viewport to the saved location + selectionViewportToRestore.size = [tableContentView visibleRect].size; + [tableContentView scrollRectToVisible:selectionViewportToRestore]; + } + + // Restore selection indexes if appropriate + if (selectionIndexToRestore) { + BOOL previousTableRowsSelectable = tableRowsSelectable; + tableRowsSelectable = YES; + [tableContentView selectRowIndexes:selectionIndexToRestore byExtendingSelection:NO]; + tableRowsSelectable = previousTableRowsSelectable; + } + + // Update display if necessary + [[tableContentView onMainThread] setNeedsDisplay:YES]; + + // Init copyTable with necessary information for copying selected rows as SQL INSERT + [tableContentView setTableInstance:self withTableData:tableValues withColumns:dataColumns withTableName:selectedTable withConnection:mySQLConnection]; + // Post the notification that the query is finished + [[NSNotificationCenter defaultCenter] postNotificationName:@"SMySQLQueryHasBeenPerformed" object:tableDocumentInstance]; + + // Clear any details to restore now that they have been restored + [self clearDetailsToRestore]; +} + +/** + * Update stored table details and update the interface to match the supplied + * table details. + * Should be called on the main thread. + */ +- (void) setTableDetails:(NSDictionary *)tableDetails +{ + NSString *newTableName; + NSInteger i; + NSNumber *colWidth, *sortColumnNumberToRestore = nil; + NSArray *columnNames; + NSDictionary *columnDefinition; + NSTableColumn *theCol; + BOOL enableInteraction = ![[tableDocumentInstance selectedToolbarItemIdentifier] isEqualToString:SPMainToolbarTableContent] || ![tableDocumentInstance isWorking]; + + if (!tableDetails) { + newTableName = nil; + } else { + newTableName = [tableDetails objectForKey:@"name"]; + } + + // Ensure the pagination view hides itself if visible, after a tiny delay for smoothness + [self performSelector:@selector(setPaginationViewVisibility:) withObject:nil afterDelay:0.1]; + + // Reset table key store for use in argumentForRow: + if (keys) [keys release], keys = nil; + + // Reset data column store + [dataColumns removeAllObjects]; + + // Check the supplied table name. If it matches the old one, a reload is being performed; + // reload the data in-place to maintain table state if possible. + if ([selectedTable isEqualToString:newTableName]) { + previousTableRowsCount = tableRowsCount; + + // Otherwise store the newly selected table name and reset the data + } else { + if (selectedTable) [selectedTable release], selectedTable = nil; + if (newTableName) selectedTable = [[NSString alloc] initWithString:newTableName]; + previousTableRowsCount = 0; + contentPage = 1; + [paginationPageField setStringValue:@"1"]; + + // Clear the selection + [tableContentView deselectAll:self]; + + // Restore the table content view to the top left + [tableContentView scrollRowToVisible:0]; + [tableContentView scrollColumnToVisible:0]; + } + + // If no table has been supplied, reset the view to a blank table and disabled elements. + if (!newTableName) { + // Remove existing columns from the table + while ([[tableContentView tableColumns] count]) { + [tableContentView removeTableColumn:NSArrayObjectAtIndex([tableContentView tableColumns], 0)]; + } + + // Empty the stored data arrays, including emptying the tableValues array + // by ressignment for thread safety. + previousTableRowsCount = 0; + [self clearTableValues]; + [tableContentView reloadData]; + isFiltered = NO; + isLimited = NO; + [countText setStringValue:@""]; + + // Reset sort column + if (sortCol) [sortCol release]; sortCol = nil; + isDesc = NO; + + // Empty and disable filter options + [fieldField setEnabled:NO]; + [fieldField removeAllItems]; + [fieldField addItemWithTitle:NSLocalizedString(@"field", @"popup menuitem for field (showing only if disabled)")]; + [compareField setEnabled:NO]; + [compareField removeAllItems]; + [compareField addItemWithTitle:NSLocalizedString(@"is", @"popup menuitem for field IS value")]; + [argumentField setHidden:NO]; + [argumentField setEnabled:NO]; + [firstBetweenField setEnabled:NO]; + [secondBetweenField setEnabled:NO]; + [firstBetweenField setStringValue:@""]; + [secondBetweenField setStringValue:@""]; + [argumentField setStringValue:@""]; + [filterButton setEnabled:NO]; + + // Hide BETWEEN operator controls + [firstBetweenField setHidden:YES]; + [secondBetweenField setHidden:YES]; + [betweenTextField setHidden:YES]; + + // Disable pagination + [paginationPreviousButton setEnabled:NO]; + [paginationButton setEnabled:NO]; + [paginationButton setTitle:@""]; + [paginationNextButton setEnabled:NO]; + + // Disable table action buttons + [addButton setEnabled:NO]; + [copyButton setEnabled:NO]; + [removeButton setEnabled:NO]; + + // Clear restoration settings + [self clearDetailsToRestore]; + + return; + } + + // Otherwise, prepare to set up the new table - the table data instance already has table details set. + + // Remove existing columns from the table + while ([[tableContentView tableColumns] count]) { + [tableContentView removeTableColumn:NSArrayObjectAtIndex([tableContentView tableColumns], 0)]; + } + + // Retrieve the field names and types for this table from the data cache. This is used when requesting all data as part + // of the fieldListForQuery method, and also to decide whether or not to preserve the current filter/sort settings. + [dataColumns addObjectsFromArray:[tableDetails objectForKey:@"columns"]]; + columnNames = [tableDetails objectForKey:@"columnNames"]; + + // Retrieve the constraints, and loop through them to add up to one foreign key to each column + NSArray *constraints = [tableDetails objectForKey:@"constraints"]; + + for (NSDictionary *constraint in constraints) + { + NSString *firstColumn = [[constraint objectForKey:@"columns"] objectAtIndex:0]; + NSString *firstRefColumn = [[[constraint objectForKey:@"ref_columns"] componentsSeparatedByString:@","] objectAtIndex:0]; + NSUInteger columnIndex = [columnNames indexOfObject:firstColumn]; + + if (columnIndex != NSNotFound && ![[dataColumns objectAtIndex:columnIndex] objectForKey:@"foreignkeyreference"]) { + NSDictionary *refDictionary = [NSDictionary dictionaryWithObjectsAndKeys: + [constraint objectForKey:@"ref_table"], @"table", + firstRefColumn, @"column", + nil]; + NSMutableDictionary *rowDictionary = [NSMutableDictionary dictionaryWithDictionary:[dataColumns objectAtIndex:columnIndex]]; + [rowDictionary setObject:refDictionary forKey:@"foreignkeyreference"]; + [dataColumns replaceObjectAtIndex:columnIndex withObject:rowDictionary]; + } + } + + NSString *nullValue = [prefs objectForKey:SPNullValue]; + NSFont *tableFont = [NSUnarchiver unarchiveObjectWithData:[prefs dataForKey:SPGlobalResultTableFont]]; + [tableContentView setRowHeight:2.0f+NSSizeToCGSize([[NSString stringWithString:@"{ǞṶḹÜ∑zgyf"] sizeWithAttributes:[NSDictionary dictionaryWithObject:tableFont forKey:NSFontAttributeName]]).height]; + + // Add the new columns to the table + for ( i = 0 ; i < [dataColumns count] ; i++ ) { + columnDefinition = NSArrayObjectAtIndex(dataColumns, i); + + // Set up the column + theCol = [[NSTableColumn alloc] initWithIdentifier:[columnDefinition objectForKey:@"datacolumnindex"]]; + [[theCol headerCell] setStringValue:[columnDefinition objectForKey:@"name"]]; + [theCol setEditable:YES]; + + // Set up the data cell depending on the column type + id dataCell; + if ([[columnDefinition objectForKey:@"typegrouping"] isEqualToString:@"enum"]) { + dataCell = [[[NSComboBoxCell alloc] initTextCell:@""] autorelease]; + [dataCell setButtonBordered:NO]; + [dataCell setBezeled:NO]; + [dataCell setDrawsBackground:NO]; + [dataCell setCompletes:YES]; + [dataCell setControlSize:NSSmallControlSize]; + // add prefs NULL value representation if NULL value is allowed for that field + if([[columnDefinition objectForKey:@"null"] boolValue]) + [dataCell addItemWithObjectValue:nullValue]; + [dataCell addItemsWithObjectValues:[columnDefinition objectForKey:@"values"]]; + + // Add a foreign key arrow if applicable + } else if ([columnDefinition objectForKey:@"foreignkeyreference"]) { + dataCell = [[[SPTextAndLinkCell alloc] initTextCell:@""] autorelease]; + [dataCell setTarget:self action:@selector(clickLinkArrow:)]; + + // Otherwise instantiate a text-only cell + } else { + dataCell = [[[SPTextAndLinkCell alloc] initTextCell:@""] autorelease]; + } + [dataCell setEditable:YES]; + + // Set the line break mode and an NSFormatter subclass which truncates long strings for display + [dataCell setLineBreakMode:NSLineBreakByTruncatingTail]; + [dataCell setFormatter:[[SPDataCellFormatter new] autorelease]]; + + // Set field length limit if field is a varchar to match varchar length + if ([[columnDefinition objectForKey:@"typegrouping"] isEqualToString:@"string"]) { + [[dataCell formatter] setTextLimit:[[columnDefinition objectForKey:@"length"] integerValue]]; + } + + // Set the data cell font according to the preferences + [dataCell setFont:tableFont]; + + // Assign the data cell + [theCol setDataCell:dataCell]; + + // Set the width of this column to saved value if exists + colWidth = [[[[prefs objectForKey:SPTableColumnWidths] objectForKey:[NSString stringWithFormat:@"%@@%@", [tableDocumentInstance database], [tableDocumentInstance host]]] objectForKey:[tablesListInstance tableName]] objectForKey:[columnDefinition objectForKey:@"name"]]; + if ( colWidth ) { + [theCol setWidth:[colWidth doubleValue]]; + } + + // Set the column to be reselected for sorting if appropriate + if (sortColumnToRestore && [sortColumnToRestore isEqualToString:[columnDefinition objectForKey:@"name"]]) + sortColumnNumberToRestore = [columnDefinition objectForKey:@"datacolumnindex"]; + + // Add the column to the table + [tableContentView addTableColumn:theCol]; + [theCol release]; + } + + // If the table has been reloaded and the previously selected sort column is still present, reselect it. + if (sortColumnNumberToRestore) { + theCol = [tableContentView tableColumnWithIdentifier:sortColumnNumberToRestore]; + if (sortCol) [sortCol release]; + sortCol = [sortColumnNumberToRestore copy]; + [tableContentView setHighlightedTableColumn:theCol]; + isDesc = !sortColumnToRestoreIsAsc; + if ( isDesc ) { + [tableContentView setIndicatorImage:[NSImage imageNamed:@"NSDescendingSortIndicator"] inTableColumn:theCol]; + } else { + [tableContentView setIndicatorImage:[NSImage imageNamed:@"NSAscendingSortIndicator"] inTableColumn:theCol]; + } + + // Otherwise, clear sorting + } else { + if (sortCol) { + [sortCol release]; + sortCol = nil; + } + isDesc = NO; + } + + // Store the current first responder so filter field doesn't steal focus + id currentFirstResponder = [[tableDocumentInstance parentWindow] firstResponder]; + + // Enable and initialize filter fields (with tags for position of menu item and field position) + [fieldField setEnabled:YES]; + [fieldField removeAllItems]; + [fieldField addItemsWithTitles:columnNames]; + for ( i = 0 ; i < [fieldField numberOfItems] ; i++ ) { + [[fieldField itemAtIndex:i] setTag:i]; + } + [compareField setEnabled:YES]; + [self setCompareTypes:self]; + [argumentField setEnabled:YES]; + [argumentField setStringValue:@""]; + [filterButton setEnabled:enableInteraction]; + + // Restore preserved filter settings if appropriate and valid + if (filterFieldToRestore) { + [fieldField selectItemWithTitle:filterFieldToRestore]; + [self setCompareTypes:self]; + + if ([fieldField itemWithTitle:filterFieldToRestore] + && ((!filterComparisonToRestore && filterValueToRestore) + || [compareField itemWithTitle:filterComparisonToRestore])) + { + if (filterComparisonToRestore) [compareField selectItemWithTitle:filterComparisonToRestore]; + if([filterComparisonToRestore isEqualToString:@"BETWEEN"]) { + [argumentField setHidden:YES]; + if (firstBetweenValueToRestore) [firstBetweenField setStringValue:firstBetweenValueToRestore]; + if (secondBetweenValueToRestore) [secondBetweenField setStringValue:secondBetweenValueToRestore]; + } else { + if (filterValueToRestore) [argumentField setStringValue:filterValueToRestore]; + } + [self toggleFilterField:self]; + + } + } + + // Restore page number if limiting is set + if ([prefs boolForKey:SPLimitResults]) contentPage = pageToRestore; + + // Restore first responder + [[tableDocumentInstance parentWindow] makeFirstResponder:currentFirstResponder]; + + // Set the state of the table buttons + [addButton setEnabled:enableInteraction]; + [copyButton setEnabled:NO]; + [removeButton setEnabled:NO]; + + // Reset the table store if required - basically if the table is being changed, + // reassigning before emptying for thread safety. + if (!previousTableRowsCount) { + [self clearTableValues]; + } + +} + +/** + * Remove all items from the current table value store. Do this by + * reassigning the tableValues store and releasing the old location, + * while setting thread safety flags. + */ +- (void) clearTableValues +{ + SPDataStorage *tableValuesTransition; + + tableValuesTransition = tableValues; + pthread_mutex_lock(&tableValuesLock); + tableRowsCount = 0; + tableValues = [[SPDataStorage alloc] init]; + [tableContentView setTableData:tableValues]; + pthread_mutex_unlock(&tableValuesLock); + [tableValuesTransition release]; +} + +/** + * Reload the table data without reconfiguring the tableView, + * using filters and limits as appropriate. + * Will not refresh the table view itself. + * Note that this does not empty the table array - see use of previousTableRowsCount. + */ +- (void) loadTableValues +{ + // If no table is selected, return + if (!selectedTable) return; + + NSMutableString *queryString; + NSString *queryStringBeforeLimit = nil; + NSString *filterString; + MCPStreamingResult *streamingResult; + NSInteger rowsToLoad = [[tableDataInstance statusValueForKey:@"Rows"] integerValue]; + + [countText setStringValue:NSLocalizedString(@"Loading table data...", @"Loading table data string")]; + + // Notify any listeners that a query has started + [[NSNotificationCenter defaultCenter] postNotificationName:@"SMySQLQueryWillBePerformed" object:tableDocumentInstance]; + + // Start construction of the query string + queryString = [NSMutableString stringWithFormat:@"SELECT %@ FROM %@", [self fieldListForQuery], [selectedTable backtickQuotedString]]; + + // Add a filter string if appropriate + filterString = [self tableFilterString]; + + if (filterString) { + [queryString appendFormat:@" WHERE %@", filterString]; + isFiltered = YES; + } else { + isFiltered = NO; + } + + // Add sorting details if appropriate + if (sortCol) { + [queryString appendFormat:@" ORDER BY %@", [[[dataColumns objectAtIndex:[sortCol integerValue]] objectForKey:@"name"] backtickQuotedString]]; + if (isDesc) [queryString appendString:@" DESC"]; + } + + // Check to see if a limit needs to be applied + if ([prefs boolForKey:SPLimitResults]) { + + // Ensure the page supplied is within the appropriate limits + if (contentPage <= 0) + contentPage = 1; + else if (contentPage > 1 && (contentPage - 1) * [prefs integerForKey:SPLimitResultsValue] >= maxNumRows) + contentPage = ceil((CGFloat)maxNumRows / [prefs floatForKey:SPLimitResultsValue]); + + // If the result set is from a late page, take a copy of the string to allow resetting limit + // if no results are found + if (contentPage > 1) { + queryStringBeforeLimit = [NSString stringWithString:queryString]; + } + + // Append the limit settings + [queryString appendFormat:@" LIMIT %ld,%ld", (long)((contentPage-1)*[prefs integerForKey:SPLimitResultsValue]), (long)[prefs integerForKey:SPLimitResultsValue]]; + + // Update the approximate count of the rows to load + rowsToLoad = rowsToLoad - (contentPage-1)*[prefs integerForKey:SPLimitResultsValue]; + if (rowsToLoad > [prefs integerForKey:SPLimitResultsValue]) rowsToLoad = [prefs integerForKey:SPLimitResultsValue]; + } + + // If within a task, allow this query to be cancelled + [tableDocumentInstance enableTaskCancellationWithTitle:NSLocalizedString(@"Stop", @"stop button") callbackObject:nil callbackFunction:NULL]; + + // Perform and process the query + [tableContentView performSelectorOnMainThread:@selector(noteNumberOfRowsChanged) withObject:nil waitUntilDone:YES]; + [self setUsedQuery:queryString]; + streamingResult = [[mySQLConnection streamingQueryString:queryString] retain]; + + // Ensure the number of columns are unchanged; if the column count has changed, abort the load + // and queue a full table reload. + BOOL fullTableReloadRequired = NO; + if (streamingResult && [dataColumns count] != [streamingResult numOfFields]) { + [tableDocumentInstance disableTaskCancellation]; + [mySQLConnection cancelCurrentQuery]; + [streamingResult cancelResultLoad]; + fullTableReloadRequired = YES; + } + + // Process the result into the data store + if (!fullTableReloadRequired && streamingResult) { + [self processResultIntoDataStorage:streamingResult approximateRowCount:rowsToLoad]; + } + if (streamingResult) [streamingResult release]; + + // If the result is empty, and a late page is selected, reset the page + if (!fullTableReloadRequired && [prefs boolForKey:SPLimitResults] && queryStringBeforeLimit && !tableRowsCount && ![mySQLConnection queryCancelled]) { + contentPage = 1; + queryString = [NSMutableString stringWithFormat:@"%@ LIMIT 0,%ld", queryStringBeforeLimit, (long)[prefs integerForKey:SPLimitResultsValue]]; + [self setUsedQuery:queryString]; + streamingResult = [[mySQLConnection streamingQueryString:queryString] retain]; + if (streamingResult) { + [self processResultIntoDataStorage:streamingResult approximateRowCount:[prefs integerForKey:SPLimitResultsValue]]; + [streamingResult release]; + } + } + + if ([mySQLConnection queryCancelled] || [mySQLConnection queryErrored]) + isInterruptedLoad = YES; + else + isInterruptedLoad = NO; + + // End cancellation ability + [tableDocumentInstance disableTaskCancellation]; + + if ([prefs boolForKey:SPLimitResults] + && (contentPage > 1 + || tableRowsCount == [prefs integerForKey:SPLimitResultsValue])) + { + isLimited = YES; + } else { + isLimited = NO; + } + + // Update the rows count as necessary + [self updateNumberOfRows]; + + // Set the filter text + [self updateCountText]; + + // Update pagination + [self updatePaginationState]; + + // Notify listenters that the query has finished + [[NSNotificationCenter defaultCenter] postNotificationName:@"SMySQLQueryHasBeenPerformed" object:tableDocumentInstance]; + + // Trigger a full reload if required + if (fullTableReloadRequired) [self reloadTable:self]; +} + +/* + * Processes a supplied streaming result set, loading it into the data array. + */ +- (void)processResultIntoDataStorage:(MCPStreamingResult *)theResult approximateRowCount:(NSUInteger)targetRowCount +{ + NSArray *tempRow; + NSUInteger i; + NSUInteger dataColumnsCount = [dataColumns count]; + BOOL *columnBlobStatuses = malloc(dataColumnsCount * sizeof(BOOL)); + + // Set the column count on the data store + [tableValues setColumnCount:dataColumnsCount]; + + CGFloat relativeTargetRowCount = 100.0/targetRowCount; + NSUInteger nextTableDisplayBoundary = 50; + BOOL tableViewRedrawn = NO; + + NSUInteger rowsProcessed = 0; + + NSAutoreleasePool *dataLoadingPool; + NSProgressIndicator *dataLoadingIndicator = [tableDocumentInstance valueForKey:@"queryProgressBar"]; + BOOL prefsLoadBlobsAsNeeded = [prefs boolForKey:SPLoadBlobsAsNeeded]; + + // Build up an array of which columns are blobs for faster iteration + for ( i = 0; i < dataColumnsCount ; i++ ) { + columnBlobStatuses[i] = [tableDataInstance columnIsBlobOrText:[NSArrayObjectAtIndex(dataColumns, i) objectForKey:@"name"]]; + } + + // Set up an autorelease pool for row processing + dataLoadingPool = [[NSAutoreleasePool alloc] init]; + + // Loop through the result rows as they become available + while (tempRow = [theResult fetchNextRowAsArray]) { + pthread_mutex_lock(&tableValuesLock); + + if (rowsProcessed < previousTableRowsCount) { + SPDataStorageReplaceRow(tableValues, rowsProcessed, tempRow); + } else { + SPDataStorageAddRow(tableValues, tempRow); + } + + // Alter the values for hidden blob and text fields if appropriate + if ( prefsLoadBlobsAsNeeded ) { + for ( i = 0 ; i < dataColumnsCount ; i++ ) { + if (columnBlobStatuses[i]) { + SPDataStorageReplaceObjectAtRowAndColumn(tableValues, rowsProcessed, i, [SPNotLoaded notLoaded]); + } + } + } + rowsProcessed++; + + pthread_mutex_unlock(&tableValuesLock); + + // Update the task interface as necessary + if (!isFiltered) { + if (rowsProcessed < targetRowCount) { + [tableDocumentInstance setTaskPercentage:(rowsProcessed*relativeTargetRowCount)]; + } else if (rowsProcessed == targetRowCount) { + [tableDocumentInstance setTaskPercentage:100.0]; + [[tableDocumentInstance onMainThread] setTaskProgressToIndeterminateAfterDelay:YES]; + } + } + + // Update the table view with new results every now and then + if (rowsProcessed > nextTableDisplayBoundary) { + if (rowsProcessed > tableRowsCount) tableRowsCount = rowsProcessed; + [[tableContentView onMainThread] noteNumberOfRowsChanged]; + if (!tableViewRedrawn) { + [[tableContentView onMainThread] setNeedsDisplay:YES]; + tableViewRedrawn = YES; + } + nextTableDisplayBoundary *= 2; + } + + // Drain and reset the autorelease pool every ~1024 rows + if (!(rowsProcessed % 1024)) { + [dataLoadingPool drain]; + dataLoadingPool = [[NSAutoreleasePool alloc] init]; + } + } + tableRowsCount = rowsProcessed; + + // If the reloaded table is shorter than the previous table, remove the extra values from the storage + if (tableRowsCount < [tableValues count]) { + pthread_mutex_lock(&tableValuesLock); + [tableValues removeRowsInRange:NSMakeRange(tableRowsCount, [tableValues count] - tableRowsCount)]; + pthread_mutex_unlock(&tableValuesLock); + } + + // Ensure the table is aware of changes + if ([NSThread isMainThread]) { + [tableContentView performSelectorOnMainThread:@selector(reloadData) withObject:nil waitUntilDone:YES]; + } else { + [tableContentView performSelectorOnMainThread:@selector(noteNumberOfRowsChanged) withObject:nil waitUntilDone:YES]; + [tableContentView performSelectorOnMainThread:@selector(reloadData) withObject:nil waitUntilDone:NO]; + } + + // Clean up the autorelease pool and reset the progress indicator + [dataLoadingPool drain]; + [dataLoadingIndicator setIndeterminate:YES]; + + free(columnBlobStatuses); +} + +/** + * Returns the query string for the current filter settings, + * ready to be dropped into a WHERE clause, or nil if no filtering + * is active. + */ +- (NSString *)tableFilterString +{ + + // If the clause has the placeholder $BINARY that placeholder will be replaced + // by BINARY if the user pressed ⇧ while invoking 'Filter' otherwise it will + // replaced by @"". + BOOL caseSensitive = (([[[NSApp onMainThread] currentEvent] modifierFlags] + & (NSShiftKeyMask|NSControlKeyMask|NSAlternateKeyMask|NSCommandKeyMask)) > 0); + + NSString *filterString; + + if(contentFilters == nil) { + NSLog(@"Fatal error while retrieving content filters. No filters found."); + NSBeep(); + return nil; + } + + // Current selected filter type + if(![contentFilters objectForKey:compareType]) { + NSLog(@"Error while retrieving filters. Filter type “%@” unknown.", compareType); + NSBeep(); + return nil; + } + NSDictionary *filter = [[contentFilters objectForKey:compareType] objectAtIndex:[[compareField selectedItem] tag]]; + + if(![filter objectForKey:@"Clause"] || ![filter objectForKey:@"NumberOfArguments"]) { + NSLog(@"Error while retrieving filter clause. No “Clause” or/and “NumberOfArguments” key found."); + NSBeep(); + return nil; + } + + NSUInteger numberOfArguments = [[filter objectForKey:@"NumberOfArguments"] integerValue]; + + BOOL suppressLeadingTablePlaceholder = NO; + if([filter objectForKey:@"SuppressLeadingFieldPlaceholder"]) + suppressLeadingTablePlaceholder = YES; + + // argument if Filter requires only one argument + NSMutableString *argument = [[NSMutableString alloc] initWithString:[argumentField stringValue]]; + + // If the filter field is empty and the selected filter does not require + // only one argument, then no filtering is required - return nil. + if (![argument length] && numberOfArguments == 1) { + [argument release]; + return nil; + } + + // arguments if Filter requires two arguments + NSMutableString *firstBetweenArgument = [[NSMutableString alloc] initWithString:[firstBetweenField stringValue]]; + NSMutableString *secondBetweenArgument = [[NSMutableString alloc] initWithString:[secondBetweenField stringValue]]; + + // If filter requires two arguments and either of the argument fields are empty + // return nil. + if (numberOfArguments == 2) { + if (([firstBetweenArgument length] == 0) || ([secondBetweenArgument length] == 0)) { + [argument release]; + [firstBetweenArgument release]; + [secondBetweenArgument release]; + return nil; + } + } + + // Retrieve actual WHERE clause + NSMutableString *clause = [[NSMutableString alloc] init]; + [clause setString:[filter objectForKey:@"Clause"]]; + + [clause replaceOccurrencesOfRegex:@"(?<!\\\\)\\$BINARY" withString:(caseSensitive) ? @"BINARY" : @""]; + [clause flushCachedRegexData]; + [clause replaceOccurrencesOfRegex:@"(?<!\\\\)\\$CURRENT_FIELD" withString:([fieldField titleOfSelectedItem]) ? [[fieldField titleOfSelectedItem] backtickQuotedString] : @""]; + [clause flushCachedRegexData]; + + // Escape % sign + [clause replaceOccurrencesOfRegex:@"%" withString:@"%%"]; + [clause flushCachedRegexData]; + + // Replace placeholder ${} by %@ + NSRange matchedRange; + NSString *re = @"(?<!\\\\)\\$\\{.*?\\}"; + if([clause isMatchedByRegex:re]) { + while([clause isMatchedByRegex:re]) { + matchedRange = [clause rangeOfRegex:re]; + [clause replaceCharactersInRange:matchedRange withString:@"%@"]; + [clause flushCachedRegexData]; + } + } + + // Check number of placeholders and given 'NumberOfArguments' + if([clause replaceOccurrencesOfString:@"%@" withString:@"%@" options:NSLiteralSearch range:NSMakeRange(0, [clause length])] != numberOfArguments) { + NSLog(@"Error while setting filter string. “NumberOfArguments” differs from the number of arguments specified in “Clause”."); + NSBeep(); + [argument release]; + [firstBetweenArgument release]; + [secondBetweenArgument release]; + [clause release]; + return nil; + } + + // Construct the filter string according the required number of arguments + + if(suppressLeadingTablePlaceholder) { + if (numberOfArguments == 2) { + filterString = [NSString stringWithFormat:clause, + [self escapeFilterArgument:firstBetweenArgument againstClause:clause], + [self escapeFilterArgument:secondBetweenArgument againstClause:clause]]; + } else if (numberOfArguments == 1) { + filterString = [NSString stringWithFormat:clause, [self escapeFilterArgument:argument againstClause:clause]]; + } else { + filterString = [NSString stringWithString:clause]; + if(numberOfArguments > 2) { + NSLog(@"Filter with more than 2 arguments is not yet supported."); + NSBeep(); + } + } + } else { + if (numberOfArguments == 2) { + filterString = [NSString stringWithFormat:@"%@ %@", + [[fieldField titleOfSelectedItem] backtickQuotedString], + [NSString stringWithFormat:clause, + [self escapeFilterArgument:firstBetweenArgument againstClause:clause], + [self escapeFilterArgument:secondBetweenArgument againstClause:clause]]]; + } else if (numberOfArguments == 1) { + filterString = [NSString stringWithFormat:@"%@ %@", + [[fieldField titleOfSelectedItem] backtickQuotedString], + [NSString stringWithFormat:clause, [self escapeFilterArgument:argument againstClause:clause]]]; + } else { + filterString = [NSString stringWithFormat:@"%@ %@", + [[fieldField titleOfSelectedItem] backtickQuotedString], clause]; + if(numberOfArguments > 2) { + NSLog(@"Filter with more than 2 arguments is not yet supported."); + NSBeep(); + } + } + } + + [argument release]; + [firstBetweenArgument release]; + [secondBetweenArgument release]; + [clause release]; + + // Return the filter string + return filterString; +} + +- (NSString *)escapeFilterArgument:(NSString *)argument againstClause:(NSString *)clause +{ + + NSMutableString *arg = [[NSMutableString alloc] init]; + [arg setString:argument]; + + [arg replaceOccurrencesOfRegex:@"(\\\\)(?![nrt_%])" withString:@"\\\\\\\\\\\\\\\\"]; + [arg flushCachedRegexData]; + [arg replaceOccurrencesOfRegex:@"(\\\\)(?=[nrt])" withString:@"\\\\\\"]; + [arg flushCachedRegexData]; + + // Get quote sign for escaping - this should work for 99% of all cases + NSString *quoteSign = [clause stringByMatching:@"([\"'])[^\\1]*?%@[^\\1]*?\\1" capture:1L]; + // Esape argument + if(quoteSign != nil && [quoteSign length] == 1) { + [arg replaceOccurrencesOfRegex:[NSString stringWithFormat:@"(%@)", quoteSign] withString:@"\\\\$1"]; + [arg flushCachedRegexData]; + } + // if([clause isMatchedByRegex:@"(?i)\\blike\\b.*?%(?!@)"]) { + // [arg replaceOccurrencesOfRegex:@"([_%])" withString:@"\\\\$1"]; + // [arg flushCachedRegexData]; + // } + return [arg autorelease]; +} + +/* + * Update the table count/selection text + */ +- (void)updateCountText +{ + NSString *rowString; + NSMutableString *countString = [NSMutableString string]; + NSNumberFormatter *numberFormatter = [[[NSNumberFormatter alloc] init] autorelease]; + [numberFormatter setNumberStyle:NSNumberFormatterDecimalStyle]; + + // Set up a couple of common strings + NSString *tableCountString = [numberFormatter stringFromNumber:[NSNumber numberWithUnsignedInteger:tableRowsCount]]; + NSString *maxRowsString = [numberFormatter stringFromNumber:[NSNumber numberWithUnsignedInteger:maxNumRows]]; + + // If the result is partial due to an error or query cancellation, show a very basic count + if (isInterruptedLoad) { + if (tableRowsCount == 1) + [countString appendFormat:NSLocalizedString(@"%@ row in partial load", @"text showing a single row a partially loaded result"), tableCountString]; + else + [countString appendFormat:NSLocalizedString(@"%@ rows in partial load", @"text showing how many rows are in a partially loaded result"), tableCountString]; + + // If no filter or limit is active, show just the count of rows in the table + } else if (!isFiltered && !isLimited) { + if (tableRowsCount == 1) + [countString appendFormat:NSLocalizedString(@"%@ row in table", @"text showing a single row in the result"), tableCountString]; + else + [countString appendFormat:NSLocalizedString(@"%@ rows in table", @"text showing how many rows are in the result"), tableCountString]; + + // If a limit is active, display a string suggesting a limit is active + } else if (!isFiltered && isLimited) { + NSUInteger limitStart = (contentPage-1)*[prefs integerForKey:SPLimitResultsValue] + 1; + [countString appendFormat:NSLocalizedString(@"Rows %@ - %@ of %@%@ from table", @"text showing how many rows are in the limited result"), [numberFormatter stringFromNumber:[NSNumber numberWithUnsignedInteger:limitStart]], [numberFormatter stringFromNumber:[NSNumber numberWithUnsignedInteger:(limitStart+tableRowsCount-1)]], maxNumRowsIsEstimate?@"~":@"", maxRowsString]; + + // If just a filter is active, show a count and an indication a filter is active + } else if (isFiltered && !isLimited) { + if (tableRowsCount == 1) + [countString appendFormat:NSLocalizedString(@"%@ row of %@%@ matches filter", @"text showing how a single rows matched filter"), tableCountString, maxNumRowsIsEstimate?@"~":@"", maxRowsString]; + else + [countString appendFormat:NSLocalizedString(@"%@ rows of %@%@ match filter", @"text showing how many rows matched filter"), tableCountString, maxNumRowsIsEstimate?@"~":@"", maxRowsString]; + + // If both a filter and limit is active, display full string + } else { + NSUInteger limitStart = (contentPage-1)*[prefs integerForKey:SPLimitResultsValue] + 1; + [countString appendFormat:NSLocalizedString(@"Rows %@ - %@ from filtered matches", @"text showing how many rows are in the limited filter match"), [numberFormatter stringFromNumber:[NSNumber numberWithUnsignedInteger:limitStart]], [numberFormatter stringFromNumber:[NSNumber numberWithUnsignedInteger:(limitStart+tableRowsCount-1)]]]; + } + + // If rows are selected, append selection count + if ([tableContentView numberOfSelectedRows] > 0) { + [countString appendString:@"; "]; + if ([tableContentView numberOfSelectedRows] == 1) + rowString = [NSString stringWithString:NSLocalizedString(@"row", @"singular word for row")]; + else + rowString = [NSString stringWithString:NSLocalizedString(@"rows", @"plural word for rows")]; + [countString appendFormat:NSLocalizedString(@"%@ %@ selected", @"text showing how many rows are selected"), [numberFormatter stringFromNumber:[NSNumber numberWithInteger:[tableContentView numberOfSelectedRows]]], rowString]; + } + + [[countText onMainThread] setStringValue:countString]; +} + +#pragma mark - +#pragma mark Table interface actions + +/* + * Reloads the current table data, performing a new SQL query. Now attempts to preserve sort + * order, filters, and viewport. Performs the action in a new thread if a task is not already + * running. + */ +- (IBAction)reloadTable:(id)sender +{ + [tableDocumentInstance startTaskWithDescription:NSLocalizedString(@"Reloading data...", @"Reloading data task description")]; + + if ([NSThread isMainThread]) { + [NSThread detachNewThreadSelector:@selector(reloadTableTask) toTarget:self withObject:nil]; + } else { + [self reloadTableTask]; + } +} + +- (void)reloadTableTask +{ + NSAutoreleasePool *reloadPool = [[NSAutoreleasePool alloc] init]; + + // Check whether a save of the current row is required. + if (![[self onMainThread] saveRowOnDeselect]) return; + + // Save view details to restore safely if possible (except viewport, which will be + // preserved automatically, and can then be scrolled as the table loads) + [self storeCurrentDetailsForRestoration]; + [self setViewportToRestore:NSZeroRect]; + + // Clear the table data column cache + [tableDataInstance resetColumnData]; + + // Load the table's data + [self loadTable:[tablesListInstance tableName]]; + + [tableDocumentInstance endTask]; + + [reloadPool drain]; +} + +/* + * Filter the table with arguments given by the user. + * Performs the action in a new thread if necessary. + */ +- (IBAction)filterTable:(id)sender +{ + NSString *taskString; + + if ([tableDocumentInstance isWorking]) return; + [self setPaginationViewVisibility:FALSE]; + + // Select the correct pagination value + if (![prefs boolForKey:SPLimitResults] || [paginationPageField integerValue] <= 0) + contentPage = 1; + else if (([paginationPageField integerValue] - 1) * [prefs integerForKey:SPLimitResultsValue] >= maxNumRows) + contentPage = ceil((CGFloat)maxNumRows / [prefs floatForKey:SPLimitResultsValue]); + else + contentPage = [paginationPageField integerValue]; + + if ([self tableFilterString]) { + taskString = NSLocalizedString(@"Filtering table...", @"Filtering table task description"); + } else if (contentPage == 1) { + taskString = [NSString stringWithFormat:NSLocalizedString(@"Loading %@...", @"Loading table task string"), selectedTable]; + } else { + taskString = [NSString stringWithFormat:NSLocalizedString(@"Loading page %lu...", @"Loading table page task string"), (unsigned long)contentPage]; + } + + [tableDocumentInstance startTaskWithDescription:taskString]; + + if ([NSThread isMainThread]) { + [NSThread detachNewThreadSelector:@selector(filterTableTask) toTarget:self withObject:nil]; + } else { + [self filterTableTask]; + } +} +- (void)filterTableTask +{ + NSAutoreleasePool *filterPool = [[NSAutoreleasePool alloc] init]; + + // Check whether a save of the current row is required. + if (![[self onMainThread] saveRowOnDeselect]) return; + + // Update history + [spHistoryControllerInstance updateHistoryEntries]; + + // Reset and reload data using the new filter settings + previousTableRowsCount = 0; + [self clearTableValues]; + [self loadTableValues]; + [[tableContentView onMainThread] scrollPoint:NSMakePoint(0.0, 0.0)]; + + [tableDocumentInstance endTask]; + [filterPool drain]; +} + +/** + * Enables or disables the filter input field based on the selected filter type. + */ +- (IBAction)toggleFilterField:(id)sender +{ + + // Check if user called "Edit Filter…" + if([[compareField selectedItem] tag] == [[contentFilters objectForKey:compareType] count]) { + [self openContentFilterManager]; + return; + } + + // Remember last selection for "Edit filter…" + lastSelectedContentFilterIndex = [[compareField selectedItem] tag]; + + NSDictionary *filter = [[contentFilters objectForKey:compareType] objectAtIndex:lastSelectedContentFilterIndex]; + NSUInteger numOfArgs = [[filter objectForKey:@"NumberOfArguments"] integerValue]; + if (numOfArgs == 2) { + [argumentField setHidden:YES]; + + if([filter objectForKey:@"ConjunctionLabels"] && [[filter objectForKey:@"ConjunctionLabels"] count] == 1) + [betweenTextField setStringValue:[[filter objectForKey:@"ConjunctionLabels"] objectAtIndex:0]]; + else + [betweenTextField setStringValue:@""]; + + [betweenTextField setHidden:NO]; + [firstBetweenField setHidden:NO]; + [secondBetweenField setHidden:NO]; + + [firstBetweenField setEnabled:YES]; + [secondBetweenField setEnabled:YES]; + [firstBetweenField selectText:self]; + } + else if (numOfArgs == 1){ + [argumentField setHidden:NO]; + [argumentField setEnabled:YES]; + [argumentField selectText:self]; + + [betweenTextField setHidden:YES]; + [firstBetweenField setHidden:YES]; + [secondBetweenField setHidden:YES]; + } + else { + [argumentField setHidden:NO]; + [argumentField setEnabled:NO]; + + [betweenTextField setHidden:YES]; + [firstBetweenField setHidden:YES]; + [secondBetweenField setHidden:YES]; + + // Start search if no argument is required + if(numOfArgs == 0) + [self filterTable:self]; + } + +} + +- (NSString *)usedQuery +{ + return usedQuery; +} + +- (void)setUsedQuery:(NSString *)query +{ + if (usedQuery) [usedQuery release]; + usedQuery = [[NSString alloc] initWithString:query]; +} + +#pragma mark - +#pragma mark Pagination + +/** + * Move the pagination backwards or forwards one page + */ +- (IBAction) navigatePaginationFromButton:(id)sender +{ + if (sender == paginationPreviousButton) { + if (contentPage <= 1) return; + [paginationPageField setIntegerValue:(contentPage - 1)]; + [self filterTable:sender]; + } else if (sender == paginationNextButton) { + if (contentPage * [prefs integerForKey:SPLimitResultsValue] >= maxNumRows) return; + [paginationPageField setIntegerValue:(contentPage + 1)]; + [self filterTable:sender]; + } +} + +/** + * When the Pagination button is pressed, show or hide the pagination + * layer depending on the current state. + */ +- (IBAction) togglePagination:(id)sender +{ + if ([sender state] == NSOnState) [self setPaginationViewVisibility:YES]; + else [self setPaginationViewVisibility:NO]; +} + +/** + * Show or hide the pagination layer, also changing the first responder as appropriate. + */ +- (void) setPaginationViewVisibility:(BOOL)makeVisible +{ + NSRect paginationViewFrame = [paginationView frame]; + + if (makeVisible) { + if (paginationViewFrame.size.height == paginationViewHeight) return; + paginationViewFrame.size.height = paginationViewHeight; + [paginationButton setState:NSOnState]; + [paginationButton setImage:[NSImage imageNamed:@"button_action"]]; + [[tableDocumentInstance parentWindow] makeFirstResponder:paginationPageField]; + } else { + if (paginationViewFrame.size.height == 0) return; + paginationViewFrame.size.height = 0; + [paginationButton setState:NSOffState]; + [paginationButton setImage:[NSImage imageNamed:@"button_pagination"]]; + if ([[tableDocumentInstance parentWindow] firstResponder] == paginationPageField + || ([[[tableDocumentInstance parentWindow] firstResponder] respondsToSelector:@selector(superview)] + && [(id)[[tableDocumentInstance parentWindow] firstResponder] superview] + && [[(id)[[tableDocumentInstance parentWindow] firstResponder] superview] respondsToSelector:@selector(superview)] + && [[(id)[[tableDocumentInstance parentWindow] firstResponder] superview] superview] == paginationPageField)) + { + [[tableDocumentInstance parentWindow] makeFirstResponder:nil]; + } + } + + [[paginationView animator] setFrame:paginationViewFrame]; +} + +/** + * Update the state of the pagination buttons and text. + */ +- (void) updatePaginationState +{ + NSUInteger maxPage = ceil((CGFloat)maxNumRows / [prefs floatForKey:SPLimitResultsValue]); + if (isFiltered && !isLimited) { + maxPage = contentPage; + } + BOOL enabledMode = ![tableDocumentInstance isWorking]; + + NSNumberFormatter *numberFormatter = [[[NSNumberFormatter alloc] init] autorelease]; + [numberFormatter setNumberStyle:NSNumberFormatterDecimalStyle]; + + // Set up the previous page button + if ([prefs boolForKey:SPLimitResults] && contentPage > 1) + [paginationPreviousButton setEnabled:enabledMode]; + else + [paginationPreviousButton setEnabled:NO]; + + // Set up the next page button + if ([prefs boolForKey:SPLimitResults] && contentPage < maxPage) + [paginationNextButton setEnabled:enabledMode]; + else + [paginationNextButton setEnabled:NO]; + + // As long as a table is selected (which it will be if this is called), enable pagination detail button + [paginationButton setEnabled:enabledMode]; + + // Set the values and maximums for the text field and associated pager + [paginationPageField setStringValue:[numberFormatter stringFromNumber:[NSNumber numberWithUnsignedInteger:contentPage]]]; + [[paginationPageField formatter] setMaximum:[NSNumber numberWithUnsignedInteger:maxPage]]; + [paginationPageStepper setIntegerValue:contentPage]; + [paginationPageStepper setMaxValue:maxPage]; +} + +#pragma mark - +#pragma mark Edit methods + +/* + * Adds an empty row to the table-array and goes into edit mode + */ +- (IBAction)addRow:(id)sender +{ + NSMutableDictionary *column; + NSMutableArray *newRow = [NSMutableArray array]; + NSUInteger i; + + // Check whether a save of the current row is required. + if ( ![self saveRowOnDeselect] ) return; + + for ( i = 0 ; i < [dataColumns count] ; i++ ) { + column = NSArrayObjectAtIndex(dataColumns, i); + if ([column objectForKey:@"default"] == nil || [column objectForKey:@"default"] == [NSNull null]) { + [newRow addObject:[NSNull null]]; + } else { + [newRow addObject:[column objectForKey:@"default"]]; + } + } + [tableValues addRowWithContents:newRow]; + tableRowsCount++; + + [tableContentView reloadData]; + [tableContentView selectRowIndexes:[NSIndexSet indexSetWithIndex:[tableContentView numberOfRows]-1] byExtendingSelection:NO]; + [tableContentView scrollRowToVisible:[tableContentView selectedRow]]; + isEditingRow = YES; + isEditingNewRow = YES; + currentlyEditingRow = [tableContentView selectedRow]; + if ( [multipleLineEditingButton state] == NSOffState ) + [tableContentView editColumn:0 row:[tableContentView numberOfRows]-1 withEvent:nil select:YES]; +} + +/** + * Copies a row of the table-array and goes into edit mode + */ +- (IBAction)copyRow:(id)sender +{ + NSMutableArray *tempRow; + MCPResult *queryResult; + NSDictionary *row; + NSArray *dbDataRow = nil; + NSUInteger i; + + // Check whether a save of the current row is required. + if ( ![self saveRowOnDeselect] ) return; + + if ( [tableContentView numberOfSelectedRows] < 1 ) + return; + if ( [tableContentView numberOfSelectedRows] > 1 ) { + SPBeginAlertSheet(NSLocalizedString(@"Error", @"error"), NSLocalizedString(@"OK", @"OK button"), nil, nil, [tableDocumentInstance parentWindow], self, nil, nil, NSLocalizedString(@"You can only copy single rows.", @"message of panel when trying to copy multiple rows")); + return; + } + + //copy row + tempRow = [tableValues rowContentsAtIndex:[tableContentView selectedRow]]; + + //if we don't show blobs, read data for this duplicate column from db + if ([prefs boolForKey:SPLoadBlobsAsNeeded]) { + // Abort if there are no indices on this table - argumentForRow will display an error. + if (![[self argumentForRow:[tableContentView selectedRow]] length]){ + return; + } + //if we have indexes, use argumentForRow + queryResult = [mySQLConnection queryString:[NSString stringWithFormat:@"SELECT * FROM %@ WHERE %@", [selectedTable backtickQuotedString], [self argumentForRow:[tableContentView selectedRow]]]]; + dbDataRow = [queryResult fetchRowAsArray]; + } + + //set autoincrement fields to NULL + queryResult = [mySQLConnection queryString:[NSString stringWithFormat:@"SHOW COLUMNS FROM %@", [selectedTable backtickQuotedString]]]; + [queryResult setReturnDataAsStrings:YES]; + if ([queryResult numOfRows]) [queryResult dataSeek:0]; + for ( i = 0 ; i < [queryResult numOfRows] ; i++ ) { + row = [queryResult fetchRowAsDictionary]; + if ( [[row objectForKey:@"Extra"] isEqualToString:@"auto_increment"] ) { + [tempRow replaceObjectAtIndex:i withObject:[NSNull null]]; + } else if ( [tableDataInstance columnIsBlobOrText:[row objectForKey:@"Field"]] && [prefs boolForKey:SPLoadBlobsAsNeeded] && dbDataRow) { + [tempRow replaceObjectAtIndex:i withObject:[dbDataRow objectAtIndex:i]]; + } + } + + //insert the copied row + [tableValues insertRowContents:tempRow atIndex:[tableContentView selectedRow]+1]; + tableRowsCount++; + + //select row and go in edit mode + [tableContentView reloadData]; + [tableContentView selectRowIndexes:[NSIndexSet indexSetWithIndex:[tableContentView selectedRow]+1] byExtendingSelection:NO]; + isEditingRow = YES; + isEditingNewRow = YES; + currentlyEditingRow = [tableContentView selectedRow]; + if ( [multipleLineEditingButton state] == NSOffState ) + [tableContentView editColumn:0 row:[tableContentView selectedRow] withEvent:nil select:YES]; +} + +/** + * Asks the user if they really want to delete the selected rows + */ +- (IBAction)removeRow:(id)sender +{ + // Check whether a save of the current row is required. + // if (![self saveRowOnDeselect]) + // return; + + // cancel editing (maybe this is not the ideal method -- see xcode docs for that method) + [[tableDocumentInstance parentWindow] endEditingFor:nil]; + + + if (![tableContentView numberOfSelectedRows]) + return; + + NSAlert *alert = [NSAlert alertWithMessageText:@"" + defaultButton:NSLocalizedString(@"Delete", @"delete button") + alternateButton:NSLocalizedString(@"Cancel", @"cancel button") + otherButton:nil + informativeTextWithFormat:@""]; + + [alert setAlertStyle:NSCriticalAlertStyle]; + + NSArray *buttons = [alert buttons]; + + // Change the alert's cancel button to have the key equivalent of return + [[buttons objectAtIndex:0] setKeyEquivalent:@"d"]; + [[buttons objectAtIndex:0] setKeyEquivalentModifierMask:NSCommandKeyMask]; + [[buttons objectAtIndex:1] setKeyEquivalent:@"\r"]; + + [alert setShowsSuppressionButton:NO]; + [[alert suppressionButton] setState:NSOffState]; + + NSString *contextInfo = @"removerow"; + + if (([tableContentView numberOfSelectedRows] == [tableContentView numberOfRows]) && !isFiltered && !isLimited && !isInterruptedLoad && !isEditingNewRow) { + + contextInfo = @"removeallrows"; + + // If table has PRIMARY KEY ask for resetting the auto increment after deletion if given + if(![[tableDataInstance statusValueForKey:@"Auto_increment"] isKindOfClass:[NSNull class]]) { + [alert setShowsSuppressionButton:YES]; + [[alert suppressionButton] setState:NSOnState]; + [[[alert suppressionButton] cell] setControlSize:NSSmallControlSize]; + [[[alert suppressionButton] cell] setFont:[NSFont systemFontOfSize:11]]; + [[alert suppressionButton] setTitle:NSLocalizedString(@"Reset AUTO_INCREMENT after deletion?", @"reset auto_increment after deletion of all rows message")]; + } + + [alert setMessageText:NSLocalizedString(@"Delete all rows?", @"delete all rows message")]; + [alert setInformativeText:NSLocalizedString(@"Are you sure you want to delete all the rows from this table? This action cannot be undone.", @"delete all rows informative message")]; + } + else if ([tableContentView numberOfSelectedRows] == 1) { + [alert setMessageText:NSLocalizedString(@"Delete selected row?", @"delete selected row message")]; + [alert setInformativeText:NSLocalizedString(@"Are you sure you want to delete the selected row from this table? This action cannot be undone.", @"delete selected row informative message")]; + } + else { + [alert setMessageText:NSLocalizedString(@"Delete rows?", @"delete rows message")]; + [alert setInformativeText:[NSString stringWithFormat:NSLocalizedString(@"Are you sure you want to delete the selected %ld rows from this table? This action cannot be undone.", @"delete rows informative message"), (long)[tableContentView numberOfSelectedRows]]]; + } + + [alert beginSheetModalForWindow:[tableDocumentInstance parentWindow] modalDelegate:self didEndSelector:@selector(removeRowSheetDidEnd:returnCode:contextInfo:) contextInfo:contextInfo]; +} + +/** + * Perform the requested row deletion action. + */ +- (void)removeRowSheetDidEnd:(NSAlert *)alert returnCode:(NSInteger)returnCode contextInfo:(void *)contextInfo +{ + + NSMutableIndexSet *selectedRows = [NSMutableIndexSet indexSet]; + NSString *wherePart; + NSInteger i, errors; + BOOL consoleUpdateStatus; + BOOL reloadAfterRemovingRow = [prefs boolForKey:SPReloadAfterRemovingRow]; + + // Order out current sheet to suppress overlapping of sheets + [[alert window] orderOut:nil]; + + if ( [contextInfo isEqualToString:@"removeallrows"] ) { + if ( returnCode == NSAlertDefaultReturn ) { + //check if the user is currently editing a row + if (isEditingRow) { + //cancel the edit + isEditingRow = NO; + // in case the delete fails, make sure we at least stay in a somewhat consistent state + [tableValues replaceRowAtIndex:currentlyEditingRow withRowContents:oldRow]; + currentlyEditingRow = -1; + } + + [mySQLConnection queryString:[NSString stringWithFormat:@"DELETE FROM %@", [selectedTable backtickQuotedString]]]; + if ( ![mySQLConnection queryErrored] ) { + + // Reset auto increment if suppression button was ticked + if([[alert suppressionButton] state] == NSOnState) + [tableSourceInstance setAutoIncrementTo:@"1"]; + + [self reloadTable:self]; + + } else { + [self performSelector:@selector(showErrorSheetWith:) + withObject:[NSArray arrayWithObjects:NSLocalizedString(@"Error", @"error"), + [NSString stringWithFormat:NSLocalizedString(@"Couldn't delete rows.\n\nMySQL said: %@", @"message when deleteing all rows failed"), + [mySQLConnection getLastErrorMessage]], + nil] + afterDelay:0.3]; + } + } + } else if ( [contextInfo isEqualToString:@"removerow"] ) { + if ( returnCode == NSAlertDefaultReturn ) { + [selectedRows addIndexes:[tableContentView selectedRowIndexes]]; + + //check if the user is currently editing a row + if (isEditingRow) { + //make sure that only one row is selected. This should never happen + if ([selectedRows count]!=1) { + NSLog(@"Expected only one selected row, but found %d",[selectedRows count]); + } + // this code is pretty much taken from the escape key handler + if ( isEditingNewRow ) { + // since the user is currently editing a new row, we don't actually have to delete any rows from the database + // we just have to remove the row from the view (and the store) + isEditingRow = NO; + isEditingNewRow = NO; + tableRowsCount--; + [tableValues removeRowAtIndex:currentlyEditingRow]; + currentlyEditingRow = -1; + [self updateCountText]; + [tableContentView reloadData]; + + //deselect the row + [tableContentView selectRowIndexes:[NSIndexSet indexSet] byExtendingSelection:NO]; + + // we also don't have to reload the table, since no query went to the database + return; + } else { + //cancel the edit + isEditingRow = NO; + // in case the delete fails, make sure we at least stay in a somewhat consistent state + [tableValues replaceRowAtIndex:currentlyEditingRow withRowContents:oldRow]; + currentlyEditingRow = -1; + } + + } + [tableContentView selectRowIndexes:[NSIndexSet indexSet] byExtendingSelection:NO]; + + errors = 0; + + // Disable updating of the Console Log window for large number of queries + // to speed the deletion + consoleUpdateStatus = [[SPQueryController sharedQueryController] allowConsoleUpdate]; + if([selectedRows count] > 10) + [[SPQueryController sharedQueryController] setAllowConsoleUpdate:NO]; + + NSUInteger index = [selectedRows firstIndex]; + + NSArray *primaryKeyFieldNames = [tableDataInstance primaryKeyColumnNames]; + + // If no PRIMARY KEY is found and numberOfSelectedRows > 3 then + // check for uniqueness of rows via combining all column values; + // if unique then use the all columns as 'primary keys' + if([selectedRows count] >3 && primaryKeyFieldNames == nil) { + primaryKeyFieldNames = [tableDataInstance columnNames]; + + NSInteger numberOfRows = 0; + // Get the number of rows in the table + MCPResult *r; + r = [mySQLConnection queryString:[NSString stringWithFormat:@"SELECT COUNT(1) FROM %@", [selectedTable backtickQuotedString]]]; + if (![mySQLConnection queryErrored]) { + NSArray *a = [r fetchRowAsArray]; + if([a count]) + numberOfRows = [[a objectAtIndex:0] integerValue]; + } + // Check for uniqueness via LIMIT numberOfRows-1,numberOfRows for speed + if(numberOfRows > 0) { + [mySQLConnection queryString:[NSString stringWithFormat:@"SELECT * FROM %@ GROUP BY %@ LIMIT %ld,%ld", [selectedTable backtickQuotedString], [primaryKeyFieldNames componentsJoinedAndBacktickQuoted], (long)(numberOfRows-1), (long)numberOfRows]]; + if([mySQLConnection affectedRows] == 0) + primaryKeyFieldNames = nil; + } else { + primaryKeyFieldNames = nil; + } + } + + if(primaryKeyFieldNames == nil) { + // delete row by row + while (index != NSNotFound) { + + wherePart = [NSString stringWithString:[self argumentForRow:index]]; + + //argumentForRow might return empty query, in which case we shouldn't execute the partial query + if([wherePart length]) { + [mySQLConnection queryString:[NSString stringWithFormat:@"DELETE FROM %@ WHERE %@", [selectedTable backtickQuotedString], wherePart]]; + + // Check for errors + if ( ![mySQLConnection affectedRows] || [mySQLConnection queryErrored]) { + // If error delete that index from selectedRows for reloading table if + // "ReloadAfterRemovingRow" is disbaled + if(!reloadAfterRemovingRow) + [selectedRows removeIndex:index]; + errors++; + } + } else { + if(!reloadAfterRemovingRow) + [selectedRows removeIndex:index]; + errors++; + } + index = [selectedRows indexGreaterThanIndex:index]; + } + } else if ([primaryKeyFieldNames count] == 1) { + // if table has only one PRIMARY KEY + // delete the fast way by using the PRIMARY KEY in an IN clause + NSMutableString *deleteQuery = [NSMutableString string]; + NSInteger affectedRows = 0; + + [deleteQuery setString:[NSString stringWithFormat:@"DELETE FROM %@ WHERE %@ IN (", [selectedTable backtickQuotedString], [NSArrayObjectAtIndex(primaryKeyFieldNames,0) backtickQuotedString]]]; + + while (index != NSNotFound) { + + id keyValue = [tableValues cellDataAtRow:index column:[[[tableDataInstance columnWithName:NSArrayObjectAtIndex(primaryKeyFieldNames,0)] objectForKey:@"datacolumnindex"] integerValue]]; + + if([keyValue isKindOfClass:[NSData class]]) + [deleteQuery appendString:[NSString stringWithFormat:@"X'%@'", [mySQLConnection prepareBinaryData:keyValue]]]; + else + [deleteQuery appendString:[NSString stringWithFormat:@"'%@'", [keyValue description]]]; + + // Split deletion query into 256k chunks + if([deleteQuery length] > 256000) { + [deleteQuery appendString:@")"]; + [mySQLConnection queryString:deleteQuery]; + // Remember affected rows for error checking + affectedRows += [mySQLConnection affectedRows]; + // Reinit a new deletion query + [deleteQuery setString:[NSString stringWithFormat:@"DELETE FROM %@ WHERE %@ IN (", [selectedTable backtickQuotedString], [NSArrayObjectAtIndex(primaryKeyFieldNames,0) backtickQuotedString]]]; + } else { + [deleteQuery appendString:@","]; + } + + index = [selectedRows indexGreaterThanIndex:index]; + } + + // Check if deleteQuery's maximal length was reached for the last index + // if yes omit the empty query + if(![deleteQuery hasSuffix:@"("]) { + // Replace final , by ) and delete the remaining rows + [deleteQuery setString:[NSString stringWithFormat:@"%@)", [deleteQuery substringToIndex:([deleteQuery length]-1)]]]; + [mySQLConnection queryString:deleteQuery]; + // Remember affected rows for error checking + affectedRows += [mySQLConnection affectedRows]; + } + + errors = (affectedRows > 0) ? [selectedRows count] - affectedRows : [selectedRows count]; + } else { + // if table has more than one PRIMARY KEY + // delete the row by using all PRIMARY KEYs in an OR clause + NSMutableString *deleteQuery = [NSMutableString string]; + NSInteger affectedRows = 0; + + [deleteQuery setString:[NSString stringWithFormat:@"DELETE FROM %@ WHERE ", [selectedTable backtickQuotedString]]]; + + while (index != NSNotFound) { + + // Build the AND clause of PRIMARY KEYS + [deleteQuery appendString:@"("]; + for(NSString *primaryKeyFieldName in primaryKeyFieldNames) { + + id keyValue = [tableValues cellDataAtRow:index column:[[[tableDataInstance columnWithName:primaryKeyFieldName] objectForKey:@"datacolumnindex"] integerValue]]; + + [deleteQuery appendString:[primaryKeyFieldName backtickQuotedString]]; + if ([keyValue isKindOfClass:[NSData class]]) { + [deleteQuery appendString:@"=X'"]; + [deleteQuery appendString:[mySQLConnection prepareBinaryData:keyValue]]; + } else { + [deleteQuery appendString:@"='"]; + [deleteQuery appendString:[mySQLConnection prepareString:[keyValue description]]]; + } + [deleteQuery appendString:@"' AND "]; + } + + // Remove the trailing AND and add the closing bracket + [deleteQuery deleteCharactersInRange:NSMakeRange([deleteQuery length]-5, 5)]; + [deleteQuery appendString:@")"]; + + // Split deletion query into 64k chunks + if([deleteQuery length] > 64000) { + [mySQLConnection queryString:deleteQuery]; + // Remember affected rows for error checking + affectedRows += [mySQLConnection affectedRows]; + // Reinit a new deletion query + [deleteQuery setString:[NSString stringWithFormat:@"DELETE FROM %@ WHERE ", [selectedTable backtickQuotedString]]]; + } else { + [deleteQuery appendString:@" OR "]; + } + + index = [selectedRows indexGreaterThanIndex:index]; + } + + // Check if deleteQuery's maximal length was reached for the last index + // if yes omit the empty query + if(![deleteQuery hasSuffix:@"WHERE "]) { + // Remove final ' OR ' and delete the remaining rows + [deleteQuery setString:[deleteQuery substringToIndex:([deleteQuery length]-4)]]; + [mySQLConnection queryString:deleteQuery]; + // Remember affected rows for error checking + affectedRows += [mySQLConnection affectedRows]; + } + + errors = (affectedRows > 0) ? [selectedRows count] - affectedRows : [selectedRows count]; + } + + // Restore Console Log window's updating bahaviour + [[SPQueryController sharedQueryController] setAllowConsoleUpdate:consoleUpdateStatus]; + + if (errors) { + NSArray *message; + //TODO: The following three messages are NOT localisable! + if (errors < 0) { + message = [NSArray arrayWithObjects:NSLocalizedString(@"Warning", @"warning"), + [NSString stringWithFormat:NSLocalizedString(@"%ld row%@ more %@ deleted! Please check the Console and inform the Sequel Pro team!", @"message of panel when more rows were deleted"), (long)(errors*-1), ((errors*-1)>1)?@"s":@"", (errors>1)?@"were":@"was"], + nil]; + } + else { + if (primaryKeyFieldNames == nil) + message = [NSArray arrayWithObjects:NSLocalizedString(@"Warning", @"warning"), + [NSString stringWithFormat:NSLocalizedString(@"%ld row%@ ha%@ not been deleted. Reload the table to be sure that the rows exist and use a primary key for your table.", @"message of panel when not all selected fields have been deleted"), (long)errors, (errors>1)?@"s":@"", (errors>1)?@"ve":@"s"], + nil]; + else + message = [NSArray arrayWithObjects:NSLocalizedString(@"Warning", @"warning"), + [NSString stringWithFormat:NSLocalizedString(@"%ld row%@ ha%@ not been deleted. Reload the table to be sure that the rows exist and check the Console for possible errors inside the primary key%@ for your table.", @"message of panel when not all selected fields have been deleted by using primary keys"), (long)errors, (errors>1)?@"s":@"", (errors>1)?@"ve":@"s", (errors>1)?@"s":@""], + nil]; + } + + [self performSelector:@selector(showErrorSheetWith:) + withObject:message + afterDelay:0.3]; + } + + // Refresh table content + if ( errors || reloadAfterRemovingRow ) { + previousTableRowsCount = tableRowsCount; + [self loadTableValues]; + } else { + for ( i = tableRowsCount - 1 ; i >= 0 ; i-- ) { + if ([selectedRows containsIndex:i]) [tableValues removeRowAtIndex:i]; + } + tableRowsCount = [tableValues count]; + [tableContentView reloadData]; + } + [tableContentView deselectAll:self]; + } else { + // The user clicked cancel in the "sure you wanna delete" message + // restore editing or whatever + } + + } +} + + +// Accessors + +/** + * Returns the current result (as shown in table content view) as array, the first object containing the field + * names as array, the following objects containing the rows as array. + */ +- (NSArray *)currentDataResult +{ + NSArray *tableColumns; + NSEnumerator *enumerator; + id tableColumn; + NSMutableArray *currentResult = [NSMutableArray array]; + NSMutableArray *tempRow = [NSMutableArray array]; + NSUInteger i; + + //load table if not already done + if ( ![tablesListInstance contentLoaded] ) { + [self loadTable:[tablesListInstance tableName]]; + } + + tableColumns = [tableContentView tableColumns]; + enumerator = [tableColumns objectEnumerator]; + + //set field names as first line + while ( (tableColumn = [enumerator nextObject]) ) { + [tempRow addObject:[[tableColumn headerCell] stringValue]]; + } + [currentResult addObject:[NSArray arrayWithArray:tempRow]]; + + //add rows + for ( i = 0 ; i < [self numberOfRowsInTableView:nil] ; i++) { + [tempRow removeAllObjects]; + enumerator = [tableColumns objectEnumerator]; + while ( (tableColumn = [enumerator nextObject]) ) { + id o = SPDataStorageObjectAtRowAndColumn(tableValues, i, [[tableColumn identifier] integerValue]); + if([o isNSNull]) + [tempRow addObject:@"NULL"]; + else if ([o isSPNotLoaded]) + [tempRow addObject:NSLocalizedString(@"(not loaded)", @"value shown for hidden blob and text fields")]; + else if([o isKindOfClass:[NSString class]]) + [tempRow addObject:[o description]]; + else { + NSImage *image = [[NSImage alloc] initWithData:o]; + if(image) { + NSInteger imageWidth = [image size].width; + if (imageWidth > 100) imageWidth = 100; + [tempRow addObject:[NSString stringWithFormat: + @"<IMG WIDTH='%ld' SRC=\"data:image/auto;base64,%@\">", + (long)imageWidth, + [[image TIFFRepresentationUsingCompression:NSTIFFCompressionJPEG factor:0.01] base64EncodingWithLineLength:0]]]; + } else { + [tempRow addObject:@"<BLOB>"]; + } + if(image) [image release]; + } + } + [currentResult addObject:[NSArray arrayWithArray:tempRow]]; + } + return currentResult; +} + +/** + * Returns the current result (as shown in table content view) as array, the first object containing the field + * names as array, the following objects containing the rows as array. + */ +- (NSArray *)currentResult +{ + NSArray *tableColumns; + NSEnumerator *enumerator; + id tableColumn; + NSMutableArray *currentResult = [NSMutableArray array]; + NSMutableArray *tempRow = [NSMutableArray array]; + NSUInteger i; + + //load table if not already done + if ( ![tablesListInstance contentLoaded] ) { + [self loadTable:[tablesListInstance tableName]]; + } + + tableColumns = [tableContentView tableColumns]; + enumerator = [tableColumns objectEnumerator]; + + //set field names as first line + while ( (tableColumn = [enumerator nextObject]) ) { + [tempRow addObject:[[tableColumn headerCell] stringValue]]; + } + [currentResult addObject:[NSArray arrayWithArray:tempRow]]; + + //add rows + for ( i = 0 ; i < [self numberOfRowsInTableView:nil] ; i++) { + [tempRow removeAllObjects]; + enumerator = [tableColumns objectEnumerator]; + while ( (tableColumn = [enumerator nextObject]) ) { + [tempRow addObject:[self tableView:nil objectValueForTableColumn:tableColumn row:i]]; + } + [currentResult addObject:[NSArray arrayWithArray:tempRow]]; + } + return currentResult; +} + +// Additional methods + +/** + * Sets the connection (received from TableDocument) and makes things that have to be done only once + */ +- (void)setConnection:(MCPConnection *)theConnection +{ + mySQLConnection = theConnection; + + [tableContentView setVerticalMotionCanBeginDrag:NO]; +} + +/** + * Performs the requested action - switching to another table + * with the appropriate filter settings - when a link arrow is + * selected. + */ +- (void)clickLinkArrow:(SPTextAndLinkCell *)theArrowCell +{ + if ([tableDocumentInstance isWorking]) return; + + if ([theArrowCell getClickedColumn] == NSNotFound || [theArrowCell getClickedRow] == NSNotFound) return; + + // Check whether a save of the current row is required. + if ( ![self saveRowOnDeselect] ) return; + + // If on the main thread, fire up a thread to perform the load while keeping the modification flag + [tableDocumentInstance startTaskWithDescription:NSLocalizedString(@"Loading reference...", @"Loading referece task string")]; + if ([NSThread isMainThread]) { + [NSThread detachNewThreadSelector:@selector(clickLinkArrowTask:) toTarget:self withObject:theArrowCell]; + } else { + [self clickLinkArrowTask:theArrowCell]; + } +} +- (void)clickLinkArrowTask:(SPTextAndLinkCell *)theArrowCell +{ + NSAutoreleasePool *linkPool = [[NSAutoreleasePool alloc] init]; + NSUInteger dataColumnIndex = [[[[tableContentView tableColumns] objectAtIndex:[theArrowCell getClickedColumn]] identifier] integerValue]; + BOOL tableFilterRequired = NO; + + // Ensure the clicked cell has foreign key details available + NSDictionary *refDictionary = [[dataColumns objectAtIndex:dataColumnIndex] objectForKey:@"foreignkeyreference"]; + if (!refDictionary) { + [linkPool release]; + return; + } + + // Save existing scroll position and details and mark that state is being modified + [spHistoryControllerInstance updateHistoryEntries]; + [spHistoryControllerInstance setModifyingState:YES]; + + NSString *targetFilterValue = [tableValues cellDataAtRow:[theArrowCell getClickedRow] column:dataColumnIndex]; + + // If the link is within the current table, apply filter settings manually + if ([[refDictionary objectForKey:@"table"] isEqualToString:selectedTable]) { + [fieldField selectItemWithTitle:[refDictionary objectForKey:@"column"]]; + [self setCompareTypes:self]; + if ([targetFilterValue isNSNull]) { + [compareField selectItemWithTitle:@"IS NULL"]; + } else { + [argumentField setStringValue:targetFilterValue]; + } + tableFilterRequired = YES; + } else { + + // Store the filter details to use when loading the target table + NSDictionary *filterSettings = [NSDictionary dictionaryWithObjectsAndKeys: + [refDictionary objectForKey:@"column"], @"filterField", + targetFilterValue, @"filterValue", + ([targetFilterValue isNSNull]?@"IS NULL":nil), @"filterComparison", + nil]; + [self setFiltersToRestore:filterSettings]; + + // Attempt to switch to the target table + if (![tablesListInstance selectItemWithName:[refDictionary objectForKey:@"table"]]) { + NSBeep(); + [self setFiltersToRestore:nil]; + } + } + + // End state and ensure a new history entry + [spHistoryControllerInstance setModifyingState:NO]; + [spHistoryControllerInstance updateHistoryEntries]; + + // End the task + [tableDocumentInstance endTask]; + + // If the same table is the target, trigger a filter task on the main thread + if (tableFilterRequired) + [self performSelectorOnMainThread:@selector(filterTable:) withObject:self waitUntilDone:NO]; + + // Empty the loading pool and exit the thread + [linkPool drain]; +} + +/** + * Sets the compare types for the filter and the appropriate formatter for the textField + */ +- (IBAction)setCompareTypes:(id)sender +{ + + if(contentFilters == nil + || ![contentFilters objectForKey:@"number"] + || ![contentFilters objectForKey:@"string"] + || ![contentFilters objectForKey:@"date"]) { + NSLog(@"Error while setting filter types."); + NSBeep(); + return; + } + + + [compareField removeAllItems]; + + NSString *fieldTypeGrouping; + if([[tableDataInstance columnWithName:[[fieldField selectedItem] title]] objectForKey:@"typegrouping"]) + fieldTypeGrouping = [NSString stringWithString:[[tableDataInstance columnWithName:[[fieldField selectedItem] title]] objectForKey:@"typegrouping"]]; + else + return; + + if ( [fieldTypeGrouping isEqualToString:@"date"] ) { + compareType = @"date"; + + /* + if ([fieldType isEqualToString:@"timestamp"]) { + [argumentField setFormatter:[[NSDateFormatter alloc] + initWithDateFormat:@"%Y-%m-%d %H:%M:%S" allowNaturalLanguage:YES]]; + } + if ([fieldType isEqualToString:@"datetime"]) { + [argumentField setFormatter:[[NSDateFormatter alloc] initWithDateFormat:@"%Y-%m-%d %H:%M:%S" allowNaturalLanguage:YES]]; + } + if ([fieldType isEqualToString:@"date"]) { + [argumentField setFormatter:[[NSDateFormatter alloc] initWithDateFormat:@"%Y-%m-%d" allowNaturalLanguage:YES]]; + } + if ([fieldType isEqualToString:@"time"]) { + [argumentField setFormatter:[[NSDateFormatter alloc] initWithDateFormat:@"%H:%M:%S" allowNaturalLanguage:YES]]; + } + if ([fieldType isEqualToString:@"year"]) { + [argumentField setFormatter:[[NSDateFormatter alloc] initWithDateFormat:@"%Y" allowNaturalLanguage:YES]]; + } + */ + + // TODO: A bug in the framework previously meant enum fields had to be treated as string fields for the purposes + // of comparison - this can now be split out to support additional comparison fucntionality if desired. + } else if ([fieldTypeGrouping isEqualToString:@"string"] || [fieldTypeGrouping isEqualToString:@"binary"] + || [fieldTypeGrouping isEqualToString:@"textdata"] || [fieldTypeGrouping isEqualToString:@"blobdata"] + || [fieldTypeGrouping isEqualToString:@"enum"]) { + + compareType = @"string"; + // [argumentField setFormatter:nil]; + + } else if ([fieldTypeGrouping isEqualToString:@"bit"] || [fieldTypeGrouping isEqualToString:@"integer"] + || [fieldTypeGrouping isEqualToString:@"float"]) { + compareType = @"number"; + // [argumentField setFormatter:numberFormatter]; + + } else { + compareType = @""; + NSBeep(); + NSLog(@"ERROR: unknown type for comparision: %@, in %@", [[tableDataInstance columnWithName:[[fieldField selectedItem] title]] objectForKey:@"type"], fieldTypeGrouping); + } + + // Add IS NULL and IS NOT NULL as they should always be available + // [compareField addItemWithTitle:@"IS NULL"]; + // [compareField addItemWithTitle:@"IS NOT NULL"]; + + // Remove user-defined filters first + if([numberOfDefaultFilters objectForKey:compareType]) { + NSUInteger cycles = [[contentFilters objectForKey:compareType] count] - [[numberOfDefaultFilters objectForKey:compareType] integerValue]; + while(cycles > 0) { + [[contentFilters objectForKey:compareType] removeLastObject]; + cycles--; + } + } + + // Load global user-defined content filters + if([prefs objectForKey:SPContentFilters] + && [contentFilters objectForKey:compareType] + && [[prefs objectForKey:SPContentFilters] objectForKey:compareType]) + { + [[contentFilters objectForKey:compareType] addObjectsFromArray:[[prefs objectForKey:SPContentFilters] objectForKey:compareType]]; + } + + // Load doc-based user-defined content filters + if([[SPQueryController sharedQueryController] contentFilterForFileURL:[tableDocumentInstance fileURL]]) { + id filters = [[SPQueryController sharedQueryController] contentFilterForFileURL:[tableDocumentInstance fileURL]]; + if([filters objectForKey:compareType]) + [[contentFilters objectForKey:compareType] addObjectsFromArray:[filters objectForKey:compareType]]; + } + + // Rebuild operator popup menu + NSUInteger i = 0; + NSMenu *menu = [compareField menu]; + if([contentFilters objectForKey:compareType]) + for(id filter in [contentFilters objectForKey:compareType]) { + NSMenuItem *item = [[NSMenuItem alloc] initWithTitle:([filter objectForKey:@"MenuLabel"])?[filter objectForKey:@"MenuLabel"]:@"not specified" action:NULL keyEquivalent:@""]; + // Create the tooltip + if([filter objectForKey:@"Tooltip"]) + [item setToolTip:[filter objectForKey:@"Tooltip"]]; + else { + NSMutableString *tip = [[NSMutableString alloc] init]; + [tip setString:[[filter objectForKey:@"Clause"] stringByReplacingOccurrencesOfRegex:@"(?<!\\\\)(\\$\\{.*?\\})" withString:@"[arg]"]]; + if([tip isMatchedByRegex:@"(?<!\\\\)\\$BINARY"]) { + [tip replaceOccurrencesOfRegex:@"(?<!\\\\)\\$BINARY" withString:@""]; + [tip appendString:NSLocalizedString(@"\n\nPress ⇧ for binary search (case-sensitive).", @"\n\npress shift for binary search tooltip message")]; + } + [tip flushCachedRegexData]; + [tip replaceOccurrencesOfRegex:@"(?<!\\\\)\\$CURRENT_FIELD" withString:[[fieldField titleOfSelectedItem] backtickQuotedString]]; + [tip flushCachedRegexData]; + [item setToolTip:tip]; + [tip release]; + } + [item setTag:i]; + [menu addItem:item]; + [item release]; + i++; + } + + [menu addItem:[NSMenuItem separatorItem]]; + NSMenuItem *item = [[NSMenuItem alloc] initWithTitle:NSLocalizedString(@"Edit Filters…", @"edit filter") action:NULL keyEquivalent:@""]; + [item setToolTip:NSLocalizedString(@"Edit user-defined Filters…", @"edit user-defined filter")]; + [item setTag:i]; + [menu addItem:item]; + [item release]; + + // Update the argumentField enabled state + [self performSelectorOnMainThread:@selector(toggleFilterField:) withObject:self waitUntilDone:YES]; + + // set focus on argumentField + [argumentField performSelectorOnMainThread:@selector(selectText:) withObject:self waitUntilDone:YES]; + +} + +- (void)openContentFilterManager +{ + [compareField selectItemWithTag:lastSelectedContentFilterIndex]; + + // init query favorites controller + [prefs synchronize]; + if(contentFilterManager) [contentFilterManager release]; + contentFilterManager = [[SPContentFilterManager alloc] initWithDelegate:self forFilterType:compareType]; + + // Open query favorite manager + [NSApp beginSheet:[contentFilterManager window] + modalForWindow:[tableDocumentInstance parentWindow] + modalDelegate:contentFilterManager + didEndSelector:nil + contextInfo:nil]; +} + +/* + * Tries to write a new row to the database. + * Returns YES if row is written to database, otherwise NO; also returns YES if no row + * is being edited and nothing has to be written to the database. + */ +- (BOOL)addRowToDB +{ + NSMutableString *queryString; + id rowObject; + NSMutableString *rowValue = [NSMutableString string]; + NSString *currentTime = [[NSDate date] descriptionWithCalendarFormat:@"%H:%M:%S" timeZone:nil locale:nil]; + BOOL prefsLoadBlobsAsNeeded = [prefs boolForKey:SPLoadBlobsAsNeeded]; + NSInteger i; + + if ( !isEditingRow || currentlyEditingRow == -1) { + return YES; + } + + [[NSNotificationCenter defaultCenter] postNotificationName:@"SMySQLQueryWillBePerformed" object:tableDocumentInstance]; + + // If editing, compare the new row to the old row and if they are identical finish editing without saving. + if (!isEditingNewRow && [oldRow isEqualToArray:[tableValues rowContentsAtIndex:currentlyEditingRow]]) { + isEditingRow = NO; + currentlyEditingRow = -1; + [[NSNotificationCenter defaultCenter] postNotificationName:@"SMySQLQueryHasBeenPerformed" object:tableDocumentInstance]; + return YES; + } + + NSMutableArray *fieldValues = [[NSMutableArray alloc] init]; + + // Get the field values + for ( i = 0 ; i < [dataColumns count] ; i++ ) { + rowObject = [tableValues cellDataAtRow:currentlyEditingRow column:i]; + + // Add not loaded placeholders directly for easy comparison when added + if (prefsLoadBlobsAsNeeded && !isEditingNewRow && [rowObject isSPNotLoaded]) + { + [fieldValues addObject:[SPNotLoaded notLoaded]]; + continue; + + // Catch CURRENT_TIMESTAMP automatic updates - if the row is new and the cell value matches + // the default value, or if the cell hasn't changed, update the current timestamp. + } else if ([[NSArrayObjectAtIndex(dataColumns, i) objectForKey:@"onupdatetimestamp"] integerValue] + && ( (isEditingNewRow && [rowObject isEqualTo:[NSArrayObjectAtIndex(dataColumns, i) objectForKey:@"default"]]) + || (!isEditingNewRow && [rowObject isEqualTo:NSArrayObjectAtIndex(oldRow, i)]))) + { + [rowValue setString:@"CURRENT_TIMESTAMP"]; + + // Convert the object to a string (here we can add special treatment for date-, number- and data-fields) + } else if ( [rowObject isNSNull] + || ([rowObject isMemberOfClass:[NSString class]] && [[rowObject description] isEqualToString:@""]) ) { + + //NULL when user entered the nullValue string defined in the prefs or when a number field isn't set + // problem: when a number isn't set, sequel-pro enters 0 + // -> second if argument isn't necessary! + [rowValue setString:@"NULL"]; + } else { + + // I don't believe any of these class matches are ever met at present. + if ( [rowObject isKindOfClass:[NSCalendarDate class]] ) { + [rowValue setString:[NSString stringWithFormat:@"'%@'", [mySQLConnection prepareString:[rowObject description]]]]; + } else if ( [rowObject isKindOfClass:[NSNumber class]] ) { + [rowValue setString:[rowObject stringValue]]; + } else if ( [rowObject isKindOfClass:[NSData class]] ) { + [rowValue setString:[NSString stringWithFormat:@"X'%@'", [mySQLConnection prepareBinaryData:rowObject]]]; + } else { + if ([[rowObject description] isEqualToString:@"CURRENT_TIMESTAMP"]) { + [rowValue setString:@"CURRENT_TIMESTAMP"]; + } else if ([[NSArrayObjectAtIndex(dataColumns, i) objectForKey:@"typegrouping"] isEqualToString:@"bit"]) { + [rowValue setString:((![[rowObject description] length] || [[rowObject description] isEqualToString:@"0"])?@"0":@"1")]; + } else if ([[NSArrayObjectAtIndex(dataColumns, i) objectForKey:@"typegrouping"] isEqualToString:@"date"] + && [[rowObject description] isEqualToString:@"NOW()"]) { + [rowValue setString:@"NOW()"]; + } else { + [rowValue setString:[NSString stringWithFormat:@"'%@'", [mySQLConnection prepareString:[rowObject description]]]]; + } + } + } + [fieldValues addObject:[NSString stringWithString:rowValue]]; + } + + // Use INSERT syntax when creating new rows - no need to do not loaded checking, as all values have been entered + if ( isEditingNewRow ) { + queryString = [NSString stringWithFormat:@"INSERT INTO %@ (%@) VALUES (%@)", + [selectedTable backtickQuotedString], [[tableDataInstance columnNames] componentsJoinedAndBacktickQuoted], [fieldValues componentsJoinedByString:@","]]; + + // Use UPDATE syntax otherwise + } else { + BOOL firstCellOutput = NO; + queryString = [NSMutableString stringWithFormat:@"UPDATE %@ SET ", [selectedTable backtickQuotedString]]; + for ( i = 0 ; i < [dataColumns count] ; i++ ) { + + // If data column loading is deferred and the value is the not loaded string, skip this cell + if (prefsLoadBlobsAsNeeded && [[fieldValues objectAtIndex:i] isSPNotLoaded]) continue; + + if (firstCellOutput) [queryString appendString:@", "]; + else firstCellOutput = YES; + + [queryString appendString:[NSString stringWithFormat:@"%@=%@", + [[NSArrayObjectAtIndex(dataColumns, i) objectForKey:@"name"] backtickQuotedString], [fieldValues objectAtIndex:i]]]; + } + [queryString appendString:[NSString stringWithFormat:@" WHERE %@", [self argumentForRow:-2]]]; + } + + // If UTF-8 via Latin1 view encoding is set convert the queryString into Latin1 and + // set the MySQL connection to Latin1 before executing this query to allow editing. + // After executing reset all. + if([tableDocumentInstance connectionEncodingViaLatin1:mySQLConnection]) { + + NSStringEncoding currentEncoding = [mySQLConnection encoding]; + NSString *latin1String = [[NSString alloc] initWithCString:[queryString UTF8String] encoding:NSISOLatin1StringEncoding]; + [mySQLConnection setEncoding:NSISOLatin1StringEncoding]; + [mySQLConnection queryString:@"SET NAMES 'latin1'"]; + [mySQLConnection queryString:latin1String]; + [mySQLConnection setEncoding:currentEncoding]; + [mySQLConnection queryString:@"SET NAMES 'utf8'"]; + [mySQLConnection queryString:@"SET CHARACTER_SET_RESULTS=latin1"]; + [latin1String release]; + + } else { + [mySQLConnection queryString:queryString]; + } + + [fieldValues release]; + [[NSNotificationCenter defaultCenter] postNotificationName:@"SMySQLQueryHasBeenPerformed" object:tableDocumentInstance]; + + // If no rows have been changed, show error if appropriate. + if ( ![mySQLConnection affectedRows] && ![mySQLConnection queryErrored] ) { + if ( [prefs boolForKey:SPShowNoAffectedRowsError] ) { + SPBeginAlertSheet(NSLocalizedString(@"Warning", @"warning"), NSLocalizedString(@"OK", @"OK button"), nil, nil, [tableDocumentInstance parentWindow], self, nil, nil, + NSLocalizedString(@"The row was not written to the MySQL database. You probably haven't changed anything.\nReload the table to be sure that the row exists and use a primary key for your table.\n(This error can be turned off in the preferences.)", @"message of panel when no rows have been affected after writing to the db")); + } else { + NSBeep(); + } + [tableValues replaceRowAtIndex:currentlyEditingRow withRowContents:oldRow]; + isEditingRow = NO; + isEditingNewRow = NO; + currentlyEditingRow = -1; + [[SPQueryController sharedQueryController] showErrorInConsole:[NSString stringWithFormat:NSLocalizedString(@"/* WARNING %@ No rows have been affected */\n", @"warning shown in the console when no rows have been affected after writing to the db"), currentTime] connection:[tableDocumentInstance name]]; + return YES; + + // On success... + } else if ( ![mySQLConnection queryErrored] ) { + isEditingRow = NO; + + // New row created successfully + if ( isEditingNewRow ) { + if ( [prefs boolForKey:SPReloadAfterAddingRow] ) { + [[tableDocumentInstance parentWindow] endEditingFor:nil]; + previousTableRowsCount = tableRowsCount; + [self loadTableValues]; + } else { + + // Set the insertId for fields with auto_increment + for ( i = 0; i < [dataColumns count] ; i++ ) { + if ([[NSArrayObjectAtIndex(dataColumns, i) objectForKey:@"autoincrement"] integerValue]) { + [tableValues replaceObjectInRow:currentlyEditingRow column:i withObject:[[NSNumber numberWithLong:[mySQLConnection insertId]] description]]; + } + } + } + isEditingNewRow = NO; + + // Existing row edited successfully + } else { + + // Reload table if set to - otherwise no action required. + if ( [prefs boolForKey:SPReloadAfterEditingRow] ) { + [[tableDocumentInstance parentWindow] endEditingFor:nil]; + previousTableRowsCount = tableRowsCount; + [self loadTableValues]; + } + } + currentlyEditingRow = -1; + + return YES; + + // Report errors which have occurred + } else { + SPBeginAlertSheet(NSLocalizedString(@"Couldn't write row", @"Couldn't write row error"), NSLocalizedString(@"Edit row", @"Edit row button"), NSLocalizedString(@"Discard changes", @"discard changes button"), nil, [tableDocumentInstance parentWindow], self, @selector(addRowErrorSheetDidEnd:returnCode:contextInfo:), nil, + [NSString stringWithFormat:NSLocalizedString(@"MySQL said:\n\n%@", @"message of panel when error while adding row to db"), [mySQLConnection getLastErrorMessage]]); + return NO; + } +} + +/* + * Handle the user decision as a result of an addRow error. + */ +- (void) addRowErrorSheetDidEnd:(NSAlert *)alert returnCode:(NSInteger)returnCode contextInfo:(void *)contextInfo +{ + // Order out current sheet to suppress overlapping of sheets + [[alert window] orderOut:nil]; + + // Edit row selected - reselect the row, and start editing. + if ( returnCode == NSAlertDefaultReturn ) { + [tableContentView selectRowIndexes:[NSIndexSet indexSetWithIndex:currentlyEditingRow] byExtendingSelection:NO]; + [tableContentView performSelector:@selector(keyDown:) withObject:[NSEvent keyEventWithType:NSKeyDown location:NSMakePoint(0,0) modifierFlags:0 timestamp:0 windowNumber:[[tableDocumentInstance parentWindow] windowNumber] context:[NSGraphicsContext currentContext] characters:nil charactersIgnoringModifiers:nil isARepeat:NO keyCode:0x24] afterDelay:0.0]; + + // Discard changes selected + } else { + if ( !isEditingNewRow ) { + [tableValues replaceRowAtIndex:currentlyEditingRow withRowContents:oldRow]; + isEditingRow = NO; + } else { + tableRowsCount--; + [tableValues removeRowAtIndex:currentlyEditingRow]; + isEditingRow = NO; + isEditingNewRow = NO; + } + currentlyEditingRow = -1; + } + [tableContentView reloadData]; +} + +/* + * A method to be called whenever the table selection changes; checks whether the current + * row is being edited, and if so attempts to save it. Returns YES if no save was necessary + * or the save was successful, and NO if a save was necessary and failed - in which case further + * editing is required. In that case this method will reselect the row in question for reediting. + */ +- (BOOL)saveRowOnDeselect +{ + // Save any edits which have been made but not saved to the table yet. + [[tableDocumentInstance parentWindow] endEditingFor:nil]; + + // If no rows are currently being edited, or a save is in progress, return success at once. + if (!isEditingRow || isSavingRow) return YES; + isSavingRow = YES; + + // Attempt to save the row, and return YES if the save succeeded. + if ([self addRowToDB]) { + isSavingRow = NO; + return YES; + } + + // Saving failed - return failure. + isSavingRow = NO; + return NO; +} + +/* + * Returns the WHERE argument to identify a row. + * If "row" is -2, it uses the oldRow. + * Uses the primary key if available, otherwise uses all fields as argument and sets LIMIT to 1 + */ +- (NSString *)argumentForRow:(NSInteger)row +{ + MCPResult *theResult; + NSDictionary *theRow; + id tempValue; + NSMutableString *value = [NSMutableString string]; + NSMutableString *argument = [NSMutableString string]; + // NSString *columnType; + NSArray *columnNames; + NSInteger i; + + if ( row == -1 ) + return @""; + + // Retrieve the field names for this table from the data cache. This is used when requesting all data as part + // of the fieldListForQuery method, and also to decide whether or not to preserve the current filter/sort settings. + columnNames = [tableDataInstance columnNames]; + + // Get the primary key if there is one + if ( !keys ) { + setLimit = NO; + keys = [[NSMutableArray alloc] init]; + theResult = [mySQLConnection queryString:[NSString stringWithFormat:@"SHOW COLUMNS FROM %@", [selectedTable backtickQuotedString]]]; + [theResult setReturnDataAsStrings:YES]; + if ([theResult numOfRows]) [theResult dataSeek:0]; + for ( i = 0 ; i < [theResult numOfRows] ; i++ ) { + theRow = [theResult fetchRowAsDictionary]; + if ( [[theRow objectForKey:@"Key"] isEqualToString:@"PRI"] ) { + [keys addObject:[theRow objectForKey:@"Field"]]; + } + } + } + + // If there is no primary key, all the fields are used in the argument. + if ( ![keys count] ) { + [keys setArray:columnNames]; + setLimit = YES; + + // When the option to not show blob or text options is set, we have a problem - we don't have + // the right values to use in the WHERE statement. Throw an error if this is the case. + if ( [prefs boolForKey:SPLoadBlobsAsNeeded] && [self tableContainsBlobOrTextColumns] ) { + SPBeginAlertSheet(NSLocalizedString(@"Error", @"error"), NSLocalizedString(@"OK", @"OK button"), nil, nil, [tableDocumentInstance parentWindow], self, nil, nil, + NSLocalizedString(@"You can't hide blob and text fields when working with tables without index.", @"message of panel when trying to edit tables without index and with hidden blob/text fields")); + [keys removeAllObjects]; + [tableContentView deselectAll:self]; + return @""; + } + } + + // Walk through the keys list constructing the argument list + for ( i = 0 ; i < [keys count] ; i++ ) { + if ( i ) + [argument appendString:@" AND "]; + + // Use the selected row if appropriate + if ( row >= 0 ) { + tempValue = [tableValues cellDataAtRow:row column:[[[tableDataInstance columnWithName:NSArrayObjectAtIndex(keys, i)] objectForKey:@"datacolumnindex"] integerValue]]; + + // Otherwise use the oldRow + } else { + tempValue = [oldRow objectAtIndex:[[[tableDataInstance columnWithName:NSArrayObjectAtIndex(keys, i)] objectForKey:@"datacolumnindex"] integerValue]]; + } + + if ( [tempValue isNSNull] ) { + [argument appendString:[NSString stringWithFormat:@"%@ IS NULL", [NSArrayObjectAtIndex(keys, i) backtickQuotedString]]]; + } else if ( [tempValue isSPNotLoaded] ) { + NSLog(@"Exceptional case: SPNotLoaded object found for method “argumentForRow:”!"); + return @""; + } else { + + if ( [tempValue isKindOfClass:[NSData class]] ) + [value setString:[NSString stringWithFormat:@"X'%@'", [mySQLConnection prepareBinaryData:tempValue]]]; + else + [value setString:[NSString stringWithFormat:@"'%@'", [mySQLConnection prepareString:tempValue]]]; + + [argument appendString:[NSString stringWithFormat:@"%@ = %@", [NSArrayObjectAtIndex(keys, i) backtickQuotedString], value]]; + } + } + + if (setLimit) [argument appendString:@" LIMIT 1"]; + + return argument; +} + + +/* + * Returns YES if the table contains any columns which are of any of the blob or text types, + * NO otherwise. + */ +- (BOOL)tableContainsBlobOrTextColumns +{ + NSInteger i; + + for ( i = 0 ; i < [dataColumns count]; i++ ) { + if ( [tableDataInstance columnIsBlobOrText:[NSArrayObjectAtIndex(dataColumns, i) objectForKey:@"name"]] ) { + return YES; + } + } + + return NO; +} + +/* + * Returns a string controlling which fields to retrieve for a query. Returns * (all fields) if the preferences + * option dontShowBlob isn't set; otherwise, returns a comma-separated list of all non-blob/text fields. + */ +- (NSString *)fieldListForQuery +{ + NSInteger i; + NSMutableArray *fields = [NSMutableArray array]; + + if (([prefs boolForKey:SPLoadBlobsAsNeeded]) && ([dataColumns count] > 0)) { + + NSArray *columnNames = [tableDataInstance columnNames]; + + for (i = 0 ; i < [columnNames count]; i++) + { + if (![tableDataInstance columnIsBlobOrText:[NSArrayObjectAtIndex(dataColumns, i) objectForKey:@"name"]] ) { + [fields addObject:[NSArrayObjectAtIndex(columnNames, i) backtickQuotedString]]; + } + else { + // For blob/text fields, select a null placeholder so the column count is still correct + [fields addObject:@"NULL"]; + } + } + + return [fields componentsJoinedByString:@","]; + } + else { + return @"*"; + } +} + +/* + * Close an open sheet. + */ +- (void)sheetDidEnd:(id)sheet returnCode:(NSInteger)returnCode contextInfo:(NSString *)contextInfo +{ + [sheet orderOut:self]; +} + +/** + * Show Error sheet (can be called from inside of a endSheet selector) + * via [self performSelector:@selector(showErrorSheetWithTitle:) withObject: afterDelay:] + */ +-(void)showErrorSheetWith:(id)error +{ + // error := first object is the title , second the message, only one button OK + SPBeginAlertSheet([error objectAtIndex:0], NSLocalizedString(@"OK", @"OK button"), + nil, nil, [tableDocumentInstance parentWindow], self, nil, nil, + [error objectAtIndex:1]); +} + +#pragma mark - +#pragma mark Retrieving and setting table state + +/** + * Provide a getter for the table's sort column name + */ +- (NSString *) sortColumnName +{ + if (!sortCol || !dataColumns) return nil; + + return [[dataColumns objectAtIndex:[sortCol integerValue]] objectForKey:@"name"]; +} + +/** + * Provide a getter for the table current sort order + */ +- (BOOL) sortColumnIsAscending +{ + return !isDesc; +} + +/** + * Provide a getter for the table's selected rows index set + */ +- (NSIndexSet *) selectedRowIndexes +{ + return [tableContentView selectedRowIndexes]; +} + +/** + * Provide a getter for the page number + */ +- (NSUInteger) pageNumber +{ + return contentPage; +} + +/** + * Provide a getter for the table's current viewport + */ +- (NSRect) viewport +{ + return [tableContentView visibleRect]; +} + +/** + * Provide a getter for the current filter details + */ +- (NSDictionary *) filterSettings +{ + NSDictionary *theDictionary; + + if (![fieldField isEnabled]) return nil; + + theDictionary = [NSDictionary dictionaryWithObjectsAndKeys: + [self tableFilterString], @"menuLabel", + [[fieldField selectedItem] title], @"filterField", + [[compareField selectedItem] title], @"filterComparison", + [NSNumber numberWithInteger:[[compareField selectedItem] tag]], @"filterComparisonTag", + [argumentField stringValue], @"filterValue", + [firstBetweenField stringValue], @"firstBetweenField", + [secondBetweenField stringValue], @"secondBetweenField", + nil]; + + return theDictionary; +} + +/** + * Set the sort column and sort order to restore on next table load + */ +- (void) setSortColumnNameToRestore:(NSString *)theSortColumnName isAscending:(BOOL)isAscending +{ + if (sortColumnToRestore) [sortColumnToRestore release], sortColumnToRestore = nil; + + if (theSortColumnName) { + sortColumnToRestore = [[NSString alloc] initWithString:theSortColumnName]; + sortColumnToRestoreIsAsc = isAscending; + } +} + +/** + * Sets the value for the page number to use on next table load + */ +- (void) setPageToRestore:(NSUInteger)thePage +{ + pageToRestore = thePage; +} + +/** + * Set the selected row indexes to restore on next table load + */ +- (void) setSelectedRowIndexesToRestore:(NSIndexSet *)theIndexSet +{ + if (selectionIndexToRestore) [selectionIndexToRestore release], selectionIndexToRestore = nil; + + if (theIndexSet) selectionIndexToRestore = [[NSIndexSet alloc] initWithIndexSet:theIndexSet]; +} + +/** + * Set the viewport to restore on next table load + */ +- (void) setViewportToRestore:(NSRect)theViewport +{ + selectionViewportToRestore = theViewport; +} + +/** + * Set the filter settings to restore (if possible) on next table load + */ +- (void) setFiltersToRestore:(NSDictionary *)filterSettings +{ + if (filterFieldToRestore) [filterFieldToRestore release], filterFieldToRestore = nil; + if (filterComparisonToRestore) [filterComparisonToRestore release], filterComparisonToRestore = nil; + if (filterValueToRestore) [filterValueToRestore release], filterValueToRestore = nil; + if (firstBetweenValueToRestore) [firstBetweenValueToRestore release], firstBetweenValueToRestore = nil; + if (secondBetweenValueToRestore) [secondBetweenValueToRestore release], secondBetweenValueToRestore = nil; + + if (filterSettings) { + if ([filterSettings objectForKey:@"filterField"]) + filterFieldToRestore = [[NSString alloc] initWithString:[filterSettings objectForKey:@"filterField"]]; + if ([filterSettings objectForKey:@"filterComparison"]) { + // Check if operator is BETWEEN, if so set up input fields + if([[filterSettings objectForKey:@"filterComparison"] isEqualToString:@"BETWEEN"]) { + [argumentField setHidden:YES]; + [betweenTextField setHidden:NO]; + [firstBetweenField setHidden:NO]; + [secondBetweenField setHidden:NO]; + [firstBetweenField setEnabled:YES]; + [secondBetweenField setEnabled:YES]; + } + + filterComparisonToRestore = [[NSString alloc] initWithString:[filterSettings objectForKey:@"filterComparison"]]; + } + if([[filterSettings objectForKey:@"filterComparison"] isEqualToString:@"BETWEEN"]) { + if ([filterSettings objectForKey:@"firstBetweenField"]) + firstBetweenValueToRestore = [[NSString alloc] initWithString:[filterSettings objectForKey:@"firstBetweenField"]]; + if ([filterSettings objectForKey:@"secondBetweenField"]) + secondBetweenValueToRestore = [[NSString alloc] initWithString:[filterSettings objectForKey:@"secondBetweenField"]]; + } else { + if ([filterSettings objectForKey:@"filterValue"] && ![[filterSettings objectForKey:@"filterValue"] isNSNull]) + filterValueToRestore = [[NSString alloc] initWithString:[filterSettings objectForKey:@"filterValue"]]; + } + } +} + +/** + * Convenience method for storing all current settings for restoration + */ +- (void) storeCurrentDetailsForRestoration +{ + [self setSortColumnNameToRestore:[self sortColumnName] isAscending:[self sortColumnIsAscending]]; + [self setPageToRestore:[self pageNumber]]; + [self setSelectedRowIndexesToRestore:[self selectedRowIndexes]]; + [self setViewportToRestore:[self viewport]]; + [self setFiltersToRestore:[self filterSettings]]; +} + +/** + * Convenience method for clearing any settings to restore + */ +- (void) clearDetailsToRestore +{ + [self setSortColumnNameToRestore:nil isAscending:YES]; + [self setPageToRestore:1]; + [self setSelectedRowIndexesToRestore:nil]; + [self setViewportToRestore:NSZeroRect]; + [self setFiltersToRestore:nil]; +} + +#pragma mark - +#pragma mark Table drawing and editing + +/** + * Updates the number of rows in the selected table. + * Attempts to use the fullResult count if available, also updating the + * table data store; otherwise, uses the table data store if accurate or + * falls back to a fetch if necessary and set in preferences. + * The prefs option "fetch accurate row counts" is used as a last resort as + * it can be very slow on large InnoDB tables which require a full table scan. + */ +- (void)updateNumberOfRows +{ + BOOL checkStatusCount = NO; + + // For unfiltered and non-limited tables, use the result count - and update the status count + if (!isLimited && !isFiltered && !isInterruptedLoad) { + maxNumRows = tableRowsCount; + maxNumRowsIsEstimate = NO; + [tableDataInstance setStatusValue:[NSString stringWithFormat:@"%ld", (long)maxNumRows] forKey:@"Rows"]; + [tableDataInstance setStatusValue:@"y" forKey:@"RowsCountAccurate"]; + [tableInfoInstance tableChanged:nil]; + [[tableDocumentInstance valueForKey:@"extendedTableInfoInstance"] performSelectorOnMainThread:@selector(loadTable:) withObject:selectedTable waitUntilDone:YES]; + + // Otherwise, if the table status value is accurate, use it + } else if ([[tableDataInstance statusValueForKey:@"RowsCountAccurate"] boolValue]) { + maxNumRows = [[tableDataInstance statusValueForKey:@"Rows"] integerValue]; + maxNumRowsIsEstimate = NO; + checkStatusCount = YES; + + // Choose whether to display an estimate, or to fetch the correct row count, based on prefs + } else if ([[prefs objectForKey:SPTableRowCountQueryLevel] integerValue] == SPRowCountFetchAlways + || ([[prefs objectForKey:SPTableRowCountQueryLevel] integerValue] == SPRowCountFetchIfCheap + && [tableDataInstance statusValueForKey:@"Data_length"] + && [[prefs objectForKey:SPTableRowCountCheapSizeBoundary] integerValue] > [[tableDataInstance statusValueForKey:@"Data_length"] integerValue])) + { + maxNumRows = [self fetchNumberOfRows]; + maxNumRowsIsEstimate = NO; + [tableDataInstance setStatusValue:[NSString stringWithFormat:@"%ld", (long)maxNumRows] forKey:@"Rows"]; + [tableDataInstance setStatusValue:@"y" forKey:@"RowsCountAccurate"]; + [tableInfoInstance tableChanged:nil]; + [[tableDocumentInstance valueForKey:@"extendedTableInfoInstance"] performSelectorOnMainThread:@selector(loadTable:) withObject:selectedTable waitUntilDone:YES]; + + // Use the estimate count + } else { + maxNumRows = [[tableDataInstance statusValueForKey:@"Rows"] integerValue]; + maxNumRowsIsEstimate = YES; + checkStatusCount = YES; + } + + // Check whether the estimated count requires updating, ie if the retrieved count exceeds it + if (checkStatusCount) { + NSInteger foundMaxRows; + if ([prefs boolForKey:SPLimitResults]) { + foundMaxRows = ((contentPage - 1) * [prefs integerForKey:SPLimitResultsValue]) + tableRowsCount; + if (foundMaxRows > maxNumRows) { + if (tableRowsCount == [prefs integerForKey:SPLimitResultsValue]) { + maxNumRows = foundMaxRows + 1; + maxNumRowsIsEstimate = YES; + } else { + maxNumRows = foundMaxRows; + maxNumRowsIsEstimate = NO; + } + } else if (!isInterruptedLoad && !isFiltered && tableRowsCount < [prefs integerForKey:SPLimitResultsValue]) { + maxNumRows = foundMaxRows; + maxNumRowsIsEstimate = NO; + } + } else if (tableRowsCount > maxNumRows) { + maxNumRows = tableRowsCount; + maxNumRowsIsEstimate = YES; + } + [tableDataInstance setStatusValue:[NSString stringWithFormat:@"%ld", (long)maxNumRows] forKey:@"Rows"]; + [tableDataInstance setStatusValue:maxNumRowsIsEstimate?@"n":@"y" forKey:@"RowsCountAccurate"]; + [tableInfoInstance tableChanged:nil]; + } +} + +/* + * Fetches the number of rows in the selected table using a "SELECT COUNT(1)" query and return it + */ +- (NSInteger)fetchNumberOfRows +{ + return [[[[mySQLConnection queryString:[NSString stringWithFormat:@"SELECT COUNT(1) FROM %@", [selectedTable backtickQuotedString]]] fetchRowAsArray] objectAtIndex:0] integerValue]; +} + +#pragma mark - +#pragma mark TableView delegate methods + +/** + * Show the table cell content as tooltip + * - for text displays line breaks and tabs as well + * - if blob data can be interpret as image data display the image as transparent thumbnail + * (up to now using base64 encoded HTML data) + */ +- (NSString *)tableView:(NSTableView *)aTableView toolTipForCell:(SPTextAndLinkCell *)aCell rect:(NSRectPointer)rect tableColumn:(NSTableColumn *)aTableColumn row:(NSInteger)row mouseLocation:(NSPoint)mouseLocation +{ + + if([[aCell stringValue] length] < 2 || [tableDocumentInstance isWorking]) return nil; + + NSImage *image; + + NSPoint pos = [NSEvent mouseLocation]; + pos.y -= 20; + + // Try to get the original data. If not possible return nil. + // @try clause is used due to the multifarious cases of + // possible exceptions (eg for reloading tables etc.) + id theValue; + @try{ + theValue = [tableValues cellDataAtRow:row column:[[aTableColumn identifier] integerValue]]; + } + @catch(id ae) { + return nil; + } + + // Get the original data for trying to display the blob data as an image + if ([theValue isKindOfClass:[NSData class]]) { + image = [[[NSImage alloc] initWithData:theValue] autorelease]; + if(image) { + [SPTooltip showWithObject:image atLocation:pos ofType:@"image"]; + return nil; + } + } + + // Show the cell string value as tooltip (including line breaks and tabs) + // by using the cell's font + [SPTooltip showWithObject:[aCell stringValue] + atLocation:pos + ofType:@"text" + displayOptions:[NSDictionary dictionaryWithObjectsAndKeys: + [[aCell font] familyName], @"fontname", + [NSString stringWithFormat:@"%f",[[aCell font] pointSize]], @"fontsize", + nil]]; + + return nil; +} + +- (NSInteger)numberOfRowsInTableView:(NSTableView *)aTableView +{ + return tableRowsCount; +} + +- (id)tableView:(CMCopyTable *)aTableView objectValueForTableColumn:(NSTableColumn *)aTableColumn row:(NSInteger)rowIndex +{ + NSUInteger columnIndex = [[aTableColumn identifier] integerValue]; + id theValue = nil; + + // While the table is being loaded, additional validation is required - data + // locks must be used to avoid crashes, and indexes higher than the available + // rows or columns may be requested. Return "..." to indicate loading in these + // cases. + if (isWorking) { + pthread_mutex_lock(&tableValuesLock); + if (rowIndex < tableRowsCount && columnIndex < [tableValues columnCount]) { + theValue = [[SPDataStorageObjectAtRowAndColumn(tableValues, rowIndex, columnIndex) copy] autorelease]; + } + pthread_mutex_unlock(&tableValuesLock); + + if (!theValue) return @"..."; + } else { + theValue = SPDataStorageObjectAtRowAndColumn(tableValues, rowIndex, columnIndex); + } + + if ([theValue isNSNull]) + return [prefs objectForKey:SPNullValue]; + + if ([theValue isKindOfClass:[NSData class]]) + return [theValue shortStringRepresentationUsingEncoding:[mySQLConnection encoding]]; + + if ([theValue isSPNotLoaded]) + return NSLocalizedString(@"(not loaded)", @"value shown for hidden blob and text fields"); + + return theValue; +} + +/** + * This function changes the text color of text/blob fields which are null or not yet loaded to gray + */ +- (void)tableView:(CMCopyTable *)aTableView willDisplayCell:(id)cell forTableColumn:(NSTableColumn*)aTableColumn row:(NSInteger)rowIndex +{ + if (![cell respondsToSelector:@selector(setTextColor:)]) return; + + NSUInteger columnIndex = [[aTableColumn identifier] integerValue]; + id theValue = nil; + + // While the table is being loaded, additional validation is required - data + // locks must be used to avoid crashes, and indexes higher than the available + // rows or columns may be requested. Use gray to indicate loading in these cases. + if (isWorking) { + pthread_mutex_lock(&tableValuesLock); + if (rowIndex < tableRowsCount && columnIndex < [tableValues columnCount]) { + theValue = SPDataStorageObjectAtRowAndColumn(tableValues, rowIndex, columnIndex); + } + pthread_mutex_unlock(&tableValuesLock); + + if (!theValue) { + [cell setTextColor:[NSColor lightGrayColor]]; + return; + } + } else { + theValue = SPDataStorageObjectAtRowAndColumn(tableValues, rowIndex, columnIndex); + } + + // If user wants to edit 'cell' set text color to black and return to avoid + // writing in gray if value was NULL + if ([aTableView editedColumn] != -1 + && [aTableView editedRow] == rowIndex + && [[NSArrayObjectAtIndex([aTableView tableColumns], [aTableView editedColumn]) identifier] integerValue] == columnIndex) { + [cell setTextColor:[NSColor blackColor]]; + return; + } + + // For null cells and not loaded cells, display the contents in gray. + if ([theValue isNSNull] || [theValue isSPNotLoaded]) { + [cell setTextColor:[NSColor lightGrayColor]]; + + // Otherwise, set the color to black - required as NSTableView reuses NSCells. + } else { + [cell setTextColor:[NSColor blackColor]]; + } +} + +- (void)tableView:(NSTableView *)aTableView setObjectValue:(id)anObject forTableColumn:(NSTableColumn *)aTableColumn row:(NSInteger)rowIndex +{ + // Catch editing events in the row and if the row isn't currently being edited, + // start an edit. This allows edits including enum changes to save correctly. + if ( !isEditingRow ) { + [oldRow setArray:[tableValues rowContentsAtIndex:rowIndex]]; + isEditingRow = YES; + currentlyEditingRow = rowIndex; + } + + NSDictionary *column = NSArrayObjectAtIndex(dataColumns, [[aTableColumn identifier] integerValue]); + + if (anObject) { + + // Restore NULLs if necessary + if ([anObject isEqualToString:[prefs objectForKey:SPNullValue]] && [[column objectForKey:@"null"] boolValue]) + anObject = [NSNull null]; + + [tableValues replaceObjectInRow:rowIndex column:[[aTableColumn identifier] integerValue] withObject:anObject]; + } else { + [tableValues replaceObjectInRow:rowIndex column:[[aTableColumn identifier] integerValue] withObject:@""]; + } +} + +#pragma mark - +#pragma mark TableView delegate methods + +/** + * Sorts the tableView by the clicked column. + * If clicked twice, order is altered to descending. + * Performs the task in a new thread if necessary. + */ +- (void)tableView:(NSTableView*)tableView didClickTableColumn:(NSTableColumn *)tableColumn +{ + + if ( [selectedTable isEqualToString:@""] || !selectedTable ) + return; + + // Prevent sorting while the table is still loading + if ([tableDocumentInstance isWorking]) return; + + // Start the task + [tableDocumentInstance startTaskWithDescription:NSLocalizedString(@"Sorting table...", @"Sorting table task description")]; + if ([NSThread isMainThread]) { + [NSThread detachNewThreadSelector:@selector(sortTableTaskWithColumn:) toTarget:self withObject:tableColumn]; + } else { + [self sortTableTaskWithColumn:tableColumn]; + } +} +- (void)sortTableTaskWithColumn:(NSTableColumn *)tableColumn +{ + NSAutoreleasePool *sortPool = [[NSAutoreleasePool alloc] init]; + + // Check whether a save of the current row is required. + if (![[self onMainThread] saveRowOnDeselect]) { + [sortPool drain]; + return; + } + + // Sets order descending if a header is clicked twice + if ([[tableColumn identifier] isEqualTo:sortCol]) { + isDesc = !isDesc; + } else { + isDesc = NO; + [[tableContentView onMainThread] setIndicatorImage:nil inTableColumn:[tableContentView tableColumnWithIdentifier:sortCol]]; + } + if (sortCol) [sortCol release]; + sortCol = [[NSNumber alloc] initWithInteger:[[tableColumn identifier] integerValue]]; + + // Set the highlight and indicatorImage + [[tableContentView onMainThread] setHighlightedTableColumn:tableColumn]; + if (isDesc) { + [[tableContentView onMainThread] setIndicatorImage:[NSImage imageNamed:@"NSDescendingSortIndicator"] inTableColumn:tableColumn]; + } else { + [[tableContentView onMainThread] setIndicatorImage:[NSImage imageNamed:@"NSAscendingSortIndicator"] inTableColumn:tableColumn]; + } + + // Update data using the new sort order + previousTableRowsCount = tableRowsCount; + [self loadTableValues]; + + if ([mySQLConnection queryErrored]) { + SPBeginAlertSheet(NSLocalizedString(@"Error", @"error"), NSLocalizedString(@"OK", @"OK button"), nil, nil, [tableDocumentInstance parentWindow], self, nil, nil, + [NSString stringWithFormat:NSLocalizedString(@"Couldn't sort table. MySQL said: %@", @"message of panel when sorting of table failed"), [mySQLConnection getLastErrorMessage]]); + [tableDocumentInstance endTask]; + [sortPool drain]; + return; + } + + [tableDocumentInstance endTask]; + [sortPool drain]; +} + +- (void)tableViewSelectionDidChange:(NSNotification *)aNotification +{ + // Check our notification object is our table content view + if ([aNotification object] != tableContentView) return; + + // If we are editing a row, attempt to save that row - if saving failed, reselect the edit row. + if (isEditingRow && [tableContentView selectedRow] != currentlyEditingRow && ![self saveRowOnDeselect]) return; + + if (![tableDocumentInstance isWorking]) { + + // Update the row selection count + // and update the status of the delete/duplicate buttons + if ([tableContentView numberOfSelectedRows] > 0) { + [copyButton setEnabled:YES]; + [removeButton setEnabled:YES]; + } + else { + [copyButton setEnabled:NO]; + [removeButton setEnabled:NO]; + } + } + + [self updateCountText]; +} + +- (void)tableViewColumnDidResize:(NSNotification *)aNotification +/* + saves the new column size in the preferences + */ +{ + // sometimes the column has no identifier. I can't figure out what is causing it, so we just skip over this item + if (![[[aNotification userInfo] objectForKey:@"NSTableColumn"] identifier]) + return; + + NSMutableDictionary *tableColumnWidths; + NSString *database = [NSString stringWithFormat:@"%@@%@", [tableDocumentInstance database], [tableDocumentInstance host]]; + NSString *table = [tablesListInstance tableName]; + + // get tableColumnWidths object + if ( [prefs objectForKey:SPTableColumnWidths] != nil ) { + tableColumnWidths = [NSMutableDictionary dictionaryWithDictionary:[prefs objectForKey:SPTableColumnWidths]]; + } else { + tableColumnWidths = [NSMutableDictionary dictionary]; + } + // get database object + if ( [tableColumnWidths objectForKey:database] == nil ) { + [tableColumnWidths setObject:[NSMutableDictionary dictionary] forKey:database]; + } else { + [tableColumnWidths setObject:[NSMutableDictionary dictionaryWithDictionary:[tableColumnWidths objectForKey:database]] forKey:database]; + + } + // get table object + if ( [[tableColumnWidths objectForKey:database] objectForKey:table] == nil ) { + [[tableColumnWidths objectForKey:database] setObject:[NSMutableDictionary dictionary] forKey:table]; + } else { + [[tableColumnWidths objectForKey:database] setObject:[NSMutableDictionary dictionaryWithDictionary:[[tableColumnWidths objectForKey:database] objectForKey:table]] forKey:table]; + + } + // save column size + [[[tableColumnWidths objectForKey:database] objectForKey:table] setObject:[NSNumber numberWithDouble:[(NSTableColumn *)[[aNotification userInfo] objectForKey:@"NSTableColumn"] width]] forKey:[[[[aNotification userInfo] objectForKey:@"NSTableColumn"] headerCell] stringValue]]; + [prefs setObject:tableColumnWidths forKey:SPTableColumnWidths]; +} + +/** + * Confirm whether to allow editing of a row. Returns YES by default, unless the multipleLineEditingButton is in + * the ON state, or for blob or text fields - in those cases opens a sheet for editing instead and returns NO. + */ +- (BOOL)tableView:(NSTableView *)aTableView shouldEditTableColumn:(NSTableColumn *)aTableColumn row:(NSInteger)rowIndex +{ + if ([tableDocumentInstance isWorking]) return NO; + + // Ensure that row is editable since it could contain "(not loaded)" columns together with + // issue that the table has no primary key + NSString *wherePart = [NSString stringWithString:[self argumentForRow:[tableContentView selectedRow]]]; + if ([wherePart length] == 0) return NO; + + // If the selected cell hasn't been loaded, load it. + if ([[tableValues cellDataAtRow:rowIndex column:[[aTableColumn identifier] integerValue]] isSPNotLoaded]) { + + // Only get the data for the selected column, not all of them + NSString *query = [NSString stringWithFormat:@"SELECT %@ FROM %@ WHERE %@", [[[aTableColumn headerCell] stringValue] backtickQuotedString], [selectedTable backtickQuotedString], wherePart]; + + MCPResult *tempResult = [mySQLConnection queryString:query]; + if (![tempResult numOfRows]) { + SPBeginAlertSheet(NSLocalizedString(@"Error", @"error"), NSLocalizedString(@"OK", @"OK button"), nil, nil, [tableDocumentInstance parentWindow], self, nil, nil, + NSLocalizedString(@"Couldn't load the row. Reload the table to be sure that the row exists and use a primary key for your table.", @"message of panel when loading of row failed")); + return NO; + } + + NSArray *tempRow = [tempResult fetchRowAsArray]; + [tableValues replaceObjectInRow:rowIndex column:[[tableContentView tableColumns] indexOfObject:aTableColumn] withObject:[tempRow objectAtIndex:0]]; + [tableContentView reloadData]; + } + + BOOL isBlob = [tableDataInstance columnIsBlobOrText:[[aTableColumn headerCell] stringValue]]; + + // Open the sheet if the multipleLineEditingButton is enabled or the column was a blob or a text. + if ([multipleLineEditingButton state] == NSOnState || isBlob) { + + SPFieldEditorController *fieldEditor = [[SPFieldEditorController alloc] init]; + + [fieldEditor setTextMaxLength:[[[aTableColumn dataCellForRow:rowIndex] formatter] textLimit]]; + + id cellValue = [tableValues cellDataAtRow:rowIndex column:[[aTableColumn identifier] integerValue]]; + if ([cellValue isNSNull]) cellValue = [NSString stringWithString:[prefs objectForKey:SPNullValue]]; + + id editData = [[fieldEditor editWithObject:cellValue + fieldName:[[aTableColumn headerCell] stringValue] + usingEncoding:[mySQLConnection encoding] + isObjectBlob:isBlob + isEditable:YES + withWindow:[tableDocumentInstance parentWindow]] retain]; + + if (editData) { + if (!isEditingRow) { + [oldRow setArray:[tableValues rowContentsAtIndex:rowIndex]]; + isEditingRow = YES; + currentlyEditingRow = rowIndex; + } + + if ([editData isKindOfClass:[NSString class]] + && [editData isEqualToString:[prefs objectForKey:SPNullValue]] + && [[NSArrayObjectAtIndex(dataColumns, [[aTableColumn identifier] integerValue]) objectForKey:@"null"] boolValue]) + { + [editData release]; + editData = [[NSNull null] retain]; + } + [tableValues replaceObjectInRow:rowIndex column:[[aTableColumn identifier] integerValue] withObject:[[editData copy] autorelease]]; + } + + [fieldEditor release]; + + if (editData) [editData release]; + + return NO; + } + + return YES; +} + +/** + * Enable drag from tableview + */ +- (BOOL)tableView:(NSTableView *)aTableView writeRowsWithIndexes:(NSIndexSet *)rows toPasteboard:(NSPasteboard*)pboard +{ + if (aTableView == tableContentView) { + NSString *tmp; + + // By holding ⌘, ⇧, or/and ⌥ copies selected rows as SQL INSERTS + // otherwise \t delimited lines + if([[NSApp currentEvent] modifierFlags] & (NSCommandKeyMask|NSShiftKeyMask|NSAlternateKeyMask)) + tmp = [tableContentView selectedRowsAsSqlInserts]; + else + tmp = [tableContentView draggedRowsAsTabString]; + + if ( nil != tmp && [tmp length] ) + { + [pboard declareTypes:[NSArray arrayWithObjects: NSTabularTextPboardType, + NSStringPboardType, nil] + owner:nil]; + + [pboard setString:tmp forType:NSStringPboardType]; + [pboard setString:tmp forType:NSTabularTextPboardType]; + return YES; + } + } + + return NO; +} + +/** + * Disable row selection while the document is working. + */ +- (BOOL)tableView:(NSTableView *)aTableView shouldSelectRow:(NSInteger)rowIndex +{ + return tableRowsSelectable; +} + +#pragma mark - +#pragma mark SplitView delegate methods + +- (BOOL)splitView:(NSSplitView *)sender canCollapseSubview:(NSView *)subview +{ + return NO; +} + +- (CGFloat)splitView:(NSSplitView *)sender constrainMaxCoordinate:(CGFloat)proposedMax ofSubviewAt:(NSInteger)offset +{ + return (proposedMax - 180); +} + +- (CGFloat)splitView:(NSSplitView *)sender constrainMinCoordinate:(CGFloat)proposedMin ofSubviewAt:(NSInteger)offset +{ + return (proposedMin + 200); +} + +#pragma mark - +#pragma mark Task interaction + +/** + * Disable all content interactive elements during an ongoing task. + */ +- (void) startDocumentTaskForTab:(NSNotification *)aNotification +{ + isWorking = YES; + + // Only proceed if this view is selected. + if (![[tableDocumentInstance selectedToolbarItemIdentifier] isEqualToString:SPMainToolbarTableContent]) + return; + + [addButton setEnabled:NO]; + [removeButton setEnabled:NO]; + [copyButton setEnabled:NO]; + [reloadButton setEnabled:NO]; + [filterButton setEnabled:NO]; + tableRowsSelectable = NO; + [paginationPreviousButton setEnabled:NO]; + [paginationNextButton setEnabled:NO]; + [paginationButton setEnabled:NO]; +} + +/** + * Enable all content interactive elements after an ongoing task. + */ +- (void) endDocumentTaskForTab:(NSNotification *)aNotification +{ + isWorking = NO; + + // Only proceed if this view is selected. + if (![[tableDocumentInstance selectedToolbarItemIdentifier] isEqualToString:SPMainToolbarTableContent]) + return; + + if ( ![[[tableDataInstance statusValues] objectForKey:@"Rows"] isNSNull] && selectedTable && [selectedTable length] && [tableDataInstance tableEncoding]) { + [addButton setEnabled:YES]; + [self updatePaginationState]; + [reloadButton setEnabled:YES]; + } + if ([tableContentView numberOfSelectedRows] > 0) { + [removeButton setEnabled:YES]; + [copyButton setEnabled:YES]; + } + [filterButton setEnabled:[fieldField isEnabled]]; + tableRowsSelectable = YES; +} + +#pragma mark - +#pragma mark Other methods + +/* + * Trap the enter, escape, tab and arrow keys, overriding default behaviour and continuing/ending editing, + * only within the current row. + */ +- (BOOL)control:(NSControl *)control textView:(NSTextView *)textView doCommandBySelector:(SEL)command +{ + NSString *fieldType; + NSUInteger row, column, i; + + row = [tableContentView editedRow]; + column = [tableContentView editedColumn]; + + // Trap tab key + if ( [textView methodForSelector:command] == [textView methodForSelector:@selector(insertTab:)] ) + { + [[control window] makeFirstResponder:control]; + + // Save the current line if it's the last field in the table + if ( column == ( [tableContentView numberOfColumns] - 1 ) ) { + [self addRowToDB]; + } else { + + // Check if next column is a blob column, and skip to the next non-blob column + i = 1; + while ( + (fieldType = [[tableDataInstance columnWithName:[[NSArrayObjectAtIndex([tableContentView tableColumns], column+i) headerCell] stringValue]] objectForKey:@"typegrouping"]) + && ([fieldType isEqualToString:@"textdata"] || [fieldType isEqualToString:@"blobdata"]) + ) { + i++; + + // If there are no columns after the latest blob or text column, save the current line. + if ( (column+i) >= [tableContentView numberOfColumns] ) { + [self addRowToDB]; + return TRUE; + } + } + + // Edit the column after the blob column + [tableContentView editColumn:column+i row:row withEvent:nil select:YES]; + } + return TRUE; + } + + // Trap enter key + else if ( [textView methodForSelector:command] == [textView methodForSelector:@selector(insertNewline:)] ) + { + [[control window] makeFirstResponder:control]; + [self addRowToDB]; + return TRUE; + } + + // Trap down arrow key + else if ( [textView methodForSelector:command] == [textView methodForSelector:@selector(moveDown:)] ) + { + NSUInteger newRow = row+1; + if (newRow>=tableRowsCount) return TRUE; //check if we're already at the end of the list + + [[control window] makeFirstResponder:control]; + [self addRowToDB]; + + if (newRow>=tableRowsCount) return TRUE; //check again. addRowToDB could reload the table and change the number of rows + if (column>=[tableValues columnCount]) return TRUE; //the column count could change too + + [tableContentView selectRowIndexes:[NSIndexSet indexSetWithIndex:newRow] byExtendingSelection:NO]; + [tableContentView editColumn:column row:newRow withEvent:nil select:YES]; + return TRUE; + } + + // Trap up arrow key + else if ( [textView methodForSelector:command] == [textView methodForSelector:@selector(moveUp:)] ) + { + if (row==0) return TRUE; //already at the beginning of the list + NSUInteger newRow = row-1; + + [[control window] makeFirstResponder:control]; + [self addRowToDB]; + + if (newRow>=tableRowsCount) return TRUE; // addRowToDB could reload the table and change the number of rows + if (column>=[tableValues columnCount]) return TRUE; //the column count could change too + + [tableContentView selectRowIndexes:[NSIndexSet indexSetWithIndex:newRow] byExtendingSelection:NO]; + [tableContentView editColumn:column row:newRow withEvent:nil select:YES]; + return TRUE; + } + + // Trap the escape key + else if ( [[control window] methodForSelector:command] == [[control window] methodForSelector:@selector(_cancelKey:)] || + [textView methodForSelector:command] == [textView methodForSelector:@selector(complete:)] ) + { + + // Abort editing + [control abortEditing]; + if ( isEditingRow && !isEditingNewRow ) { + isEditingRow = NO; + [tableValues replaceRowAtIndex:row withRowContents:oldRow]; + } else if ( isEditingNewRow ) { + isEditingRow = NO; + isEditingNewRow = NO; + tableRowsCount--; + [tableValues removeRowAtIndex:row]; + [self updateCountText]; + [tableContentView reloadData]; + } + currentlyEditingRow = -1; + return TRUE; + } + else + { + return FALSE; + } +} + +/** + * This method is called as part of Key Value Observing which is used to watch for prefernce changes which effect the interface. + */ +- (void)observeValueForKeyPath:(NSString *)keyPath ofObject:(id)object change:(NSDictionary *)change context:(void *)context +{ + // Display table veiew vertical gridlines preference changed + if ([keyPath isEqualToString:SPDisplayTableViewVerticalGridlines]) { + [tableContentView setGridStyleMask:([[change objectForKey:NSKeyValueChangeNewKey] boolValue]) ? NSTableViewSolidVerticalGridLineMask : NSTableViewGridNone]; + } + // Table font preference changed + else if ([keyPath isEqualToString:SPGlobalResultTableFont]) { + NSFont *tableFont = [NSUnarchiver unarchiveObjectWithData:[change objectForKey:NSKeyValueChangeNewKey]]; + [tableContentView setRowHeight:2.0f+NSSizeToCGSize([[NSString stringWithString:@"{ǞṶḹÜ∑zgyf"] sizeWithAttributes:[NSDictionary dictionaryWithObject:tableFont forKey:NSFontAttributeName]]).height]; + [tableContentView setFont:tableFont]; + [tableContentView reloadData]; + } +} + +/** + * Menu validation + */ +- (BOOL)validateMenuItem:(NSMenuItem *)menuItem +{ + // Remove row + if ([menuItem action] == @selector(removeRow:)) { + [menuItem setTitle:([tableContentView numberOfSelectedRows] > 1) ? @"Delete Rows" : @"Delete Row"]; + + return ([tableContentView numberOfSelectedRows] > 0); + } + + // Duplicate row + if ([menuItem action] == @selector(copyRow:)) { + return ([tableContentView numberOfSelectedRows] == 1); + } + + return YES; +} + +/** + * Makes the content filter field have focus by making it the first responder. + */ +- (void)makeContentFilterHaveFocus +{ + + NSDictionary *filter = [[contentFilters objectForKey:compareType] objectAtIndex:[[compareField selectedItem] tag]]; + + if([filter objectForKey:@"NumberOfArguments"]) { + NSUInteger numOfArgs = [[filter objectForKey:@"NumberOfArguments"] integerValue]; + switch(numOfArgs) { + case 2: + [[tableDocumentInstance parentWindow] makeFirstResponder:firstBetweenField]; + break; + case 1: + [[tableDocumentInstance parentWindow] makeFirstResponder:argumentField]; + break; + default: + [[tableDocumentInstance parentWindow] makeFirstResponder:compareField]; + } + } +} + +#pragma mark - + +// Last but not least +- (void)dealloc +{ + [[NSNotificationCenter defaultCenter] removeObserver:self]; + + [tableValues release]; + pthread_mutex_destroy(&tableValuesLock); + [dataColumns release]; + [oldRow release]; + if (selectedTable) [selectedTable release]; + if (contentFilters) [contentFilters release]; + if (numberOfDefaultFilters) [numberOfDefaultFilters release]; + if (keys) [keys release]; + if (sortCol) [sortCol release]; + [usedQuery release]; + if (sortColumnToRestore) [sortColumnToRestore release]; + if (selectionIndexToRestore) [selectionIndexToRestore release]; + if (filterFieldToRestore) filterFieldToRestore = nil; + if (filterComparisonToRestore) filterComparisonToRestore = nil; + if (filterValueToRestore) filterValueToRestore = nil; + if (firstBetweenValueToRestore) firstBetweenValueToRestore = nil; + if (secondBetweenValueToRestore) secondBetweenValueToRestore = nil; + + [super dealloc]; +} + +@end |